1 /*
2 * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "jvm.h"
27 #include "memory/allocation.inline.hpp"
28 #include "oops/oop.inline.hpp"
29 #include "runtime/arguments.hpp"
30 #include "runtime/globals.hpp"
31 #include "runtime/globals_extension.hpp"
32 #include "runtime/commandLineFlagConstraintList.hpp"
33 #include "runtime/commandLineFlagWriteableList.hpp"
34 #include "runtime/commandLineFlagRangeList.hpp"
35 #include "runtime/os.hpp"
36 #include "runtime/sharedRuntime.hpp"
37 #include "trace/tracing.hpp"
38 #include "utilities/defaultStream.hpp"
39 #include "utilities/macros.hpp"
40 #include "utilities/ostream.hpp"
41 #include "utilities/stringUtils.hpp"
42 #if INCLUDE_ALL_GCS
43 #include "gc/g1/g1_globals.hpp"
44 #endif // INCLUDE_ALL_GCS
45 #ifdef COMPILER1
46 #include "c1/c1_globals.hpp"
47 #endif
48 #if INCLUDE_JVMCI
49 #include "jvmci/jvmci_globals.hpp"
50 #endif
51 #ifdef COMPILER2
52 #include "opto/c2_globals.hpp"
53 #endif
54
55 RUNTIME_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
56 MATERIALIZE_PD_DEVELOPER_FLAG, \
57 MATERIALIZE_PRODUCT_FLAG, \
58 MATERIALIZE_PD_PRODUCT_FLAG, \
59 MATERIALIZE_DIAGNOSTIC_FLAG, \
60 MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
61 MATERIALIZE_EXPERIMENTAL_FLAG, \
62 MATERIALIZE_NOTPRODUCT_FLAG, \
63 MATERIALIZE_MANAGEABLE_FLAG, \
64 MATERIALIZE_PRODUCT_RW_FLAG, \
65 MATERIALIZE_LP64_PRODUCT_FLAG, \
66 IGNORE_RANGE, \
67 IGNORE_CONSTRAINT, \
68 IGNORE_WRITEABLE)
69
70 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
71 MATERIALIZE_PD_DEVELOPER_FLAG, \
72 MATERIALIZE_PRODUCT_FLAG, \
73 MATERIALIZE_PD_PRODUCT_FLAG, \
74 MATERIALIZE_DIAGNOSTIC_FLAG, \
75 MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
76 MATERIALIZE_NOTPRODUCT_FLAG, \
77 IGNORE_RANGE, \
78 IGNORE_CONSTRAINT, \
79 IGNORE_WRITEABLE)
80
81 ARCH_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
82 MATERIALIZE_PRODUCT_FLAG, \
83 MATERIALIZE_DIAGNOSTIC_FLAG, \
84 MATERIALIZE_EXPERIMENTAL_FLAG, \
85 MATERIALIZE_NOTPRODUCT_FLAG, \
86 IGNORE_RANGE, \
87 IGNORE_CONSTRAINT, \
88 IGNORE_WRITEABLE)
89
90 MATERIALIZE_FLAGS_EXT
91
92 #define DEFAULT_RANGE_STR_CHUNK_SIZE 64
93 static char* create_range_str(const char *fmt, ...) {
94 static size_t string_length = DEFAULT_RANGE_STR_CHUNK_SIZE;
95 static char* range_string = NEW_C_HEAP_ARRAY(char, string_length, mtLogging);
96
97 int size_needed = 0;
98 do {
99 va_list args;
100 va_start(args, fmt);
101 size_needed = jio_vsnprintf(range_string, string_length, fmt, args);
102 va_end(args);
103
104 if (size_needed < 0) {
105 string_length += DEFAULT_RANGE_STR_CHUNK_SIZE;
106 range_string = REALLOC_C_HEAP_ARRAY(char, range_string, string_length, mtLogging);
107 guarantee(range_string != NULL, "create_range_str string should not be NULL");
108 }
109 } while (size_needed < 0);
110
111 return range_string;
112 }
113
114 const char* Flag::get_int_default_range_str() {
115 return create_range_str("[ " INT32_FORMAT_W(-25) " ... " INT32_FORMAT_W(25) " ]", INT_MIN, INT_MAX);
116 }
117
118 const char* Flag::get_uint_default_range_str() {
119 return create_range_str("[ " UINT32_FORMAT_W(-25) " ... " UINT32_FORMAT_W(25) " ]", 0, UINT_MAX);
120 }
121
122 const char* Flag::get_intx_default_range_str() {
123 return create_range_str("[ " INTX_FORMAT_W(-25) " ... " INTX_FORMAT_W(25) " ]", min_intx, max_intx);
124 }
125
126 const char* Flag::get_uintx_default_range_str() {
127 return create_range_str("[ " UINTX_FORMAT_W(-25) " ... " UINTX_FORMAT_W(25) " ]", 0, max_uintx);
128 }
129
130 const char* Flag::get_uint64_t_default_range_str() {
131 return create_range_str("[ " UINT64_FORMAT_W(-25) " ... " UINT64_FORMAT_W(25) " ]", 0, uint64_t(max_juint));
132 }
133
134 const char* Flag::get_size_t_default_range_str() {
135 return create_range_str("[ " SIZE_FORMAT_W(-25) " ... " SIZE_FORMAT_W(25) " ]", 0, SIZE_MAX);
136 }
137
138 const char* Flag::get_double_default_range_str() {
139 return create_range_str("[ %-25.3f ... %25.3f ]", DBL_MIN, DBL_MAX);
140 }
141
142 static bool is_product_build() {
143 #ifdef PRODUCT
144 return true;
145 #else
146 return false;
147 #endif
148 }
149
150 Flag::Error Flag::check_writable(bool changed) {
151 if (is_constant_in_binary()) {
152 fatal("flag is constant: %s", _name);
153 }
154
155 Flag::Error error = Flag::SUCCESS;
156 if (changed) {
157 CommandLineFlagWriteable* writeable = CommandLineFlagWriteableList::find(_name);
158 if (writeable) {
159 if (writeable->is_writeable() == false) {
160 switch (writeable->type())
161 {
162 case CommandLineFlagWriteable::Once:
163 error = Flag::SET_ONLY_ONCE;
164 jio_fprintf(defaultStream::error_stream(), "Error: %s may not be set more than once\n", _name);
165 break;
166 case CommandLineFlagWriteable::CommandLineOnly:
167 error = Flag::COMMAND_LINE_ONLY;
168 jio_fprintf(defaultStream::error_stream(), "Error: %s may be modified only from commad line\n", _name);
169 break;
170 default:
171 ShouldNotReachHere();
172 break;
173 }
174 }
175 writeable->mark_once();
176 }
177 }
178 return error;
179 }
180
181 bool Flag::is_bool() const {
182 return strcmp(_type, "bool") == 0;
183 }
184
185 bool Flag::get_bool() const {
186 return *((bool*) _addr);
187 }
188
189 Flag::Error Flag::set_bool(bool value) {
190 Flag::Error error = check_writable(value!=get_bool());
191 if (error == Flag::SUCCESS) {
192 *((bool*) _addr) = value;
193 }
194 return error;
195 }
196
197 bool Flag::is_int() const {
198 return strcmp(_type, "int") == 0;
199 }
200
201 int Flag::get_int() const {
202 return *((int*) _addr);
203 }
204
205 Flag::Error Flag::set_int(int value) {
206 Flag::Error error = check_writable(value!=get_int());
207 if (error == Flag::SUCCESS) {
208 *((int*) _addr) = value;
209 }
210 return error;
211 }
212
213 bool Flag::is_uint() const {
214 return strcmp(_type, "uint") == 0;
215 }
216
217 uint Flag::get_uint() const {
218 return *((uint*) _addr);
219 }
220
221 Flag::Error Flag::set_uint(uint value) {
222 Flag::Error error = check_writable(value!=get_uint());
223 if (error == Flag::SUCCESS) {
224 *((uint*) _addr) = value;
225 }
226 return error;
227 }
228
229 bool Flag::is_intx() const {
230 return strcmp(_type, "intx") == 0;
231 }
232
233 intx Flag::get_intx() const {
234 return *((intx*) _addr);
235 }
236
237 Flag::Error Flag::set_intx(intx value) {
238 Flag::Error error = check_writable(value!=get_intx());
239 if (error == Flag::SUCCESS) {
240 *((intx*) _addr) = value;
241 }
242 return error;
243 }
244
245 bool Flag::is_uintx() const {
246 return strcmp(_type, "uintx") == 0;
247 }
248
249 uintx Flag::get_uintx() const {
250 return *((uintx*) _addr);
251 }
252
253 Flag::Error Flag::set_uintx(uintx value) {
254 Flag::Error error = check_writable(value!=get_uintx());
255 if (error == Flag::SUCCESS) {
256 *((uintx*) _addr) = value;
257 }
258 return error;
259 }
260
261 bool Flag::is_uint64_t() const {
262 return strcmp(_type, "uint64_t") == 0;
263 }
264
265 uint64_t Flag::get_uint64_t() const {
266 return *((uint64_t*) _addr);
267 }
268
269 Flag::Error Flag::set_uint64_t(uint64_t value) {
270 Flag::Error error = check_writable(value!=get_uint64_t());
271 if (error == Flag::SUCCESS) {
272 *((uint64_t*) _addr) = value;
273 }
274 return error;
275 }
276
277 bool Flag::is_size_t() const {
278 return strcmp(_type, "size_t") == 0;
279 }
280
281 size_t Flag::get_size_t() const {
282 return *((size_t*) _addr);
283 }
284
285 Flag::Error Flag::set_size_t(size_t value) {
286 Flag::Error error = check_writable(value!=get_size_t());
287 if (error == Flag::SUCCESS) {
288 *((size_t*) _addr) = value;
289 }
290 return error;
291 }
292
293 bool Flag::is_double() const {
294 return strcmp(_type, "double") == 0;
295 }
296
297 double Flag::get_double() const {
298 return *((double*) _addr);
299 }
300
301 Flag::Error Flag::set_double(double value) {
302 Flag::Error error = check_writable(value!=get_double());
303 if (error == Flag::SUCCESS) {
304 *((double*) _addr) = value;
305 }
306 return error;
307 }
308
309 bool Flag::is_ccstr() const {
310 return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0;
311 }
312
313 bool Flag::ccstr_accumulates() const {
314 return strcmp(_type, "ccstrlist") == 0;
315 }
316
317 ccstr Flag::get_ccstr() const {
318 return *((ccstr*) _addr);
319 }
320
321 Flag::Error Flag::set_ccstr(ccstr value) {
322 Flag::Error error = check_writable(value!=get_ccstr());
323 if (error == Flag::SUCCESS) {
324 *((ccstr*) _addr) = value;
325 }
326 return error;
327 }
328
329
330 Flag::Flags Flag::get_origin() {
331 return Flags(_flags & VALUE_ORIGIN_MASK);
332 }
333
334 void Flag::set_origin(Flags origin) {
335 assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity");
336 Flags new_origin = Flags((origin == COMMAND_LINE) ? Flags(origin | ORIG_COMMAND_LINE) : origin);
337 _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | new_origin);
338 }
339
340 bool Flag::is_default() {
341 return (get_origin() == DEFAULT);
342 }
343
344 bool Flag::is_ergonomic() {
345 return (get_origin() == ERGONOMIC);
346 }
347
348 bool Flag::is_command_line() {
349 return (_flags & ORIG_COMMAND_LINE) != 0;
350 }
351
352 void Flag::set_command_line() {
353 _flags = Flags(_flags | ORIG_COMMAND_LINE);
354 }
355
356 bool Flag::is_product() const {
357 return (_flags & KIND_PRODUCT) != 0;
358 }
359
360 bool Flag::is_manageable() const {
361 return (_flags & KIND_MANAGEABLE) != 0;
362 }
363
364 bool Flag::is_diagnostic() const {
365 return (_flags & KIND_DIAGNOSTIC) != 0;
366 }
367
368 bool Flag::is_experimental() const {
369 return (_flags & KIND_EXPERIMENTAL) != 0;
370 }
371
372 bool Flag::is_notproduct() const {
373 return (_flags & KIND_NOT_PRODUCT) != 0;
374 }
375
376 bool Flag::is_develop() const {
377 return (_flags & KIND_DEVELOP) != 0;
378 }
379
380 bool Flag::is_read_write() const {
381 return (_flags & KIND_READ_WRITE) != 0;
382 }
383
384 bool Flag::is_commercial() const {
385 return (_flags & KIND_COMMERCIAL) != 0;
386 }
387
388 /**
389 * Returns if this flag is a constant in the binary. Right now this is
390 * true for notproduct and develop flags in product builds.
391 */
392 bool Flag::is_constant_in_binary() const {
393 #ifdef PRODUCT
394 return is_notproduct() || is_develop();
395 #else
396 return false;
397 #endif
398 }
399
400 bool Flag::is_unlocker() const {
401 return strcmp(_name, "UnlockDiagnosticVMOptions") == 0 ||
402 strcmp(_name, "UnlockExperimentalVMOptions") == 0 ||
403 is_unlocker_ext();
404 }
405
406 bool Flag::is_unlocked() const {
407 if (is_diagnostic()) {
408 return UnlockDiagnosticVMOptions;
409 }
410 if (is_experimental()) {
411 return UnlockExperimentalVMOptions;
412 }
413 return is_unlocked_ext();
414 }
415
416 void Flag::clear_diagnostic() {
417 assert(is_diagnostic(), "sanity");
418 _flags = Flags(_flags & ~KIND_DIAGNOSTIC);
419 assert(!is_diagnostic(), "sanity");
420 }
421
422 // Get custom message for this locked flag, or NULL if
423 // none is available. Returns message type produced.
424 Flag::MsgType Flag::get_locked_message(char* buf, int buflen) const {
425 buf[0] = '\0';
426 if (is_diagnostic() && !is_unlocked()) {
427 jio_snprintf(buf, buflen,
428 "Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n"
429 "Error: The unlock option must precede '%s'.\n",
430 _name, _name);
431 return Flag::DIAGNOSTIC_FLAG_BUT_LOCKED;
432 }
433 if (is_experimental() && !is_unlocked()) {
434 jio_snprintf(buf, buflen,
435 "Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n"
436 "Error: The unlock option must precede '%s'.\n",
437 _name, _name);
438 return Flag::EXPERIMENTAL_FLAG_BUT_LOCKED;
439 }
440 if (is_develop() && is_product_build()) {
441 jio_snprintf(buf, buflen, "Error: VM option '%s' is develop and is available only in debug version of VM.\n",
442 _name);
443 return Flag::DEVELOPER_FLAG_BUT_PRODUCT_BUILD;
444 }
445 if (is_notproduct() && is_product_build()) {
446 jio_snprintf(buf, buflen, "Error: VM option '%s' is notproduct and is available only in debug version of VM.\n",
447 _name);
448 return Flag::NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD;
449 }
450 get_locked_message_ext(buf, buflen);
451 return Flag::NONE;
452 }
453
454 bool Flag::is_writeable() const {
455 return is_manageable() || (is_product() && is_read_write()) || is_writeable_ext();
456 }
457
458 // All flags except "manageable" are assumed to be internal flags.
459 // Long term, we need to define a mechanism to specify which flags
460 // are external/stable and change this function accordingly.
461 bool Flag::is_external() const {
462 return is_manageable() || is_external_ext();
463 }
464
465 void Flag::print_on(outputStream* st, bool withComments, bool printRanges) {
466 // Don't print notproduct and develop flags in a product build.
467 if (is_constant_in_binary()) {
468 return;
469 }
470
471 if (!printRanges) {
472 // Use some named constants to make code more readable.
473 const unsigned int nSpaces = 10;
474 const unsigned int maxFlagLen = 40 + nSpaces;
475
476 // The print below assumes that the flag name is 40 characters or less.
477 // This works for most flags, but there are exceptions. Our longest flag
478 // name right now is UseAdaptiveGenerationSizePolicyAtMajorCollection and
479 // its minor collection buddy. These are 48 characters. We use a buffer of
480 // nSpaces spaces below to adjust the space between the flag value and the
481 // column of flag type and origin that is printed in the end of the line.
482 char spaces[nSpaces + 1] = " ";
483 st->print("%9s %-*s = ", _type, maxFlagLen-nSpaces, _name);
484
485 if (is_bool()) {
486 st->print("%-20s", get_bool() ? "true" : "false");
487 } else if (is_int()) {
488 st->print("%-20d", get_int());
489 } else if (is_uint()) {
490 st->print("%-20u", get_uint());
491 } else if (is_intx()) {
492 st->print(INTX_FORMAT_W(-20), get_intx());
493 } else if (is_uintx()) {
494 st->print(UINTX_FORMAT_W(-20), get_uintx());
495 } else if (is_uint64_t()) {
496 st->print(UINT64_FORMAT_W(-20), get_uint64_t());
497 } else if (is_size_t()) {
498 st->print(SIZE_FORMAT_W(-20), get_size_t());
499 } else if (is_double()) {
500 st->print("%-20f", get_double());
501 } else if (is_ccstr()) {
502 const char* cp = get_ccstr();
503 if (cp != NULL) {
504 const char* eol;
505 while ((eol = strchr(cp, '\n')) != NULL) {
506 size_t llen = pointer_delta(eol, cp, sizeof(char));
507 st->print("%.*s", (int)llen, cp);
508 st->cr();
509 cp = eol+1;
510 st->print("%5s %-35s += ", "", _name);
511 }
512 st->print("%-20s", cp);
513 }
514 else st->print("%-20s", "");
515 }
516 // Make sure we do not punch a '\0' at a negative char array index.
517 unsigned int nameLen = (unsigned int)strlen(_name);
518 if (nameLen <= maxFlagLen) {
519 spaces[maxFlagLen - MAX2(maxFlagLen-nSpaces, nameLen)] = '\0';
520 st->print("%s", spaces);
521 }
522 print_kind_and_origin(st);
523
524 #ifndef PRODUCT
525 if (withComments) {
526 st->print("%s", _doc);
527 }
528 #endif
529
530 st->cr();
531
532 } else if (!is_bool() && !is_ccstr()) {
533 st->print("%9s %-50s ", _type, _name);
534
535 RangeStrFunc func = NULL;
536 if (is_int()) {
537 func = Flag::get_int_default_range_str;
538 } else if (is_uint()) {
539 func = Flag::get_uint_default_range_str;
540 } else if (is_intx()) {
541 func = Flag::get_intx_default_range_str;
542 } else if (is_uintx()) {
543 func = Flag::get_uintx_default_range_str;
544 } else if (is_uint64_t()) {
545 func = Flag::get_uint64_t_default_range_str;
546 } else if (is_size_t()) {
547 func = Flag::get_size_t_default_range_str;
548 } else if (is_double()) {
549 func = Flag::get_double_default_range_str;
550 } else {
551 ShouldNotReachHere();
552 }
553 CommandLineFlagRangeList::print(st, _name, func);
554
555 st->print(" %-16s", " ");
556 print_kind_and_origin(st);
557
558 #ifndef PRODUCT
559 if (withComments) {
560 st->print("%s", _doc);
561 }
562 #endif
563
564 st->cr();
565 }
566 }
567
568 void Flag::print_kind_and_origin(outputStream* st) {
569 struct Data {
570 int flag;
571 const char* name;
572 };
573
574 Data data[] = {
575 { KIND_JVMCI, "JVMCI" },
576 { KIND_C1, "C1" },
577 { KIND_C2, "C2" },
578 { KIND_ARCH, "ARCH" },
579 { KIND_PLATFORM_DEPENDENT, "pd" },
580 { KIND_PRODUCT, "product" },
581 { KIND_MANAGEABLE, "manageable" },
582 { KIND_DIAGNOSTIC, "diagnostic" },
583 { KIND_EXPERIMENTAL, "experimental" },
584 { KIND_COMMERCIAL, "commercial" },
585 { KIND_NOT_PRODUCT, "notproduct" },
586 { KIND_DEVELOP, "develop" },
587 { KIND_LP64_PRODUCT, "lp64_product" },
588 { KIND_READ_WRITE, "rw" },
589 { -1, "" }
590 };
591
592 if ((_flags & KIND_MASK) != 0) {
593 bool is_first = true;
594 const size_t buffer_size = 64;
595 size_t buffer_used = 0;
596 char kind[buffer_size];
597
598 jio_snprintf(kind, buffer_size, "{");
599 buffer_used++;
600 for (int i = 0; data[i].flag != -1; i++) {
601 Data d = data[i];
602 if ((_flags & d.flag) != 0) {
603 if (is_first) {
604 is_first = false;
605 } else {
606 assert(buffer_used + 1 < buffer_size, "Too small buffer");
607 jio_snprintf(kind + buffer_used, buffer_size - buffer_used, " ");
608 buffer_used++;
609 }
610 size_t length = strlen(d.name);
611 assert(buffer_used + length < buffer_size, "Too small buffer");
612 jio_snprintf(kind + buffer_used, buffer_size - buffer_used, "%s", d.name);
613 buffer_used += length;
614 }
615 }
616 assert(buffer_used + 2 <= buffer_size, "Too small buffer");
617 jio_snprintf(kind + buffer_used, buffer_size - buffer_used, "}");
618 st->print("%20s", kind);
619 }
620
621 int origin = _flags & VALUE_ORIGIN_MASK;
622 st->print(" {");
623 switch(origin) {
624 case DEFAULT:
625 st->print("default"); break;
626 case COMMAND_LINE:
627 st->print("command line"); break;
628 case ENVIRON_VAR:
629 st->print("environment"); break;
630 case CONFIG_FILE:
631 st->print("config file"); break;
632 case MANAGEMENT:
633 st->print("management"); break;
634 case ERGONOMIC:
635 if (_flags & ORIG_COMMAND_LINE) {
636 st->print("command line, ");
637 }
638 st->print("ergonomic"); break;
639 case ATTACH_ON_DEMAND:
640 st->print("attach"); break;
641 case INTERNAL:
642 st->print("internal"); break;
643 }
644 st->print("}");
645 }
646
647 void Flag::print_as_flag(outputStream* st) {
648 if (is_bool()) {
649 st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
650 } else if (is_int()) {
651 st->print("-XX:%s=%d", _name, get_int());
652 } else if (is_uint()) {
653 st->print("-XX:%s=%u", _name, get_uint());
654 } else if (is_intx()) {
655 st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
656 } else if (is_uintx()) {
657 st->print("-XX:%s=" UINTX_FORMAT, _name, get_uintx());
658 } else if (is_uint64_t()) {
659 st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t());
660 } else if (is_size_t()) {
661 st->print("-XX:%s=" SIZE_FORMAT, _name, get_size_t());
662 } else if (is_double()) {
663 st->print("-XX:%s=%f", _name, get_double());
664 } else if (is_ccstr()) {
665 st->print("-XX:%s=", _name);
666 const char* cp = get_ccstr();
667 if (cp != NULL) {
668 // Need to turn embedded '\n's back into separate arguments
669 // Not so efficient to print one character at a time,
670 // but the choice is to do the transformation to a buffer
671 // and print that. And this need not be efficient.
672 for (; *cp != '\0'; cp += 1) {
673 switch (*cp) {
674 default:
675 st->print("%c", *cp);
676 break;
677 case '\n':
678 st->print(" -XX:%s=", _name);
679 break;
680 }
681 }
682 }
683 } else {
684 ShouldNotReachHere();
685 }
686 }
687
688 const char* Flag::flag_error_str(Flag::Error error) {
689 switch (error) {
690 case Flag::MISSING_NAME: return "MISSING_NAME";
691 case Flag::MISSING_VALUE: return "MISSING_VALUE";
692 case Flag::NON_WRITABLE: return "NON_WRITABLE";
693 case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS";
694 case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT";
695 case Flag::INVALID_FLAG: return "INVALID_FLAG";
696 case Flag::ERR_OTHER: return "ERR_OTHER";
697 case Flag::SUCCESS: return "SUCCESS";
698 default: ShouldNotReachHere(); return "NULL";
699 }
700 }
701
702 // 4991491 do not "optimize out" the was_set false values: omitting them
703 // tickles a Microsoft compiler bug causing flagTable to be malformed
704
705 #define RUNTIME_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) },
706 #define RUNTIME_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
707 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) },
708 #define RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC | Flag::KIND_PLATFORM_DEPENDENT) },
709 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) },
710 #define RUNTIME_MANAGEABLE_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) },
711 #define RUNTIME_PRODUCT_RW_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_READ_WRITE) },
712 #define RUNTIME_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP) },
713 #define RUNTIME_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
714 #define RUNTIME_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_NOT_PRODUCT) },
715
716 #define JVMCI_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_PRODUCT) },
717 #define JVMCI_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
718 #define JVMCI_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_DIAGNOSTIC) },
719 #define JVMCI_PD_DIAGNOSTIC_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_DIAGNOSTIC | Flag::KIND_PLATFORM_DEPENDENT) },
720 #define JVMCI_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_EXPERIMENTAL) },
721 #define JVMCI_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_DEVELOP) },
722 #define JVMCI_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
723 #define JVMCI_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_JVMCI | Flag::KIND_NOT_PRODUCT) },
724
725 #ifdef _LP64
726 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_LP64_PRODUCT) },
727 #else
728 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
729 #endif // _LP64
730
731 #define C1_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_PRODUCT) },
732 #define C1_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
733 #define C1_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DIAGNOSTIC) },
734 #define C1_PD_DIAGNOSTIC_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DIAGNOSTIC | Flag::KIND_PLATFORM_DEPENDENT) },
735 #define C1_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DEVELOP) },
736 #define C1_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
737 #define C1_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_NOT_PRODUCT) },
738
739 #define C2_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_PRODUCT) },
740 #define C2_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
741 #define C2_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DIAGNOSTIC) },
742 #define C2_PD_DIAGNOSTIC_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DIAGNOSTIC | Flag::KIND_PLATFORM_DEPENDENT) },
743 #define C2_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_EXPERIMENTAL) },
744 #define C2_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DEVELOP) },
745 #define C2_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
746 #define C2_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_NOT_PRODUCT) },
747
748 #define ARCH_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_PRODUCT) },
749 #define ARCH_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_DIAGNOSTIC) },
750 #define ARCH_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_EXPERIMENTAL) },
751 #define ARCH_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_DEVELOP) },
752 #define ARCH_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_NOT_PRODUCT) },
753
754 static Flag flagTable[] = {
755 RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
756 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
757 RUNTIME_PRODUCT_FLAG_STRUCT, \
758 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
759 RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
760 RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
761 RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
762 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
763 RUNTIME_MANAGEABLE_FLAG_STRUCT, \
764 RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
765 RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \
766 IGNORE_RANGE, \
767 IGNORE_CONSTRAINT, \
768 IGNORE_WRITEABLE)
769 RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
770 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
771 RUNTIME_PRODUCT_FLAG_STRUCT, \
772 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
773 RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
774 RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
775 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
776 IGNORE_RANGE, \
777 IGNORE_CONSTRAINT, \
778 IGNORE_WRITEABLE)
779 #if INCLUDE_ALL_GCS
780 G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
781 RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
782 RUNTIME_PRODUCT_FLAG_STRUCT, \
783 RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
784 RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
785 RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
786 RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
787 RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
788 RUNTIME_MANAGEABLE_FLAG_STRUCT, \
789 RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
790 IGNORE_RANGE, \
791 IGNORE_CONSTRAINT, \
792 IGNORE_WRITEABLE)
793 #endif // INCLUDE_ALL_GCS
794 #if INCLUDE_JVMCI
795 JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_STRUCT, \
796 JVMCI_PD_DEVELOP_FLAG_STRUCT, \
797 JVMCI_PRODUCT_FLAG_STRUCT, \
798 JVMCI_PD_PRODUCT_FLAG_STRUCT, \
799 JVMCI_DIAGNOSTIC_FLAG_STRUCT, \
800 JVMCI_PD_DIAGNOSTIC_FLAG_STRUCT, \
801 JVMCI_EXPERIMENTAL_FLAG_STRUCT, \
802 JVMCI_NOTPRODUCT_FLAG_STRUCT, \
803 IGNORE_RANGE, \
804 IGNORE_CONSTRAINT, \
805 IGNORE_WRITEABLE)
806 #endif // INCLUDE_JVMCI
807 #ifdef COMPILER1
808 C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, \
809 C1_PD_DEVELOP_FLAG_STRUCT, \
810 C1_PRODUCT_FLAG_STRUCT, \
811 C1_PD_PRODUCT_FLAG_STRUCT, \
812 C1_DIAGNOSTIC_FLAG_STRUCT, \
813 C1_PD_DIAGNOSTIC_FLAG_STRUCT, \
814 C1_NOTPRODUCT_FLAG_STRUCT, \
815 IGNORE_RANGE, \
816 IGNORE_CONSTRAINT, \
817 IGNORE_WRITEABLE)
818 #endif // COMPILER1
819 #ifdef COMPILER2
820 C2_FLAGS(C2_DEVELOP_FLAG_STRUCT, \
821 C2_PD_DEVELOP_FLAG_STRUCT, \
822 C2_PRODUCT_FLAG_STRUCT, \
823 C2_PD_PRODUCT_FLAG_STRUCT, \
824 C2_DIAGNOSTIC_FLAG_STRUCT, \
825 C2_PD_DIAGNOSTIC_FLAG_STRUCT, \
826 C2_EXPERIMENTAL_FLAG_STRUCT, \
827 C2_NOTPRODUCT_FLAG_STRUCT, \
828 IGNORE_RANGE, \
829 IGNORE_CONSTRAINT, \
830 IGNORE_WRITEABLE)
831 #endif // COMPILER2
832 ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, \
833 ARCH_PRODUCT_FLAG_STRUCT, \
834 ARCH_DIAGNOSTIC_FLAG_STRUCT, \
835 ARCH_EXPERIMENTAL_FLAG_STRUCT, \
836 ARCH_NOTPRODUCT_FLAG_STRUCT, \
837 IGNORE_RANGE, \
838 IGNORE_CONSTRAINT, \
839 IGNORE_WRITEABLE)
840 FLAGTABLE_EXT
841 {0, NULL, NULL}
842 };
843
844 Flag* Flag::flags = flagTable;
845 size_t Flag::numFlags = (sizeof(flagTable) / sizeof(Flag));
846
847 inline bool str_equal(const char* s, size_t s_len, const char* q, size_t q_len) {
848 if (s_len != q_len) return false;
849 return memcmp(s, q, q_len) == 0;
850 }
851
852 // Search the flag table for a named flag
853 Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked, bool return_flag) {
854 for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
855 if (str_equal(current->_name, current->get_name_length(), name, length)) {
856 // Found a matching entry.
857 // Don't report notproduct and develop flags in product builds.
858 if (current->is_constant_in_binary()) {
859 return (return_flag ? current : NULL);
860 }
861 // Report locked flags only if allowed.
862 if (!(current->is_unlocked() || current->is_unlocker())) {
863 if (!allow_locked) {
864 // disable use of locked flags, e.g. diagnostic, experimental,
865 // commercial... until they are explicitly unlocked
866 return NULL;
867 }
868 }
869 return current;
870 }
871 }
872 // Flag name is not in the flag table
873 return NULL;
874 }
875
876 // Get or compute the flag name length
877 size_t Flag::get_name_length() {
878 if (_name_len == 0) {
879 _name_len = strlen(_name);
880 }
881 return _name_len;
882 }
883
884 Flag* Flag::fuzzy_match(const char* name, size_t length, bool allow_locked) {
885 float VMOptionsFuzzyMatchSimilarity = 0.7f;
886 Flag* match = NULL;
887 float score;
888 float max_score = -1;
889
890 for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
891 score = StringUtils::similarity(current->_name, strlen(current->_name), name, length);
892 if (score > max_score) {
893 max_score = score;
894 match = current;
895 }
896 }
897
898 if (!(match->is_unlocked() || match->is_unlocker())) {
899 if (!allow_locked) {
900 return NULL;
901 }
902 }
903
904 if (max_score < VMOptionsFuzzyMatchSimilarity) {
905 return NULL;
906 }
907
908 return match;
909 }
910
911 // Returns the address of the index'th element
912 static Flag* address_of_flag(CommandLineFlagWithType flag) {
913 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
914 return &Flag::flags[flag];
915 }
916
917 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
918 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
919 Flag* f = &Flag::flags[flag];
920 return f->is_default();
921 }
922
923 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
924 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
925 Flag* f = &Flag::flags[flag];
926 return f->is_ergonomic();
927 }
928
929 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
930 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
931 Flag* f = &Flag::flags[flag];
932 return f->is_command_line();
933 }
934
935 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
936 Flag* result = Flag::find_flag((char*)name, strlen(name));
937 if (result == NULL) return false;
938 *value = result->is_command_line();
939 return true;
940 }
941
942 void CommandLineFlagsEx::setOnCmdLine(CommandLineFlagWithType flag) {
943 Flag* faddr = address_of_flag(flag);
944 assert(faddr != NULL, "Unknown flag");
945 faddr->set_command_line();
946 }
947
948 template<class E, class T>
949 static void trace_flag_changed(const char* name, const T old_value, const T new_value, const Flag::Flags origin) {
950 E e;
951 e.set_name(name);
952 e.set_oldValue(old_value);
953 e.set_newValue(new_value);
954 e.set_origin(origin);
955 e.commit();
956 }
957
958 static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose) {
959 Flag::Error status = Flag::SUCCESS;
960 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
961 if (constraint != NULL) {
962 status = constraint->apply_bool(new_value, verbose);
963 }
964 return status;
965 }
966
967 Flag::Error CommandLineFlags::boolAt(const char* name, size_t len, bool* value, bool allow_locked, bool return_flag) {
968 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
969 if (result == NULL) return Flag::INVALID_FLAG;
970 if (!result->is_bool()) return Flag::WRONG_FORMAT;
971 *value = result->get_bool();
972 return Flag::SUCCESS;
973 }
974
975 Flag::Error CommandLineFlags::boolAtPut(Flag* flag, bool* value, Flag::Flags origin) {
976 const char* name;
977 if (flag == NULL) return Flag::INVALID_FLAG;
978 if (!flag->is_bool()) return Flag::WRONG_FORMAT;
979 name = flag->_name;
980 Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
981 if (check != Flag::SUCCESS) return check;
982 bool old_value = flag->get_bool();
983 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
984 check = flag->set_bool(*value);
985 *value = old_value;
986 flag->set_origin(origin);
987 return check;
988 }
989
990 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
991 Flag* result = Flag::find_flag(name, len);
992 return boolAtPut(result, value, origin);
993 }
994
995 Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
996 Flag* faddr = address_of_flag(flag);
997 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
998 return CommandLineFlags::boolAtPut(faddr, &value, origin);
999 }
1000
1001 static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose) {
1002 Flag::Error status = Flag::SUCCESS;
1003 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1004 if (range != NULL) {
1005 status = range->check_int(new_value, verbose);
1006 }
1007 if (status == Flag::SUCCESS) {
1008 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1009 if (constraint != NULL) {
1010 status = constraint->apply_int(new_value, verbose);
1011 }
1012 }
1013 return status;
1014 }
1015
1016 Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
1017 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1018 if (result == NULL) return Flag::INVALID_FLAG;
1019 if (!result->is_int()) return Flag::WRONG_FORMAT;
1020 *value = result->get_int();
1021 return Flag::SUCCESS;
1022 }
1023
1024 Flag::Error CommandLineFlags::intAtPut(Flag* flag, int* value, Flag::Flags origin) {
1025 const char* name;
1026 if (flag == NULL) return Flag::INVALID_FLAG;
1027 if (!flag->is_int()) return Flag::WRONG_FORMAT;
1028 name = flag->_name;
1029 Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1030 if (check != Flag::SUCCESS) return check;
1031 int old_value = flag->get_int();
1032 trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
1033 check = flag->set_int(*value);
1034 *value = old_value;
1035 flag->set_origin(origin);
1036 return check;
1037 }
1038
1039 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
1040 Flag* result = Flag::find_flag(name, len);
1041 return intAtPut(result, value, origin);
1042 }
1043
1044 Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
1045 Flag* faddr = address_of_flag(flag);
1046 guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
1047 return CommandLineFlags::intAtPut(faddr, &value, origin);
1048 }
1049
1050 static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose) {
1051 Flag::Error status = Flag::SUCCESS;
1052 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1053 if (range != NULL) {
1054 status = range->check_uint(new_value, verbose);
1055 }
1056 if (status == Flag::SUCCESS) {
1057 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1058 if (constraint != NULL) {
1059 status = constraint->apply_uint(new_value, verbose);
1060 }
1061 }
1062 return status;
1063 }
1064
1065 Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
1066 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1067 if (result == NULL) return Flag::INVALID_FLAG;
1068 if (!result->is_uint()) return Flag::WRONG_FORMAT;
1069 *value = result->get_uint();
1070 return Flag::SUCCESS;
1071 }
1072
1073 Flag::Error CommandLineFlags::uintAtPut(Flag* flag, uint* value, Flag::Flags origin) {
1074 const char* name;
1075 if (flag == NULL) return Flag::INVALID_FLAG;
1076 if (!flag->is_uint()) return Flag::WRONG_FORMAT;
1077 name = flag->_name;
1078 Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1079 if (check != Flag::SUCCESS) return check;
1080 uint old_value = flag->get_uint();
1081 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
1082 check = flag->set_uint(*value);
1083 *value = old_value;
1084 flag->set_origin(origin);
1085 return check;
1086 }
1087
1088 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
1089 Flag* result = Flag::find_flag(name, len);
1090 return uintAtPut(result, value, origin);
1091 }
1092
1093 Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
1094 Flag* faddr = address_of_flag(flag);
1095 guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
1096 return CommandLineFlags::uintAtPut(faddr, &value, origin);
1097 }
1098
1099 Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
1100 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1101 if (result == NULL) return Flag::INVALID_FLAG;
1102 if (!result->is_intx()) return Flag::WRONG_FORMAT;
1103 *value = result->get_intx();
1104 return Flag::SUCCESS;
1105 }
1106
1107 static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose) {
1108 Flag::Error status = Flag::SUCCESS;
1109 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1110 if (range != NULL) {
1111 status = range->check_intx(new_value, verbose);
1112 }
1113 if (status == Flag::SUCCESS) {
1114 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1115 if (constraint != NULL) {
1116 status = constraint->apply_intx(new_value, verbose);
1117 }
1118 }
1119 return status;
1120 }
1121
1122 Flag::Error CommandLineFlags::intxAtPut(Flag* flag, intx* value, Flag::Flags origin) {
1123 const char* name;
1124 if (flag == NULL) return Flag::INVALID_FLAG;
1125 if (!flag->is_intx()) return Flag::WRONG_FORMAT;
1126 name = flag->_name;
1127 Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1128 if (check != Flag::SUCCESS) return check;
1129 intx old_value = flag->get_intx();
1130 trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
1131 check = flag->set_intx(*value);
1132 *value = old_value;
1133 flag->set_origin(origin);
1134 return check;
1135 }
1136
1137 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
1138 Flag* result = Flag::find_flag(name, len);
1139 return intxAtPut(result, value, origin);
1140 }
1141
1142 Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
1143 Flag* faddr = address_of_flag(flag);
1144 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
1145 return CommandLineFlags::intxAtPut(faddr, &value, origin);
1146 }
1147
1148 Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
1149 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1150 if (result == NULL) return Flag::INVALID_FLAG;
1151 if (!result->is_uintx()) return Flag::WRONG_FORMAT;
1152 *value = result->get_uintx();
1153 return Flag::SUCCESS;
1154 }
1155
1156 static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose) {
1157 Flag::Error status = Flag::SUCCESS;
1158 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1159 if (range != NULL) {
1160 status = range->check_uintx(new_value, verbose);
1161 }
1162 if (status == Flag::SUCCESS) {
1163 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1164 if (constraint != NULL) {
1165 status = constraint->apply_uintx(new_value, verbose);
1166 }
1167 }
1168 return status;
1169 }
1170
1171 Flag::Error CommandLineFlags::uintxAtPut(Flag* flag, uintx* value, Flag::Flags origin) {
1172 const char* name;
1173 if (flag == NULL) return Flag::INVALID_FLAG;
1174 if (!flag->is_uintx()) return Flag::WRONG_FORMAT;
1175 name = flag->_name;
1176 Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1177 if (check != Flag::SUCCESS) return check;
1178 uintx old_value = flag->get_uintx();
1179 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1180 check = flag->set_uintx(*value);
1181 *value = old_value;
1182 flag->set_origin(origin);
1183 return check;
1184 }
1185
1186 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
1187 Flag* result = Flag::find_flag(name, len);
1188 return uintxAtPut(result, value, origin);
1189 }
1190
1191 Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
1192 Flag* faddr = address_of_flag(flag);
1193 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
1194 return CommandLineFlags::uintxAtPut(faddr, &value, origin);
1195 }
1196
1197 Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
1198 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1199 if (result == NULL) return Flag::INVALID_FLAG;
1200 if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1201 *value = result->get_uint64_t();
1202 return Flag::SUCCESS;
1203 }
1204
1205 static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose) {
1206 Flag::Error status = Flag::SUCCESS;
1207 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1208 if (range != NULL) {
1209 status = range->check_uint64_t(new_value, verbose);
1210 }
1211 if (status == Flag::SUCCESS) {
1212 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1213 if (constraint != NULL) {
1214 status = constraint->apply_uint64_t(new_value, verbose);
1215 }
1216 }
1217 return status;
1218 }
1219
1220 Flag::Error CommandLineFlags::uint64_tAtPut(Flag* flag, uint64_t* value, Flag::Flags origin) {
1221 const char* name;
1222 if (flag == NULL) return Flag::INVALID_FLAG;
1223 if (!flag->is_uint64_t()) return Flag::WRONG_FORMAT;
1224 name = flag->_name;
1225 Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1226 if (check != Flag::SUCCESS) return check;
1227 uint64_t old_value = flag->get_uint64_t();
1228 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1229 check = flag->set_uint64_t(*value);
1230 *value = old_value;
1231 flag->set_origin(origin);
1232 return check;
1233 }
1234
1235 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1236 Flag* result = Flag::find_flag(name, len);
1237 return uint64_tAtPut(result, value, origin);
1238 }
1239
1240 Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1241 Flag* faddr = address_of_flag(flag);
1242 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1243 return CommandLineFlags::uint64_tAtPut(faddr, &value, origin);
1244 }
1245
1246 Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
1247 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1248 if (result == NULL) return Flag::INVALID_FLAG;
1249 if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1250 *value = result->get_size_t();
1251 return Flag::SUCCESS;
1252 }
1253
1254 static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose) {
1255 Flag::Error status = Flag::SUCCESS;
1256 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1257 if (range != NULL) {
1258 status = range->check_size_t(new_value, verbose);
1259 }
1260 if (status == Flag::SUCCESS) {
1261 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1262 if (constraint != NULL) {
1263 status = constraint->apply_size_t(new_value, verbose);
1264 }
1265 }
1266 return status;
1267 }
1268
1269
1270 Flag::Error CommandLineFlags::size_tAtPut(Flag* flag, size_t* value, Flag::Flags origin) {
1271 const char* name;
1272 if (flag == NULL) return Flag::INVALID_FLAG;
1273 if (!flag->is_size_t()) return Flag::WRONG_FORMAT;
1274 name = flag->_name;
1275 Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1276 if (check != Flag::SUCCESS) return check;
1277 size_t old_value = flag->get_size_t();
1278 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1279 check = flag->set_size_t(*value);
1280 *value = old_value;
1281 flag->set_origin(origin);
1282 return check;
1283 }
1284
1285 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
1286 Flag* result = Flag::find_flag(name, len);
1287 return size_tAtPut(result, value, origin);
1288 }
1289
1290 Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
1291 Flag* faddr = address_of_flag(flag);
1292 guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
1293 return CommandLineFlags::size_tAtPut(faddr, &value, origin);
1294 }
1295
1296 Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
1297 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1298 if (result == NULL) return Flag::INVALID_FLAG;
1299 if (!result->is_double()) return Flag::WRONG_FORMAT;
1300 *value = result->get_double();
1301 return Flag::SUCCESS;
1302 }
1303
1304 static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose) {
1305 Flag::Error status = Flag::SUCCESS;
1306 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1307 if (range != NULL) {
1308 status = range->check_double(new_value, verbose);
1309 }
1310 if (status == Flag::SUCCESS) {
1311 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1312 if (constraint != NULL) {
1313 status = constraint->apply_double(new_value, verbose);
1314 }
1315 }
1316 return status;
1317 }
1318
1319 Flag::Error CommandLineFlags::doubleAtPut(Flag* flag, double* value, Flag::Flags origin) {
1320 const char* name;
1321 if (flag == NULL) return Flag::INVALID_FLAG;
1322 if (!flag->is_double()) return Flag::WRONG_FORMAT;
1323 name = flag->_name;
1324 Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1325 if (check != Flag::SUCCESS) return check;
1326 double old_value = flag->get_double();
1327 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
1328 check = flag->set_double(*value);
1329 *value = old_value;
1330 flag->set_origin(origin);
1331 return check;
1332 }
1333
1334 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
1335 Flag* result = Flag::find_flag(name, len);
1336 return doubleAtPut(result, value, origin);
1337 }
1338
1339 Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1340 Flag* faddr = address_of_flag(flag);
1341 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1342 return CommandLineFlags::doubleAtPut(faddr, &value, origin);
1343 }
1344
1345 Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
1346 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1347 if (result == NULL) return Flag::INVALID_FLAG;
1348 if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1349 *value = result->get_ccstr();
1350 return Flag::SUCCESS;
1351 }
1352
1353 Flag::Error CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
1354 Flag* result = Flag::find_flag(name, len);
1355 if (result == NULL) return Flag::INVALID_FLAG;
1356 if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1357 ccstr old_value = result->get_ccstr();
1358 trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin);
1359 char* new_value = NULL;
1360 if (*value != NULL) {
1361 new_value = os::strdup_check_oom(*value);
1362 }
1363 Flag::Error check = result->set_ccstr(new_value);
1364 if (result->is_default() && old_value != NULL) {
1365 // Prior value is NOT heap allocated, but was a literal constant.
1366 old_value = os::strdup_check_oom(old_value);
1367 }
1368 *value = old_value;
1369 result->set_origin(origin);
1370 return check;
1371 }
1372
1373 Flag::Error CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
1374 Flag* faddr = address_of_flag(flag);
1375 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
1376 ccstr old_value = faddr->get_ccstr();
1377 trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin);
1378 char* new_value = os::strdup_check_oom(value);
1379 Flag::Error check = faddr->set_ccstr(new_value);
1380 if (!faddr->is_default() && old_value != NULL) {
1381 // Prior value is heap allocated so free it.
1382 FREE_C_HEAP_ARRAY(char, old_value);
1383 }
1384 faddr->set_origin(origin);
1385 return check;
1386 }
1387
1388 extern "C" {
1389 static int compare_flags(const void* void_a, const void* void_b) {
1390 return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name);
1391 }
1392 }
1393
1394 void CommandLineFlags::printSetFlags(outputStream* out) {
1395 // Print which flags were set on the command line
1396 // note: this method is called before the thread structure is in place
1397 // which means resource allocation cannot be used.
1398
1399 // The last entry is the null entry.
1400 const size_t length = Flag::numFlags - 1;
1401
1402 // Sort
1403 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtArguments);
1404 for (size_t i = 0; i < length; i++) {
1405 array[i] = &flagTable[i];
1406 }
1407 qsort(array, length, sizeof(Flag*), compare_flags);
1408
1409 // Print
1410 for (size_t i = 0; i < length; i++) {
1411 if (array[i]->get_origin() /* naked field! */) {
1412 array[i]->print_as_flag(out);
1413 out->print(" ");
1414 }
1415 }
1416 out->cr();
1417 FREE_C_HEAP_ARRAY(Flag*, array);
1418 }
1419
1420 #ifndef PRODUCT
1421
1422 void CommandLineFlags::verify() {
1423 assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
1424 }
1425
1426 #endif // PRODUCT
1427
1428 void CommandLineFlags::printFlags(outputStream* out, bool withComments, bool printRanges) {
1429 // Print the flags sorted by name
1430 // note: this method is called before the thread structure is in place
1431 // which means resource allocation cannot be used.
1432
1433 // The last entry is the null entry.
1434 const size_t length = Flag::numFlags - 1;
1435
1436 // Sort
1437 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtArguments);
1438 for (size_t i = 0; i < length; i++) {
1439 array[i] = &flagTable[i];
1440 }
1441 qsort(array, length, sizeof(Flag*), compare_flags);
1442
1443 // Print
1444 if (!printRanges) {
1445 out->print_cr("[Global flags]");
1446 } else {
1447 out->print_cr("[Global flags ranges]");
1448 }
1449
1450 for (size_t i = 0; i < length; i++) {
1451 if (array[i]->is_unlocked()) {
1452 array[i]->print_on(out, withComments, printRanges);
1453 }
1454 }
1455 FREE_C_HEAP_ARRAY(Flag*, array);
1456 }