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

annotate src/share/vm/runtime/globals.cpp @ 4715:6c995c08526c

7122880: Extend vendor-specific command interface to include manageable switches Summary: Add Flag::external_ext()/writable_ext(), both return false. Reviewed-by: coleenp, zgu

author	phh
date	Mon, 19 Dec 2011 15:50:47 -0500
parents	cd00eaeebef6
children	4f25538b54c9

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

Mercurial > hg > truffle

annotate src/share/vm/runtime/globals.cpp @ 4715:6c995c08526c