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

annotate src/share/vm/runtime/globals.cpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	5fc51c1ecdeb
children	6b0fd0964b87

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

Mercurial > hg > truffle

annotate src/share/vm/runtime/globals.cpp @ 9126:bc26f978b0ce