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

annotate src/share/vm/runtime/globals.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	a5dd6e3ef9f3
children	1baf7f1e3f23 db9981fd3124

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

Mercurial > hg > truffle

annotate src/share/vm/runtime/globals.cpp @ 6862:8a5ea0a9ccc4