27 #include "oops/oop.inline.hpp" |
27 #include "oops/oop.inline.hpp" |
28 #include "runtime/arguments.hpp" |
28 #include "runtime/arguments.hpp" |
29 #include "runtime/globals.hpp" |
29 #include "runtime/globals.hpp" |
30 #include "runtime/globals_extension.hpp" |
30 #include "runtime/globals_extension.hpp" |
31 #include "runtime/commandLineFlagConstraintList.hpp" |
31 #include "runtime/commandLineFlagConstraintList.hpp" |
|
32 #include "runtime/commandLineFlagWriteableList.hpp" |
32 #include "runtime/commandLineFlagRangeList.hpp" |
33 #include "runtime/commandLineFlagRangeList.hpp" |
33 #include "runtime/os.hpp" |
34 #include "runtime/os.hpp" |
34 #include "runtime/sharedRuntime.hpp" |
35 #include "runtime/sharedRuntime.hpp" |
35 #include "trace/tracing.hpp" |
36 #include "trace/tracing.hpp" |
|
37 #include "utilities/defaultStream.hpp" |
36 #include "utilities/macros.hpp" |
38 #include "utilities/macros.hpp" |
37 #include "utilities/ostream.hpp" |
39 #include "utilities/ostream.hpp" |
38 #if INCLUDE_ALL_GCS |
40 #if INCLUDE_ALL_GCS |
39 #include "gc/g1/g1_globals.hpp" |
41 #include "gc/g1/g1_globals.hpp" |
40 #endif // INCLUDE_ALL_GCS |
42 #endif // INCLUDE_ALL_GCS |
60 MATERIALIZE_NOTPRODUCT_FLAG, \ |
62 MATERIALIZE_NOTPRODUCT_FLAG, \ |
61 MATERIALIZE_MANAGEABLE_FLAG, \ |
63 MATERIALIZE_MANAGEABLE_FLAG, \ |
62 MATERIALIZE_PRODUCT_RW_FLAG, \ |
64 MATERIALIZE_PRODUCT_RW_FLAG, \ |
63 MATERIALIZE_LP64_PRODUCT_FLAG, \ |
65 MATERIALIZE_LP64_PRODUCT_FLAG, \ |
64 IGNORE_RANGE, \ |
66 IGNORE_RANGE, \ |
65 IGNORE_CONSTRAINT) |
67 IGNORE_CONSTRAINT, \ |
|
68 IGNORE_WRITEABLE) |
66 |
69 |
67 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \ |
70 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \ |
68 MATERIALIZE_PD_DEVELOPER_FLAG, \ |
71 MATERIALIZE_PD_DEVELOPER_FLAG, \ |
69 MATERIALIZE_PRODUCT_FLAG, \ |
72 MATERIALIZE_PRODUCT_FLAG, \ |
70 MATERIALIZE_PD_PRODUCT_FLAG, \ |
73 MATERIALIZE_PD_PRODUCT_FLAG, \ |
71 MATERIALIZE_DIAGNOSTIC_FLAG, \ |
74 MATERIALIZE_DIAGNOSTIC_FLAG, \ |
72 MATERIALIZE_NOTPRODUCT_FLAG, \ |
75 MATERIALIZE_NOTPRODUCT_FLAG, \ |
73 IGNORE_RANGE, \ |
76 IGNORE_RANGE, \ |
74 IGNORE_CONSTRAINT) |
77 IGNORE_CONSTRAINT, \ |
|
78 IGNORE_WRITEABLE) |
75 |
79 |
76 ARCH_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \ |
80 ARCH_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \ |
77 MATERIALIZE_PRODUCT_FLAG, \ |
81 MATERIALIZE_PRODUCT_FLAG, \ |
78 MATERIALIZE_DIAGNOSTIC_FLAG, \ |
82 MATERIALIZE_DIAGNOSTIC_FLAG, \ |
79 MATERIALIZE_EXPERIMENTAL_FLAG, \ |
83 MATERIALIZE_EXPERIMENTAL_FLAG, \ |
80 MATERIALIZE_NOTPRODUCT_FLAG, \ |
84 MATERIALIZE_NOTPRODUCT_FLAG, \ |
81 IGNORE_RANGE, \ |
85 IGNORE_RANGE, \ |
82 IGNORE_CONSTRAINT) |
86 IGNORE_CONSTRAINT, \ |
|
87 IGNORE_WRITEABLE) |
83 |
88 |
84 MATERIALIZE_FLAGS_EXT |
89 MATERIALIZE_FLAGS_EXT |
85 |
90 |
86 #define DEFAULT_RANGE_STR_CHUNK_SIZE 64 |
91 #define DEFAULT_RANGE_STR_CHUNK_SIZE 64 |
87 static char* create_range_str(const char *fmt, ...) { |
92 static char* create_range_str(const char *fmt, ...) { |
139 #else |
144 #else |
140 return false; |
145 return false; |
141 #endif |
146 #endif |
142 } |
147 } |
143 |
148 |
144 void Flag::check_writable() { |
149 Flag::Error Flag::check_writable(bool changed) { |
145 if (is_constant_in_binary()) { |
150 if (is_constant_in_binary()) { |
146 fatal("flag is constant: %s", _name); |
151 fatal("flag is constant: %s", _name); |
147 } |
152 } |
|
153 |
|
154 Flag::Error error = Flag::SUCCESS; |
|
155 if (changed) { |
|
156 CommandLineFlagWriteable* writeable = CommandLineFlagWriteableList::find(_name); |
|
157 if (writeable) { |
|
158 if (writeable->is_writeable() == false) { |
|
159 switch (writeable->type()) |
|
160 { |
|
161 case CommandLineFlagWriteable::Once: |
|
162 error = Flag::SET_ONLY_ONCE; |
|
163 jio_fprintf(defaultStream::error_stream(), "Error: %s may not be set more than once\n", _name); |
|
164 break; |
|
165 case CommandLineFlagWriteable::CommandLineOnly: |
|
166 error = Flag::COMMAND_LINE_ONLY; |
|
167 jio_fprintf(defaultStream::error_stream(), "Error: %s may be modified only from commad line\n", _name); |
|
168 break; |
|
169 default: |
|
170 ShouldNotReachHere(); |
|
171 break; |
|
172 } |
|
173 } |
|
174 writeable->mark_once(); |
|
175 } |
|
176 } |
|
177 return error; |
148 } |
178 } |
149 |
179 |
150 bool Flag::is_bool() const { |
180 bool Flag::is_bool() const { |
151 return strcmp(_type, "bool") == 0; |
181 return strcmp(_type, "bool") == 0; |
152 } |
182 } |
153 |
183 |
154 bool Flag::get_bool() const { |
184 bool Flag::get_bool() const { |
155 return *((bool*) _addr); |
185 return *((bool*) _addr); |
156 } |
186 } |
157 |
187 |
158 void Flag::set_bool(bool value) { |
188 Flag::Error Flag::set_bool(bool value) { |
159 check_writable(); |
189 Flag::Error error = check_writable(value!=get_bool()); |
160 *((bool*) _addr) = value; |
190 if (error == Flag::SUCCESS) { |
|
191 *((bool*) _addr) = value; |
|
192 } |
|
193 return error; |
161 } |
194 } |
162 |
195 |
163 bool Flag::is_int() const { |
196 bool Flag::is_int() const { |
164 return strcmp(_type, "int") == 0; |
197 return strcmp(_type, "int") == 0; |
165 } |
198 } |
166 |
199 |
167 int Flag::get_int() const { |
200 int Flag::get_int() const { |
168 return *((int*) _addr); |
201 return *((int*) _addr); |
169 } |
202 } |
170 |
203 |
171 void Flag::set_int(int value) { |
204 Flag::Error Flag::set_int(int value) { |
172 check_writable(); |
205 Flag::Error error = check_writable(value!=get_int()); |
173 *((int*) _addr) = value; |
206 if (error == Flag::SUCCESS) { |
|
207 *((int*) _addr) = value; |
|
208 } |
|
209 return error; |
174 } |
210 } |
175 |
211 |
176 bool Flag::is_uint() const { |
212 bool Flag::is_uint() const { |
177 return strcmp(_type, "uint") == 0; |
213 return strcmp(_type, "uint") == 0; |
178 } |
214 } |
179 |
215 |
180 uint Flag::get_uint() const { |
216 uint Flag::get_uint() const { |
181 return *((uint*) _addr); |
217 return *((uint*) _addr); |
182 } |
218 } |
183 |
219 |
184 void Flag::set_uint(uint value) { |
220 Flag::Error Flag::set_uint(uint value) { |
185 check_writable(); |
221 Flag::Error error = check_writable(value!=get_uint()); |
186 *((uint*) _addr) = value; |
222 if (error == Flag::SUCCESS) { |
|
223 *((uint*) _addr) = value; |
|
224 } |
|
225 return error; |
187 } |
226 } |
188 |
227 |
189 bool Flag::is_intx() const { |
228 bool Flag::is_intx() const { |
190 return strcmp(_type, "intx") == 0; |
229 return strcmp(_type, "intx") == 0; |
191 } |
230 } |
192 |
231 |
193 intx Flag::get_intx() const { |
232 intx Flag::get_intx() const { |
194 return *((intx*) _addr); |
233 return *((intx*) _addr); |
195 } |
234 } |
196 |
235 |
197 void Flag::set_intx(intx value) { |
236 Flag::Error Flag::set_intx(intx value) { |
198 check_writable(); |
237 Flag::Error error = check_writable(value!=get_intx()); |
199 *((intx*) _addr) = value; |
238 if (error == Flag::SUCCESS) { |
|
239 *((intx*) _addr) = value; |
|
240 } |
|
241 return error; |
200 } |
242 } |
201 |
243 |
202 bool Flag::is_uintx() const { |
244 bool Flag::is_uintx() const { |
203 return strcmp(_type, "uintx") == 0; |
245 return strcmp(_type, "uintx") == 0; |
204 } |
246 } |
205 |
247 |
206 uintx Flag::get_uintx() const { |
248 uintx Flag::get_uintx() const { |
207 return *((uintx*) _addr); |
249 return *((uintx*) _addr); |
208 } |
250 } |
209 |
251 |
210 void Flag::set_uintx(uintx value) { |
252 Flag::Error Flag::set_uintx(uintx value) { |
211 check_writable(); |
253 Flag::Error error = check_writable(value!=get_uintx()); |
212 *((uintx*) _addr) = value; |
254 if (error == Flag::SUCCESS) { |
|
255 *((uintx*) _addr) = value; |
|
256 } |
|
257 return error; |
213 } |
258 } |
214 |
259 |
215 bool Flag::is_uint64_t() const { |
260 bool Flag::is_uint64_t() const { |
216 return strcmp(_type, "uint64_t") == 0; |
261 return strcmp(_type, "uint64_t") == 0; |
217 } |
262 } |
218 |
263 |
219 uint64_t Flag::get_uint64_t() const { |
264 uint64_t Flag::get_uint64_t() const { |
220 return *((uint64_t*) _addr); |
265 return *((uint64_t*) _addr); |
221 } |
266 } |
222 |
267 |
223 void Flag::set_uint64_t(uint64_t value) { |
268 Flag::Error Flag::set_uint64_t(uint64_t value) { |
224 check_writable(); |
269 Flag::Error error = check_writable(value!=get_uint64_t()); |
225 *((uint64_t*) _addr) = value; |
270 if (error == Flag::SUCCESS) { |
|
271 *((uint64_t*) _addr) = value; |
|
272 } |
|
273 return error; |
226 } |
274 } |
227 |
275 |
228 bool Flag::is_size_t() const { |
276 bool Flag::is_size_t() const { |
229 return strcmp(_type, "size_t") == 0; |
277 return strcmp(_type, "size_t") == 0; |
230 } |
278 } |
231 |
279 |
232 size_t Flag::get_size_t() const { |
280 size_t Flag::get_size_t() const { |
233 return *((size_t*) _addr); |
281 return *((size_t*) _addr); |
234 } |
282 } |
235 |
283 |
236 void Flag::set_size_t(size_t value) { |
284 Flag::Error Flag::set_size_t(size_t value) { |
237 check_writable(); |
285 Flag::Error error = check_writable(value!=get_size_t()); |
238 *((size_t*) _addr) = value; |
286 if (error == Flag::SUCCESS) { |
|
287 *((size_t*) _addr) = value; |
|
288 } |
|
289 return error; |
239 } |
290 } |
240 |
291 |
241 bool Flag::is_double() const { |
292 bool Flag::is_double() const { |
242 return strcmp(_type, "double") == 0; |
293 return strcmp(_type, "double") == 0; |
243 } |
294 } |
244 |
295 |
245 double Flag::get_double() const { |
296 double Flag::get_double() const { |
246 return *((double*) _addr); |
297 return *((double*) _addr); |
247 } |
298 } |
248 |
299 |
249 void Flag::set_double(double value) { |
300 Flag::Error Flag::set_double(double value) { |
250 check_writable(); |
301 Flag::Error error = check_writable(value!=get_double()); |
251 *((double*) _addr) = value; |
302 if (error == Flag::SUCCESS) { |
|
303 *((double*) _addr) = value; |
|
304 } |
|
305 return error; |
252 } |
306 } |
253 |
307 |
254 bool Flag::is_ccstr() const { |
308 bool Flag::is_ccstr() const { |
255 return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0; |
309 return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0; |
256 } |
310 } |
652 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ |
709 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ |
653 RUNTIME_MANAGEABLE_FLAG_STRUCT, \ |
710 RUNTIME_MANAGEABLE_FLAG_STRUCT, \ |
654 RUNTIME_PRODUCT_RW_FLAG_STRUCT, \ |
711 RUNTIME_PRODUCT_RW_FLAG_STRUCT, \ |
655 RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \ |
712 RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \ |
656 IGNORE_RANGE, \ |
713 IGNORE_RANGE, \ |
657 IGNORE_CONSTRAINT) |
714 IGNORE_CONSTRAINT, \ |
|
715 IGNORE_WRITEABLE) |
658 RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \ |
716 RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \ |
659 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \ |
717 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \ |
660 RUNTIME_PRODUCT_FLAG_STRUCT, \ |
718 RUNTIME_PRODUCT_FLAG_STRUCT, \ |
661 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \ |
719 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \ |
662 RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \ |
720 RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \ |
663 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ |
721 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ |
664 IGNORE_RANGE, \ |
722 IGNORE_RANGE, \ |
665 IGNORE_CONSTRAINT) |
723 IGNORE_CONSTRAINT, \ |
|
724 IGNORE_WRITEABLE) |
666 #if INCLUDE_ALL_GCS |
725 #if INCLUDE_ALL_GCS |
667 G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \ |
726 G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \ |
668 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \ |
727 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \ |
669 RUNTIME_PRODUCT_FLAG_STRUCT, \ |
728 RUNTIME_PRODUCT_FLAG_STRUCT, \ |
670 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \ |
729 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \ |
672 RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \ |
731 RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \ |
673 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ |
732 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \ |
674 RUNTIME_MANAGEABLE_FLAG_STRUCT, \ |
733 RUNTIME_MANAGEABLE_FLAG_STRUCT, \ |
675 RUNTIME_PRODUCT_RW_FLAG_STRUCT, \ |
734 RUNTIME_PRODUCT_RW_FLAG_STRUCT, \ |
676 IGNORE_RANGE, \ |
735 IGNORE_RANGE, \ |
677 IGNORE_CONSTRAINT) |
736 IGNORE_CONSTRAINT, \ |
|
737 IGNORE_WRITEABLE) |
678 #endif // INCLUDE_ALL_GCS |
738 #endif // INCLUDE_ALL_GCS |
679 #if INCLUDE_JVMCI |
739 #if INCLUDE_JVMCI |
680 JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_STRUCT, \ |
740 JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_STRUCT, \ |
681 JVMCI_PD_DEVELOP_FLAG_STRUCT, \ |
741 JVMCI_PD_DEVELOP_FLAG_STRUCT, \ |
682 JVMCI_PRODUCT_FLAG_STRUCT, \ |
742 JVMCI_PRODUCT_FLAG_STRUCT, \ |
683 JVMCI_PD_PRODUCT_FLAG_STRUCT, \ |
743 JVMCI_PD_PRODUCT_FLAG_STRUCT, \ |
684 JVMCI_DIAGNOSTIC_FLAG_STRUCT, \ |
744 JVMCI_DIAGNOSTIC_FLAG_STRUCT, \ |
685 JVMCI_EXPERIMENTAL_FLAG_STRUCT, \ |
745 JVMCI_EXPERIMENTAL_FLAG_STRUCT, \ |
686 JVMCI_NOTPRODUCT_FLAG_STRUCT, \ |
746 JVMCI_NOTPRODUCT_FLAG_STRUCT, \ |
687 IGNORE_RANGE, \ |
747 IGNORE_RANGE, \ |
688 IGNORE_CONSTRAINT) |
748 IGNORE_CONSTRAINT, \ |
|
749 IGNORE_WRITEABLE) |
689 #endif // INCLUDE_JVMCI |
750 #endif // INCLUDE_JVMCI |
690 #ifdef COMPILER1 |
751 #ifdef COMPILER1 |
691 C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, \ |
752 C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, \ |
692 C1_PD_DEVELOP_FLAG_STRUCT, \ |
753 C1_PD_DEVELOP_FLAG_STRUCT, \ |
693 C1_PRODUCT_FLAG_STRUCT, \ |
754 C1_PRODUCT_FLAG_STRUCT, \ |
694 C1_PD_PRODUCT_FLAG_STRUCT, \ |
755 C1_PD_PRODUCT_FLAG_STRUCT, \ |
695 C1_DIAGNOSTIC_FLAG_STRUCT, \ |
756 C1_DIAGNOSTIC_FLAG_STRUCT, \ |
696 C1_NOTPRODUCT_FLAG_STRUCT, \ |
757 C1_NOTPRODUCT_FLAG_STRUCT, \ |
697 IGNORE_RANGE, \ |
758 IGNORE_RANGE, \ |
698 IGNORE_CONSTRAINT) |
759 IGNORE_CONSTRAINT, \ |
|
760 IGNORE_WRITEABLE) |
699 #endif // COMPILER1 |
761 #endif // COMPILER1 |
700 #ifdef COMPILER2 |
762 #ifdef COMPILER2 |
701 C2_FLAGS(C2_DEVELOP_FLAG_STRUCT, \ |
763 C2_FLAGS(C2_DEVELOP_FLAG_STRUCT, \ |
702 C2_PD_DEVELOP_FLAG_STRUCT, \ |
764 C2_PD_DEVELOP_FLAG_STRUCT, \ |
703 C2_PRODUCT_FLAG_STRUCT, \ |
765 C2_PRODUCT_FLAG_STRUCT, \ |
704 C2_PD_PRODUCT_FLAG_STRUCT, \ |
766 C2_PD_PRODUCT_FLAG_STRUCT, \ |
705 C2_DIAGNOSTIC_FLAG_STRUCT, \ |
767 C2_DIAGNOSTIC_FLAG_STRUCT, \ |
706 C2_EXPERIMENTAL_FLAG_STRUCT, \ |
768 C2_EXPERIMENTAL_FLAG_STRUCT, \ |
707 C2_NOTPRODUCT_FLAG_STRUCT, \ |
769 C2_NOTPRODUCT_FLAG_STRUCT, \ |
708 IGNORE_RANGE, \ |
770 IGNORE_RANGE, \ |
709 IGNORE_CONSTRAINT) |
771 IGNORE_CONSTRAINT, \ |
|
772 IGNORE_WRITEABLE) |
710 #endif // COMPILER2 |
773 #endif // COMPILER2 |
711 #ifdef SHARK |
774 #ifdef SHARK |
712 SHARK_FLAGS(SHARK_DEVELOP_FLAG_STRUCT, \ |
775 SHARK_FLAGS(SHARK_DEVELOP_FLAG_STRUCT, \ |
713 SHARK_PD_DEVELOP_FLAG_STRUCT, \ |
776 SHARK_PD_DEVELOP_FLAG_STRUCT, \ |
714 SHARK_PRODUCT_FLAG_STRUCT, \ |
777 SHARK_PRODUCT_FLAG_STRUCT, \ |
715 SHARK_PD_PRODUCT_FLAG_STRUCT, \ |
778 SHARK_PD_PRODUCT_FLAG_STRUCT, \ |
716 SHARK_DIAGNOSTIC_FLAG_STRUCT, \ |
779 SHARK_DIAGNOSTIC_FLAG_STRUCT, \ |
717 SHARK_NOTPRODUCT_FLAG_STRUCT) |
780 SHARK_NOTPRODUCT_FLAG_STRUCT, \ |
|
781 IGNORE_RANGE, \ |
|
782 IGNORE_CONSTRAINT, \ |
|
783 IGNORE_WRITEABLE) |
718 #endif // SHARK |
784 #endif // SHARK |
719 ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, \ |
785 ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, \ |
720 ARCH_PRODUCT_FLAG_STRUCT, \ |
786 ARCH_PRODUCT_FLAG_STRUCT, \ |
721 ARCH_DIAGNOSTIC_FLAG_STRUCT, \ |
787 ARCH_DIAGNOSTIC_FLAG_STRUCT, \ |
722 ARCH_EXPERIMENTAL_FLAG_STRUCT, \ |
788 ARCH_EXPERIMENTAL_FLAG_STRUCT, \ |
723 ARCH_NOTPRODUCT_FLAG_STRUCT, \ |
789 ARCH_NOTPRODUCT_FLAG_STRUCT, \ |
724 IGNORE_RANGE, \ |
790 IGNORE_RANGE, \ |
725 IGNORE_CONSTRAINT) |
791 IGNORE_CONSTRAINT, \ |
|
792 IGNORE_WRITEABLE) |
726 FLAGTABLE_EXT |
793 FLAGTABLE_EXT |
727 {0, NULL, NULL} |
794 {0, NULL, NULL} |
728 }; |
795 }; |
729 |
796 |
730 Flag* Flag::flags = flagTable; |
797 Flag* Flag::flags = flagTable; |
871 name = flag->_name; |
938 name = flag->_name; |
872 Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
939 Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
873 if (check != Flag::SUCCESS) return check; |
940 if (check != Flag::SUCCESS) return check; |
874 bool old_value = flag->get_bool(); |
941 bool old_value = flag->get_bool(); |
875 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin); |
942 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin); |
876 flag->set_bool(*value); |
943 check = flag->set_bool(*value); |
877 *value = old_value; |
944 *value = old_value; |
878 flag->set_origin(origin); |
945 flag->set_origin(origin); |
879 return Flag::SUCCESS; |
946 return check; |
880 } |
947 } |
881 |
948 |
882 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) { |
949 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) { |
883 Flag* result = Flag::find_flag(name, len); |
950 Flag* result = Flag::find_flag(name, len); |
884 return boolAtPut(result, value, origin); |
951 return boolAtPut(result, value, origin); |
920 name = flag->_name; |
987 name = flag->_name; |
921 Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
988 Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
922 if (check != Flag::SUCCESS) return check; |
989 if (check != Flag::SUCCESS) return check; |
923 int old_value = flag->get_int(); |
990 int old_value = flag->get_int(); |
924 trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin); |
991 trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin); |
925 flag->set_int(*value); |
992 check = flag->set_int(*value); |
926 *value = old_value; |
993 *value = old_value; |
927 flag->set_origin(origin); |
994 flag->set_origin(origin); |
928 return Flag::SUCCESS; |
995 return check; |
929 } |
996 } |
930 |
997 |
931 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) { |
998 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) { |
932 Flag* result = Flag::find_flag(name, len); |
999 Flag* result = Flag::find_flag(name, len); |
933 return intAtPut(result, value, origin); |
1000 return intAtPut(result, value, origin); |
969 name = flag->_name; |
1036 name = flag->_name; |
970 Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1037 Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
971 if (check != Flag::SUCCESS) return check; |
1038 if (check != Flag::SUCCESS) return check; |
972 uint old_value = flag->get_uint(); |
1039 uint old_value = flag->get_uint(); |
973 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin); |
1040 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin); |
974 flag->set_uint(*value); |
1041 check = flag->set_uint(*value); |
975 *value = old_value; |
1042 *value = old_value; |
976 flag->set_origin(origin); |
1043 flag->set_origin(origin); |
977 return Flag::SUCCESS; |
1044 return check; |
978 } |
1045 } |
979 |
1046 |
980 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) { |
1047 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) { |
981 Flag* result = Flag::find_flag(name, len); |
1048 Flag* result = Flag::find_flag(name, len); |
982 return uintAtPut(result, value, origin); |
1049 return uintAtPut(result, value, origin); |
1018 name = flag->_name; |
1085 name = flag->_name; |
1019 Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1086 Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1020 if (check != Flag::SUCCESS) return check; |
1087 if (check != Flag::SUCCESS) return check; |
1021 intx old_value = flag->get_intx(); |
1088 intx old_value = flag->get_intx(); |
1022 trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin); |
1089 trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin); |
1023 flag->set_intx(*value); |
1090 check = flag->set_intx(*value); |
1024 *value = old_value; |
1091 *value = old_value; |
1025 flag->set_origin(origin); |
1092 flag->set_origin(origin); |
1026 return Flag::SUCCESS; |
1093 return check; |
1027 } |
1094 } |
1028 |
1095 |
1029 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) { |
1096 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) { |
1030 Flag* result = Flag::find_flag(name, len); |
1097 Flag* result = Flag::find_flag(name, len); |
1031 return intxAtPut(result, value, origin); |
1098 return intxAtPut(result, value, origin); |
1067 name = flag->_name; |
1134 name = flag->_name; |
1068 Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1135 Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1069 if (check != Flag::SUCCESS) return check; |
1136 if (check != Flag::SUCCESS) return check; |
1070 uintx old_value = flag->get_uintx(); |
1137 uintx old_value = flag->get_uintx(); |
1071 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1138 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1072 flag->set_uintx(*value); |
1139 check = flag->set_uintx(*value); |
1073 *value = old_value; |
1140 *value = old_value; |
1074 flag->set_origin(origin); |
1141 flag->set_origin(origin); |
1075 return Flag::SUCCESS; |
1142 return check; |
1076 } |
1143 } |
1077 |
1144 |
1078 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) { |
1145 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) { |
1079 Flag* result = Flag::find_flag(name, len); |
1146 Flag* result = Flag::find_flag(name, len); |
1080 return uintxAtPut(result, value, origin); |
1147 return uintxAtPut(result, value, origin); |
1116 name = flag->_name; |
1183 name = flag->_name; |
1117 Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1184 Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1118 if (check != Flag::SUCCESS) return check; |
1185 if (check != Flag::SUCCESS) return check; |
1119 uint64_t old_value = flag->get_uint64_t(); |
1186 uint64_t old_value = flag->get_uint64_t(); |
1120 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1187 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1121 flag->set_uint64_t(*value); |
1188 check = flag->set_uint64_t(*value); |
1122 *value = old_value; |
1189 *value = old_value; |
1123 flag->set_origin(origin); |
1190 flag->set_origin(origin); |
1124 return Flag::SUCCESS; |
1191 return check; |
1125 } |
1192 } |
1126 |
1193 |
1127 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) { |
1194 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) { |
1128 Flag* result = Flag::find_flag(name, len); |
1195 Flag* result = Flag::find_flag(name, len); |
1129 return uint64_tAtPut(result, value, origin); |
1196 return uint64_tAtPut(result, value, origin); |
1166 name = flag->_name; |
1233 name = flag->_name; |
1167 Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1234 Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1168 if (check != Flag::SUCCESS) return check; |
1235 if (check != Flag::SUCCESS) return check; |
1169 size_t old_value = flag->get_size_t(); |
1236 size_t old_value = flag->get_size_t(); |
1170 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1237 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1171 flag->set_size_t(*value); |
1238 check = flag->set_size_t(*value); |
1172 *value = old_value; |
1239 *value = old_value; |
1173 flag->set_origin(origin); |
1240 flag->set_origin(origin); |
1174 return Flag::SUCCESS; |
1241 return check; |
1175 } |
1242 } |
1176 |
1243 |
1177 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) { |
1244 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) { |
1178 Flag* result = Flag::find_flag(name, len); |
1245 Flag* result = Flag::find_flag(name, len); |
1179 return size_tAtPut(result, value, origin); |
1246 return size_tAtPut(result, value, origin); |
1215 name = flag->_name; |
1282 name = flag->_name; |
1216 Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1283 Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); |
1217 if (check != Flag::SUCCESS) return check; |
1284 if (check != Flag::SUCCESS) return check; |
1218 double old_value = flag->get_double(); |
1285 double old_value = flag->get_double(); |
1219 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin); |
1286 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin); |
1220 flag->set_double(*value); |
1287 check = flag->set_double(*value); |
1221 *value = old_value; |
1288 *value = old_value; |
1222 flag->set_origin(origin); |
1289 flag->set_origin(origin); |
1223 return Flag::SUCCESS; |
1290 return check; |
1224 } |
1291 } |
1225 |
1292 |
1226 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) { |
1293 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) { |
1227 Flag* result = Flag::find_flag(name, len); |
1294 Flag* result = Flag::find_flag(name, len); |
1228 return doubleAtPut(result, value, origin); |
1295 return doubleAtPut(result, value, origin); |
1250 trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin); |
1317 trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin); |
1251 char* new_value = NULL; |
1318 char* new_value = NULL; |
1252 if (*value != NULL) { |
1319 if (*value != NULL) { |
1253 new_value = os::strdup_check_oom(*value); |
1320 new_value = os::strdup_check_oom(*value); |
1254 } |
1321 } |
1255 result->set_ccstr(new_value); |
1322 Flag::Error check = result->set_ccstr(new_value); |
1256 if (result->is_default() && old_value != NULL) { |
1323 if (result->is_default() && old_value != NULL) { |
1257 // Prior value is NOT heap allocated, but was a literal constant. |
1324 // Prior value is NOT heap allocated, but was a literal constant. |
1258 old_value = os::strdup_check_oom(old_value); |
1325 old_value = os::strdup_check_oom(old_value); |
1259 } |
1326 } |
1260 *value = old_value; |
1327 *value = old_value; |
1261 result->set_origin(origin); |
1328 result->set_origin(origin); |
1262 return Flag::SUCCESS; |
1329 return check; |
1263 } |
1330 } |
1264 |
1331 |
1265 Flag::Error CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) { |
1332 Flag::Error CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) { |
1266 Flag* faddr = address_of_flag(flag); |
1333 Flag* faddr = address_of_flag(flag); |
1267 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); |
1334 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); |
1268 ccstr old_value = faddr->get_ccstr(); |
1335 ccstr old_value = faddr->get_ccstr(); |
1269 trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin); |
1336 trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin); |
1270 char* new_value = os::strdup_check_oom(value); |
1337 char* new_value = os::strdup_check_oom(value); |
1271 faddr->set_ccstr(new_value); |
1338 Flag::Error check = faddr->set_ccstr(new_value); |
1272 if (!faddr->is_default() && old_value != NULL) { |
1339 if (!faddr->is_default() && old_value != NULL) { |
1273 // Prior value is heap allocated so free it. |
1340 // Prior value is heap allocated so free it. |
1274 FREE_C_HEAP_ARRAY(char, old_value); |
1341 FREE_C_HEAP_ARRAY(char, old_value); |
1275 } |
1342 } |
1276 faddr->set_origin(origin); |
1343 faddr->set_origin(origin); |
1277 return Flag::SUCCESS; |
1344 return check; |
1278 } |
1345 } |
1279 |
1346 |
1280 extern "C" { |
1347 extern "C" { |
1281 static int compare_flags(const void* void_a, const void* void_b) { |
1348 static int compare_flags(const void* void_a, const void* void_b) { |
1282 return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name); |
1349 return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name); |