truffle: src/share/vm/runtime/globals.cpp annotate

annotate src/share/vm/runtime/globals.cpp @ 10246:194f52aa2f23

7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap Summary: Refactor G1's hot card cache and card counts table into their own files. Simplify the card counts table, including removing the encoding of the card index in each entry. The card counts table now has a 1:1 correspondence with the cards spanned by heap. Space for the card counts table is reserved from virtual memory (rather than C heap) during JVM startup and is committed/expanded when the heap is expanded. Changes were also reviewed-by Vitaly Davidovich. Reviewed-by: tschatzl, jmasa

author	johnc
date	Thu, 09 May 2013 11:16:39 -0700
parents	64d2a0a39954
children	5fc51c1ecdeb b3cd8b58b798

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8045 64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1150 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1150 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1150 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	26 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	27 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	28 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	29 #include "runtime/globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	30 #include "runtime/globals_extension.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	31 #include "utilities/ostream.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6633 diff changeset	32 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	33 #include "utilities/top.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6633 diff changeset	34 #if INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	35 #include "gc_implementation/g1/g1_globals.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6633 diff changeset	36 #endif // INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	37 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	38 #include "c1/c1_globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	39 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	40 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	41 #include "opto/c2_globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	42 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	43 #ifdef SHARK
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	44 #include "shark/shark_globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1768 diff changeset	45 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	46
a61af66fc99e Initial load duke parents: diff changeset	47 RUNTIME_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, \
a61af66fc99e Initial load duke parents: diff changeset	48 MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, \
4088 358eca91be48 7116730: Revert 7116481: Commercial features in Hotspot must be gated by a switch phh parents: 4087 diff changeset	49 MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_EXPERIMENTAL_FLAG, \
358eca91be48 7116730: Revert 7116481: Commercial features in Hotspot must be gated by a switch phh parents: 4087 diff changeset	50 MATERIALIZE_NOTPRODUCT_FLAG, \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	51 MATERIALIZE_MANAGEABLE_FLAG, MATERIALIZE_PRODUCT_RW_FLAG, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	52 MATERIALIZE_LP64_PRODUCT_FLAG)
0 a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, \
a61af66fc99e Initial load duke parents: diff changeset	55 MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, \
a61af66fc99e Initial load duke parents: diff changeset	56 MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_NOTPRODUCT_FLAG)
a61af66fc99e Initial load duke parents: diff changeset	57
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	58 ARCH_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PRODUCT_FLAG, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	59 MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_EXPERIMENTAL_FLAG, \
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	60 MATERIALIZE_NOTPRODUCT_FLAG)
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	61
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	62 MATERIALIZE_FLAGS_EXT
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	63
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	64
0 a61af66fc99e Initial load duke parents: diff changeset	65 bool Flag::is_unlocker() const {
4088 358eca91be48 7116730: Revert 7116481: Commercial features in Hotspot must be gated by a switch phh parents: 4087 diff changeset	66 return strcmp(name, "UnlockDiagnosticVMOptions") == 0 \|\|
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	67 strcmp(name, "UnlockExperimentalVMOptions") == 0 \|\|
cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	68 is_unlocker_ext();
0 a61af66fc99e Initial load duke parents: diff changeset	69 }
a61af66fc99e Initial load duke parents: diff changeset	70
a61af66fc99e Initial load duke parents: diff changeset	71 bool Flag::is_unlocked() const {
8045 64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	72 if (strcmp(kind, "{diagnostic}") == 0 \|\|
64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	73 strcmp(kind, "{C2 diagnostic}") == 0 \|\|
64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	74 strcmp(kind, "{ARCH diagnostic}") == 0 \|\|
64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	75 strcmp(kind, "{Shark diagnostic}") == 0) {
2460 ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 1972 diff changeset	76 if (strcmp(name, "EnableInvokeDynamic") == 0 && UnlockExperimentalVMOptions && !UnlockDiagnosticVMOptions) {
ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 1972 diff changeset	77 // transitional logic to allow tests to run until they are changed
ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 1972 diff changeset	78 static int warned;
ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 1972 diff changeset	79 if (++warned == 1) warning("Use -XX:+UnlockDiagnosticVMOptions before EnableInvokeDynamic flag");
ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 1972 diff changeset	80 return true;
ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 1972 diff changeset	81 }
0 a61af66fc99e Initial load duke parents: diff changeset	82 return UnlockDiagnosticVMOptions;
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1067 diff changeset	83 } else if (strcmp(kind, "{experimental}") == 0 \|\|
8045 64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	84 strcmp(kind, "{C2 experimental}") == 0 \|\|
64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	85 strcmp(kind, "{ARCH experimental}") == 0 \|\|
64d2a0a39954 8006430: TraceTypeProfile is a product flag while it should be a diagnostic flag kmo parents: 8001 diff changeset	86 strcmp(kind, "{Shark experimental}") == 0) {
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 342 diff changeset	87 return UnlockExperimentalVMOptions;
0 a61af66fc99e Initial load duke parents: diff changeset	88 } else {
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	89 return is_unlocked_ext();
0 a61af66fc99e Initial load duke parents: diff changeset	90 }
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92
5947 80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	93 // Get custom message for this locked flag, or return NULL if
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	94 // none is available.
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	95 void Flag::get_locked_message(char* buf, int buflen) const {
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	96 get_locked_message_ext(buf, buflen);
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	97 }
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	98
0 a61af66fc99e Initial load duke parents: diff changeset	99 bool Flag::is_writeable() const {
4715 6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4107 diff changeset	100 return strcmp(kind, "{manageable}") == 0 \|\|
6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4107 diff changeset	101 strcmp(kind, "{product rw}") == 0 \|\|
6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4107 diff changeset	102 is_writeable_ext();
0 a61af66fc99e Initial load duke parents: diff changeset	103 }
a61af66fc99e Initial load duke parents: diff changeset	104
4715 6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4107 diff changeset	105 // All flags except "manageable" are assumed to be internal flags.
0 a61af66fc99e Initial load duke parents: diff changeset	106 // Long term, we need to define a mechanism to specify which flags
a61af66fc99e Initial load duke parents: diff changeset	107 // are external/stable and change this function accordingly.
a61af66fc99e Initial load duke parents: diff changeset	108 bool Flag::is_external() const {
4715 6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4107 diff changeset	109 return strcmp(kind, "{manageable}") == 0 \|\| is_external_ext();
0 a61af66fc99e Initial load duke parents: diff changeset	110 }
a61af66fc99e Initial load duke parents: diff changeset	111
4715 6c995c08526c 7122880: Extend vendor-specific command interface to include manageable switches phh parents: 4107 diff changeset	112
0 a61af66fc99e Initial load duke parents: diff changeset	113 // Length of format string (e.g. "%.1234s") for printing ccstr below
a61af66fc99e Initial load duke parents: diff changeset	114 #define FORMAT_BUFFER_LEN 16
a61af66fc99e Initial load duke parents: diff changeset	115
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	116 void Flag::print_on(outputStream* st, bool withComments) {
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	117 st->print("%9s %-40s %c= ", type, name, (origin != DEFAULT ? ':' : ' '));
1067 ba7ea42fc66e 6898160: Need serviceability support for new vm argument type 'uint64_t' phh parents: 1064 diff changeset	118 if (is_bool()) st->print("%-16s", get_bool() ? "true" : "false");
ba7ea42fc66e 6898160: Need serviceability support for new vm argument type 'uint64_t' phh parents: 1064 diff changeset	119 if (is_intx()) st->print("%-16ld", get_intx());
ba7ea42fc66e 6898160: Need serviceability support for new vm argument type 'uint64_t' phh parents: 1064 diff changeset	120 if (is_uintx()) st->print("%-16lu", get_uintx());
ba7ea42fc66e 6898160: Need serviceability support for new vm argument type 'uint64_t' phh parents: 1064 diff changeset	121 if (is_uint64_t()) st->print("%-16lu", get_uint64_t());
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	122 if (is_double()) st->print("%-16f", get_double());
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	123
0 a61af66fc99e Initial load duke parents: diff changeset	124 if (is_ccstr()) {
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	125 const char* cp = get_ccstr();
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	126 if (cp != NULL) {
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	127 const char* eol;
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	128 while ((eol = strchr(cp, '\n')) != NULL) {
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	129 char format_buffer[FORMAT_BUFFER_LEN];
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	130 size_t llen = pointer_delta(eol, cp, sizeof(char));
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	131 jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
103 38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	132 "%%." SIZE_FORMAT "s", llen);
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	133 st->print(format_buffer, cp);
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	134 st->cr();
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	135 cp = eol+1;
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	136 st->print("%5s %-35s += ", "", name);
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	137 }
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	138 st->print("%-16s", cp);
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	139 }
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	140 else st->print("%-16s", "");
0 a61af66fc99e Initial load duke parents: diff changeset	141 }
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	142 st->print("%-20s", kind);
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	143 if (withComments) {
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	144 #ifndef PRODUCT
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	145 st->print("%s", doc );
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	146 #endif
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	147 }
0 a61af66fc99e Initial load duke parents: diff changeset	148 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	149 }
a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 void Flag::print_as_flag(outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	152 if (is_bool()) {
a61af66fc99e Initial load duke parents: diff changeset	153 st->print("-XX:%s%s", get_bool() ? "+" : "-", name);
a61af66fc99e Initial load duke parents: diff changeset	154 } else if (is_intx()) {
a61af66fc99e Initial load duke parents: diff changeset	155 st->print("-XX:%s=" INTX_FORMAT, name, get_intx());
a61af66fc99e Initial load duke parents: diff changeset	156 } else if (is_uintx()) {
a61af66fc99e Initial load duke parents: diff changeset	157 st->print("-XX:%s=" UINTX_FORMAT, name, get_uintx());
1067 ba7ea42fc66e 6898160: Need serviceability support for new vm argument type 'uint64_t' phh parents: 1064 diff changeset	158 } else if (is_uint64_t()) {
ba7ea42fc66e 6898160: Need serviceability support for new vm argument type 'uint64_t' phh parents: 1064 diff changeset	159 st->print("-XX:%s=" UINT64_FORMAT, name, get_uint64_t());
6049 f47478089efc 7167069: 6 VM flags crash the VM when queried via jinfo brutisso parents: 5947 diff changeset	160 } else if (is_double()) {
f47478089efc 7167069: 6 VM flags crash the VM when queried via jinfo brutisso parents: 5947 diff changeset	161 st->print("-XX:%s=%f", name, get_double());
0 a61af66fc99e Initial load duke parents: diff changeset	162 } else if (is_ccstr()) {
a61af66fc99e Initial load duke parents: diff changeset	163 st->print("-XX:%s=", name);
103 38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	164 const char* cp = get_ccstr();
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	165 if (cp != NULL) {
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	166 // Need to turn embedded '\n's back into separate arguments
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	167 // Not so efficient to print one character at a time,
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	168 // but the choice is to do the transformation to a buffer
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	169 // and print that. And this need not be efficient.
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	170 for (; *cp != '\0'; cp += 1) {
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	171 switch (*cp) {
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	172 default:
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	173 st->print("%c", *cp);
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	174 break;
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	175 case '\n':
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	176 st->print(" -XX:%s=", name);
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	177 break;
38a50dd839cf 6619271: The -Xprintflags causes the VM to segv never parents: 13 diff changeset	178 }
0 a61af66fc99e Initial load duke parents: diff changeset	179 }
a61af66fc99e Initial load duke parents: diff changeset	180 }
a61af66fc99e Initial load duke parents: diff changeset	181 } else {
a61af66fc99e Initial load duke parents: diff changeset	182 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 // 4991491 do not "optimize out" the was_set false values: omitting them
a61af66fc99e Initial load duke parents: diff changeset	187 // tickles a Microsoft compiler bug causing flagTable to be malformed
a61af66fc99e Initial load duke parents: diff changeset	188
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	189 #define RUNTIME_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	190 #define RUNTIME_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{pd product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	191 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{diagnostic}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	192 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{experimental}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	193 #define RUNTIME_MANAGEABLE_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{manageable}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	194 #define RUNTIME_PRODUCT_RW_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product rw}", DEFAULT },
0 a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 #ifdef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	197 #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
a61af66fc99e Initial load duke parents: diff changeset	198 #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
a61af66fc99e Initial load duke parents: diff changeset	199 #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
a61af66fc99e Initial load duke parents: diff changeset	200 #else
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	201 #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	202 #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{pd}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	203 #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{notproduct}", DEFAULT },
0 a61af66fc99e Initial load duke parents: diff changeset	204 #endif
a61af66fc99e Initial load duke parents: diff changeset	205
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	206 #ifdef _LP64
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	207 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{lp64_product}", DEFAULT },
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	208 #else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	209 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	210 #endif // _LP64
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 103 diff changeset	211
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	212 #define C1_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	213 #define C1_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 pd product}", DEFAULT },
0 a61af66fc99e Initial load duke parents: diff changeset	214 #ifdef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	215 #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
a61af66fc99e Initial load duke parents: diff changeset	216 #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
a61af66fc99e Initial load duke parents: diff changeset	217 #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
a61af66fc99e Initial load duke parents: diff changeset	218 #else
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	219 #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	220 #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{C1 pd}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	221 #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1 notproduct}", DEFAULT },
0 a61af66fc99e Initial load duke parents: diff changeset	222 #endif
a61af66fc99e Initial load duke parents: diff changeset	223
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	224 #define C2_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	225 #define C2_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 pd product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	226 #define C2_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 diagnostic}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	227 #define C2_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 experimental}", DEFAULT },
0 a61af66fc99e Initial load duke parents: diff changeset	228 #ifdef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	229 #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
a61af66fc99e Initial load duke parents: diff changeset	230 #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
a61af66fc99e Initial load duke parents: diff changeset	231 #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
a61af66fc99e Initial load duke parents: diff changeset	232 #else
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	233 #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	234 #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{C2 pd}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	235 #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2 notproduct}", DEFAULT },
0 a61af66fc99e Initial load duke parents: diff changeset	236 #endif
a61af66fc99e Initial load duke parents: diff changeset	237
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	238 #define ARCH_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH product}", DEFAULT },
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	239 #define ARCH_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH diagnostic}", DEFAULT },
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	240 #define ARCH_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH experimental}", DEFAULT },
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	241 #ifdef PRODUCT
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	242 #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	243 #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	244 #else
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	245 #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH}", DEFAULT },
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	246 #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH notproduct}", DEFAULT },
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	247 #endif
a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	248
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	249 #define SHARK_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	250 #define SHARK_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark pd product}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	251 #define SHARK_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark diagnostic}", DEFAULT },
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	252 #ifdef PRODUCT
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	253 #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	254 #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	255 #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	256 #else
1768 6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	257 #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	258 #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{Shark pd}", DEFAULT },
6ee479178066 6979444: add command line option to print command line flags descriptions ikrylov parents: 1692 diff changeset	259 #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark notproduct}", DEFAULT },
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	260 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 static Flag flagTable[] = {
4088 358eca91be48 7116730: Revert 7116481: Commercial features in Hotspot must be gated by a switch phh parents: 4087 diff changeset	263 RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_EXPERIMENTAL_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT, RUNTIME_MANAGEABLE_FLAG_STRUCT, RUNTIME_PRODUCT_RW_FLAG_STRUCT, RUNTIME_LP64_PRODUCT_FLAG_STRUCT)
0 a61af66fc99e Initial load duke parents: diff changeset	264 RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6633 diff changeset	265 #if INCLUDE_ALL_GCS
350 d28aa69f0959 6618726: Introduce -XX:+UnlockExperimentalVMOptions flag ysr parents: 342 diff changeset	266 G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_EXPERIMENTAL_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT, RUNTIME_MANAGEABLE_FLAG_STRUCT, RUNTIME_PRODUCT_RW_FLAG_STRUCT)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6633 diff changeset	267 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	268 #ifdef COMPILER1
a61af66fc99e Initial load duke parents: diff changeset	269 C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, C1_PD_DEVELOP_FLAG_STRUCT, C1_PRODUCT_FLAG_STRUCT, C1_PD_PRODUCT_FLAG_STRUCT, C1_NOTPRODUCT_FLAG_STRUCT)
a61af66fc99e Initial load duke parents: diff changeset	270 #endif
a61af66fc99e Initial load duke parents: diff changeset	271 #ifdef COMPILER2
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 1067 diff changeset	272 C2_FLAGS(C2_DEVELOP_FLAG_STRUCT, C2_PD_DEVELOP_FLAG_STRUCT, C2_PRODUCT_FLAG_STRUCT, C2_PD_PRODUCT_FLAG_STRUCT, C2_DIAGNOSTIC_FLAG_STRUCT, C2_EXPERIMENTAL_FLAG_STRUCT, C2_NOTPRODUCT_FLAG_STRUCT)
0 a61af66fc99e Initial load duke parents: diff changeset	273 #endif
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	274 #ifdef SHARK
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	275 SHARK_FLAGS(SHARK_DEVELOP_FLAG_STRUCT, SHARK_PD_DEVELOP_FLAG_STRUCT, SHARK_PRODUCT_FLAG_STRUCT, SHARK_PD_PRODUCT_FLAG_STRUCT, SHARK_DIAGNOSTIC_FLAG_STRUCT, SHARK_NOTPRODUCT_FLAG_STRUCT)
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	276 #endif
6633 a5dd6e3ef9f3 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp twisti parents: 6197 diff changeset	277 ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, ARCH_PRODUCT_FLAG_STRUCT, ARCH_DIAGNOSTIC_FLAG_STRUCT, ARCH_EXPERIMENTAL_FLAG_STRUCT, ARCH_NOTPRODUCT_FLAG_STRUCT)
4107 cd00eaeebef6 7117389: Add a framework for vendor-specific command line switch extensions to Hotspot phh parents: 4088 diff changeset	278 FLAGTABLE_EXT
0 a61af66fc99e Initial load duke parents: diff changeset	279 {0, NULL, NULL}
a61af66fc99e Initial load duke parents: diff changeset	280 };
a61af66fc99e Initial load duke parents: diff changeset	281
a61af66fc99e Initial load duke parents: diff changeset	282 Flag* Flag::flags = flagTable;
a61af66fc99e Initial load duke parents: diff changeset	283 size_t Flag::numFlags = (sizeof(flagTable) / sizeof(Flag));
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 inline bool str_equal(const char* s, char* q, size_t len) {
a61af66fc99e Initial load duke parents: diff changeset	286 // s is null terminated, q is not!
a61af66fc99e Initial load duke parents: diff changeset	287 if (strlen(s) != (unsigned int) len) return false;
a61af66fc99e Initial load duke parents: diff changeset	288 return strncmp(s, q, len) == 0;
a61af66fc99e Initial load duke parents: diff changeset	289 }
a61af66fc99e Initial load duke parents: diff changeset	290
5947 80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	291 // Search the flag table for a named flag
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	292 Flag* Flag::find_flag(char* name, size_t length, bool allow_locked) {
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	293 for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
0 a61af66fc99e Initial load duke parents: diff changeset	294 if (str_equal(current->name, name, length)) {
5947 80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	295 // Found a matching entry. Report locked flags only if allowed.
0 a61af66fc99e Initial load duke parents: diff changeset	296 if (!(current->is_unlocked() \|\| current->is_unlocker())) {
5947 80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	297 if (!allow_locked) {
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	298 // disable use of locked flags, e.g. diagnostic, experimental,
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	299 // commercial... until they are explicitly unlocked
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	300 return NULL;
80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	301 }
0 a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303 return current;
a61af66fc99e Initial load duke parents: diff changeset	304 }
a61af66fc99e Initial load duke parents: diff changeset	305 }
5947 80fe40862b02 7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages jmelvin parents: 4773 diff changeset	306 // Flag name is not in the flag table
0 a61af66fc99e Initial load duke parents: diff changeset	307 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	308 }
a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 // Returns the address of the index'th element
a61af66fc99e Initial load duke parents: diff changeset	311 static Flag* address_of_flag(CommandLineFlagWithType flag) {
a61af66fc99e Initial load duke parents: diff changeset	312 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
a61af66fc99e Initial load duke parents: diff changeset	313 return &Flag::flags[flag];
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
a61af66fc99e Initial load duke parents: diff changeset	317 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
a61af66fc99e Initial load duke parents: diff changeset	318 Flag* f = &Flag::flags[flag];
a61af66fc99e Initial load duke parents: diff changeset	319 return (f->origin == DEFAULT);
a61af66fc99e Initial load duke parents: diff changeset	320 }
a61af66fc99e Initial load duke parents: diff changeset	321
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	322 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	323 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	324 Flag* f = &Flag::flags[flag];
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	325 return (f->origin == ERGONOMIC);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	326 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	327
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	328 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	329 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	330 Flag* f = &Flag::flags[flag];
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	331 return (f->origin == COMMAND_LINE);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	332 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	333
0 a61af66fc99e Initial load duke parents: diff changeset	334 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
a61af66fc99e Initial load duke parents: diff changeset	335 Flag* result = Flag::find_flag((char*)name, strlen(name));
a61af66fc99e Initial load duke parents: diff changeset	336 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	337 *value = (result->origin == COMMAND_LINE);
a61af66fc99e Initial load duke parents: diff changeset	338 return true;
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341 bool CommandLineFlags::boolAt(char* name, size_t len, bool* value) {
a61af66fc99e Initial load duke parents: diff changeset	342 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	343 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	344 if (!result->is_bool()) return false;
a61af66fc99e Initial load duke parents: diff changeset	345 *value = result->get_bool();
a61af66fc99e Initial load duke parents: diff changeset	346 return true;
a61af66fc99e Initial load duke parents: diff changeset	347 }
a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	350 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	351 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	352 if (!result->is_bool()) return false;
a61af66fc99e Initial load duke parents: diff changeset	353 bool old_value = result->get_bool();
a61af66fc99e Initial load duke parents: diff changeset	354 result->set_bool(*value);
a61af66fc99e Initial load duke parents: diff changeset	355 *value = old_value;
a61af66fc99e Initial load duke parents: diff changeset	356 result->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	357 return true;
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359
a61af66fc99e Initial load duke parents: diff changeset	360 void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	361 Flag* faddr = address_of_flag(flag);
a61af66fc99e Initial load duke parents: diff changeset	362 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
a61af66fc99e Initial load duke parents: diff changeset	363 faddr->set_bool(value);
a61af66fc99e Initial load duke parents: diff changeset	364 faddr->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	365 }
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) {
a61af66fc99e Initial load duke parents: diff changeset	368 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	369 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	370 if (!result->is_intx()) return false;
a61af66fc99e Initial load duke parents: diff changeset	371 *value = result->get_intx();
a61af66fc99e Initial load duke parents: diff changeset	372 return true;
a61af66fc99e Initial load duke parents: diff changeset	373 }
a61af66fc99e Initial load duke parents: diff changeset	374
a61af66fc99e Initial load duke parents: diff changeset	375 bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	376 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	377 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	378 if (!result->is_intx()) return false;
a61af66fc99e Initial load duke parents: diff changeset	379 intx old_value = result->get_intx();
a61af66fc99e Initial load duke parents: diff changeset	380 result->set_intx(*value);
a61af66fc99e Initial load duke parents: diff changeset	381 *value = old_value;
a61af66fc99e Initial load duke parents: diff changeset	382 result->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	383 return true;
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	387 Flag* faddr = address_of_flag(flag);
a61af66fc99e Initial load duke parents: diff changeset	388 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
a61af66fc99e Initial load duke parents: diff changeset	389 faddr->set_intx(value);
a61af66fc99e Initial load duke parents: diff changeset	390 faddr->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392
a61af66fc99e Initial load duke parents: diff changeset	393 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) {
a61af66fc99e Initial load duke parents: diff changeset	394 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	395 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	396 if (!result->is_uintx()) return false;
a61af66fc99e Initial load duke parents: diff changeset	397 *value = result->get_uintx();
a61af66fc99e Initial load duke parents: diff changeset	398 return true;
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	402 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	403 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	404 if (!result->is_uintx()) return false;
a61af66fc99e Initial load duke parents: diff changeset	405 uintx old_value = result->get_uintx();
a61af66fc99e Initial load duke parents: diff changeset	406 result->set_uintx(*value);
a61af66fc99e Initial load duke parents: diff changeset	407 *value = old_value;
a61af66fc99e Initial load duke parents: diff changeset	408 result->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	409 return true;
a61af66fc99e Initial load duke parents: diff changeset	410 }
a61af66fc99e Initial load duke parents: diff changeset	411
a61af66fc99e Initial load duke parents: diff changeset	412 void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	413 Flag* faddr = address_of_flag(flag);
a61af66fc99e Initial load duke parents: diff changeset	414 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
a61af66fc99e Initial load duke parents: diff changeset	415 faddr->set_uintx(value);
a61af66fc99e Initial load duke parents: diff changeset	416 faddr->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	417 }
a61af66fc99e Initial load duke parents: diff changeset	418
1064 473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	419 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) {
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	420 Flag* result = Flag::find_flag(name, len);
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	421 if (result == NULL) return false;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	422 if (!result->is_uint64_t()) return false;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	423 *value = result->get_uint64_t();
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	424 return true;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	425 }
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	426
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	427 bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin) {
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	428 Flag* result = Flag::find_flag(name, len);
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	429 if (result == NULL) return false;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	430 if (!result->is_uint64_t()) return false;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	431 uint64_t old_value = result->get_uint64_t();
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	432 result->set_uint64_t(*value);
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	433 *value = old_value;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	434 result->origin = origin;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	435 return true;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	436 }
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	437
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	438 void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, FlagValueOrigin origin) {
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	439 Flag* faddr = address_of_flag(flag);
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	440 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	441 faddr->set_uint64_t(value);
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	442 faddr->origin = origin;
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	443 }
473cce303f13 6887571: Increase default heap config sizes phh parents: 372 diff changeset	444
0 a61af66fc99e Initial load duke parents: diff changeset	445 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) {
a61af66fc99e Initial load duke parents: diff changeset	446 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	447 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	448 if (!result->is_double()) return false;
a61af66fc99e Initial load duke parents: diff changeset	449 *value = result->get_double();
a61af66fc99e Initial load duke parents: diff changeset	450 return true;
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452
a61af66fc99e Initial load duke parents: diff changeset	453 bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	454 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	455 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	456 if (!result->is_double()) return false;
a61af66fc99e Initial load duke parents: diff changeset	457 double old_value = result->get_double();
a61af66fc99e Initial load duke parents: diff changeset	458 result->set_double(*value);
a61af66fc99e Initial load duke parents: diff changeset	459 *value = old_value;
a61af66fc99e Initial load duke parents: diff changeset	460 result->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	461 return true;
a61af66fc99e Initial load duke parents: diff changeset	462 }
a61af66fc99e Initial load duke parents: diff changeset	463
a61af66fc99e Initial load duke parents: diff changeset	464 void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	465 Flag* faddr = address_of_flag(flag);
a61af66fc99e Initial load duke parents: diff changeset	466 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
a61af66fc99e Initial load duke parents: diff changeset	467 faddr->set_double(value);
a61af66fc99e Initial load duke parents: diff changeset	468 faddr->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	469 }
a61af66fc99e Initial load duke parents: diff changeset	470
a61af66fc99e Initial load duke parents: diff changeset	471 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
a61af66fc99e Initial load duke parents: diff changeset	472 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	473 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	474 if (!result->is_ccstr()) return false;
a61af66fc99e Initial load duke parents: diff changeset	475 *value = result->get_ccstr();
a61af66fc99e Initial load duke parents: diff changeset	476 return true;
a61af66fc99e Initial load duke parents: diff changeset	477 }
a61af66fc99e Initial load duke parents: diff changeset	478
a61af66fc99e Initial load duke parents: diff changeset	479 // Contract: Flag will make private copy of the incoming value.
a61af66fc99e Initial load duke parents: diff changeset	480 // Outgoing value is always malloc-ed, and caller MUST call free.
a61af66fc99e Initial load duke parents: diff changeset	481 bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	482 Flag* result = Flag::find_flag(name, len);
a61af66fc99e Initial load duke parents: diff changeset	483 if (result == NULL) return false;
a61af66fc99e Initial load duke parents: diff changeset	484 if (!result->is_ccstr()) return false;
a61af66fc99e Initial load duke parents: diff changeset	485 ccstr old_value = result->get_ccstr();
370 885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 196 diff changeset	486 char* new_value = NULL;
885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 196 diff changeset	487 if (*value != NULL) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	488 new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal);
370 885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 196 diff changeset	489 strcpy(new_value, *value);
885fe0f95828 6744783: HotSpot segfaults if given -XX options with an empty string argument never parents: 196 diff changeset	490 }
0 a61af66fc99e Initial load duke parents: diff changeset	491 result->set_ccstr(new_value);
a61af66fc99e Initial load duke parents: diff changeset	492 if (result->origin == DEFAULT && old_value != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	493 // Prior value is NOT heap allocated, but was a literal constant.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	494 char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	495 strcpy(old_value_to_free, old_value);
a61af66fc99e Initial load duke parents: diff changeset	496 old_value = old_value_to_free;
a61af66fc99e Initial load duke parents: diff changeset	497 }
a61af66fc99e Initial load duke parents: diff changeset	498 *value = old_value;
a61af66fc99e Initial load duke parents: diff changeset	499 result->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	500 return true;
a61af66fc99e Initial load duke parents: diff changeset	501 }
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 // Contract: Flag will make private copy of the incoming value.
a61af66fc99e Initial load duke parents: diff changeset	504 void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, FlagValueOrigin origin) {
a61af66fc99e Initial load duke parents: diff changeset	505 Flag* faddr = address_of_flag(flag);
a61af66fc99e Initial load duke parents: diff changeset	506 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
a61af66fc99e Initial load duke parents: diff changeset	507 ccstr old_value = faddr->get_ccstr();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	508 char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	509 strcpy(new_value, value);
a61af66fc99e Initial load duke parents: diff changeset	510 faddr->set_ccstr(new_value);
a61af66fc99e Initial load duke parents: diff changeset	511 if (faddr->origin != DEFAULT && old_value != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	512 // Prior value is heap allocated so free it.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	513 FREE_C_HEAP_ARRAY(char, old_value, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	514 }
a61af66fc99e Initial load duke parents: diff changeset	515 faddr->origin = origin;
a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517
a61af66fc99e Initial load duke parents: diff changeset	518 extern "C" {
a61af66fc99e Initial load duke parents: diff changeset	519 static int compare_flags(const void* void_a, const void* void_b) {
a61af66fc99e Initial load duke parents: diff changeset	520 return strcmp((((Flag) void_a))->name, (((Flag**) void_b))->name);
a61af66fc99e Initial load duke parents: diff changeset	521 }
a61af66fc99e Initial load duke parents: diff changeset	522 }
a61af66fc99e Initial load duke parents: diff changeset	523
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	524 void CommandLineFlags::printSetFlags(outputStream* out) {
0 a61af66fc99e Initial load duke parents: diff changeset	525 // Print which flags were set on the command line
a61af66fc99e Initial load duke parents: diff changeset	526 // note: this method is called before the thread structure is in place
a61af66fc99e Initial load duke parents: diff changeset	527 // which means resource allocation cannot be used.
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 // Compute size
a61af66fc99e Initial load duke parents: diff changeset	530 int length= 0;
a61af66fc99e Initial load duke parents: diff changeset	531 while (flagTable[length].name != NULL) length++;
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533 // Sort
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	534 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	535 for (int index = 0; index < length; index++) {
a61af66fc99e Initial load duke parents: diff changeset	536 array[index] = &flagTable[index];
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538 qsort(array, length, sizeof(Flag*), compare_flags);
a61af66fc99e Initial load duke parents: diff changeset	539
a61af66fc99e Initial load duke parents: diff changeset	540 // Print
a61af66fc99e Initial load duke parents: diff changeset	541 for (int i = 0; i < length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	542 if (array[i]->origin /* naked field! */) {
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	543 array[i]->print_as_flag(out);
4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	544 out->print(" ");
0 a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546 }
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	547 out->cr();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	548 FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	549 }
a61af66fc99e Initial load duke parents: diff changeset	550
a61af66fc99e Initial load duke parents: diff changeset	551 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 void CommandLineFlags::verify() {
a61af66fc99e Initial load duke parents: diff changeset	555 assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
a61af66fc99e Initial load duke parents: diff changeset	556 }
a61af66fc99e Initial load duke parents: diff changeset	557
1150 f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1080 diff changeset	558 #endif // PRODUCT
f62a22282a47 6914622: Print values of all flags for product VM kvn parents: 1080 diff changeset	559
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	560 void CommandLineFlags::printFlags(outputStream* out, bool withComments) {
0 a61af66fc99e Initial load duke parents: diff changeset	561 // Print the flags sorted by name
a61af66fc99e Initial load duke parents: diff changeset	562 // note: this method is called before the thread structure is in place
a61af66fc99e Initial load duke parents: diff changeset	563 // which means resource allocation cannot be used.
a61af66fc99e Initial load duke parents: diff changeset	564
a61af66fc99e Initial load duke parents: diff changeset	565 // Compute size
a61af66fc99e Initial load duke parents: diff changeset	566 int length= 0;
a61af66fc99e Initial load duke parents: diff changeset	567 while (flagTable[length].name != NULL) length++;
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569 // Sort
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	570 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	571 for (int index = 0; index < length; index++) {
a61af66fc99e Initial load duke parents: diff changeset	572 array[index] = &flagTable[index];
a61af66fc99e Initial load duke parents: diff changeset	573 }
a61af66fc99e Initial load duke parents: diff changeset	574 qsort(array, length, sizeof(Flag*), compare_flags);
a61af66fc99e Initial load duke parents: diff changeset	575
a61af66fc99e Initial load duke parents: diff changeset	576 // Print
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	577 out->print_cr("[Global flags]");
0 a61af66fc99e Initial load duke parents: diff changeset	578 for (int i = 0; i < length; i++) {
a61af66fc99e Initial load duke parents: diff changeset	579 if (array[i]->is_unlocked()) {
4773 4f25538b54c9 7120511: Add diagnostic commands fparain parents: 4715 diff changeset	580 array[i]->print_on(out, withComments);
0 a61af66fc99e Initial load duke parents: diff changeset	581 }
a61af66fc99e Initial load duke parents: diff changeset	582 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6049 diff changeset	583 FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
0 a61af66fc99e Initial load duke parents: diff changeset	584 }

Mercurial > hg > truffle

annotate src/share/vm/runtime/globals.cpp @ 10246:194f52aa2f23