Mercurial > jdk8-mips64-public > hotspot / changeset
changeset
8024545: make develop and notproduct flag values available in product builds
Thu, 26 Sep 2013 12:07:53 -0700
- author
- twisti
- date
- Thu, 26 Sep 2013 12:07:53 -0700
- changeset 5790
- 72b7e96c1922
- parent 5763
- 1b64d46620a3
- child 5791
- c9ccd7b85f20
8024545: make develop and notproduct flag values available in product builds
Reviewed-by: dholmes, kvn
1.1 --- a/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java Tue Sep 24 16:08:00 2013 -0700 1.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java Thu Sep 26 12:07:53 2013 -0700 1.3 @@ -134,15 +134,13 @@ 1.4 private String type; 1.5 private String name; 1.6 private Address addr; 1.7 - private String kind; 1.8 - private int origin; 1.9 + private int flags; 1.10 1.11 - private Flag(String type, String name, Address addr, String kind, int origin) { 1.12 + private Flag(String type, String name, Address addr, int flags) { 1.13 this.type = type; 1.14 this.name = name; 1.15 this.addr = addr; 1.16 - this.kind = kind; 1.17 - this.origin = origin; 1.18 + this.flags = flags; 1.19 } 1.20 1.21 public String getType() { 1.22 @@ -157,12 +155,8 @@ 1.23 return addr; 1.24 } 1.25 1.26 - public String getKind() { 1.27 - return kind; 1.28 - } 1.29 - 1.30 public int getOrigin() { 1.31 - return origin; 1.32 + return flags & 0xF; // XXX can we get the mask bits from somewhere? 1.33 } 1.34 1.35 public boolean isBool() { 1.36 @@ -173,8 +167,7 @@ 1.37 if (Assert.ASSERTS_ENABLED) { 1.38 Assert.that(isBool(), "not a bool flag!"); 1.39 } 1.40 - return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned()) 1.41 - != 0; 1.42 + return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned()) != 0; 1.43 } 1.44 1.45 public boolean isIntx() { 1.46 @@ -843,11 +836,10 @@ 1.47 1.48 Address flagAddr = flagType.getAddressField("flags").getValue(); 1.49 1.50 - AddressField typeFld = flagType.getAddressField("type"); 1.51 - AddressField nameFld = flagType.getAddressField("name"); 1.52 - AddressField addrFld = flagType.getAddressField("addr"); 1.53 - AddressField kindFld = flagType.getAddressField("kind"); 1.54 - CIntField originFld = new CIntField(flagType.getCIntegerField("origin"), 0); 1.55 + AddressField typeFld = flagType.getAddressField("_type"); 1.56 + AddressField nameFld = flagType.getAddressField("_name"); 1.57 + AddressField addrFld = flagType.getAddressField("_addr"); 1.58 + CIntField flagsFld = new CIntField(flagType.getCIntegerField("_flags"), 0); 1.59 1.60 long flagSize = flagType.getSize(); // sizeof(Flag) 1.61 1.62 @@ -856,9 +848,8 @@ 1.63 String type = CStringUtilities.getString(typeFld.getValue(flagAddr)); 1.64 String name = CStringUtilities.getString(nameFld.getValue(flagAddr)); 1.65 Address addr = addrFld.getValue(flagAddr); 1.66 - String kind = CStringUtilities.getString(kindFld.getValue(flagAddr)); 1.67 - int origin = (int)originFld.getValue(flagAddr); 1.68 - commandLineFlags[f] = new Flag(type, name, addr, kind, origin); 1.69 + int flags = (int)flagsFld.getValue(flagAddr); 1.70 + commandLineFlags[f] = new Flag(type, name, addr, flags); 1.71 flagAddr = flagAddr.addOffsetTo(flagSize); 1.72 } 1.73
2.1 --- a/src/share/vm/prims/jvm.cpp Tue Sep 24 16:08:00 2013 -0700 2.2 +++ b/src/share/vm/prims/jvm.cpp Thu Sep 26 12:07:53 2013 -0700 2.3 @@ -4235,13 +4235,13 @@ 2.4 2.5 JVM_LEAF(jboolean, JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get)) 2.6 JVMWrapper("JVM_AccessBoolVMFlag"); 2.7 - return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, INTERNAL); 2.8 + return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, Flag::INTERNAL); 2.9 JVM_END 2.10 2.11 JVM_LEAF(jboolean, JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get)) 2.12 JVMWrapper("JVM_AccessVMIntFlag"); 2.13 intx v; 2.14 - jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, INTERNAL); 2.15 + jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, Flag::INTERNAL); 2.16 *value = (jint)v; 2.17 return result; 2.18 JVM_END
3.1 --- a/src/share/vm/runtime/arguments.cpp Tue Sep 24 16:08:00 2013 -0700 3.2 +++ b/src/share/vm/runtime/arguments.cpp Thu Sep 26 12:07:53 2013 -0700 3.3 @@ -625,11 +625,11 @@ 3.4 } 3.5 } 3.6 3.7 -static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) { 3.8 +static bool set_bool_flag(char* name, bool value, Flag::Flags origin) { 3.9 return CommandLineFlags::boolAtPut(name, &value, origin); 3.10 } 3.11 3.12 -static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) { 3.13 +static bool set_fp_numeric_flag(char* name, char* value, Flag::Flags origin) { 3.14 double v; 3.15 if (sscanf(value, "%lf", &v) != 1) { 3.16 return false; 3.17 @@ -641,7 +641,7 @@ 3.18 return false; 3.19 } 3.20 3.21 -static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) { 3.22 +static bool set_numeric_flag(char* name, char* value, Flag::Flags origin) { 3.23 julong v; 3.24 intx intx_v; 3.25 bool is_neg = false; 3.26 @@ -674,14 +674,14 @@ 3.27 return false; 3.28 } 3.29 3.30 -static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) { 3.31 +static bool set_string_flag(char* name, const char* value, Flag::Flags origin) { 3.32 if (!CommandLineFlags::ccstrAtPut(name, &value, origin)) return false; 3.33 // Contract: CommandLineFlags always returns a pointer that needs freeing. 3.34 FREE_C_HEAP_ARRAY(char, value, mtInternal); 3.35 return true; 3.36 } 3.37 3.38 -static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) { 3.39 +static bool append_to_string_flag(char* name, const char* new_value, Flag::Flags origin) { 3.40 const char* old_value = ""; 3.41 if (!CommandLineFlags::ccstrAt(name, &old_value)) return false; 3.42 size_t old_len = old_value != NULL ? strlen(old_value) : 0; 3.43 @@ -709,7 +709,7 @@ 3.44 return true; 3.45 } 3.46 3.47 -bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) { 3.48 +bool Arguments::parse_argument(const char* arg, Flag::Flags origin) { 3.49 3.50 // range of acceptable characters spelled out for portability reasons 3.51 #define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]" 3.52 @@ -850,7 +850,7 @@ 3.53 } 3.54 3.55 bool Arguments::process_argument(const char* arg, 3.56 - jboolean ignore_unrecognized, FlagValueOrigin origin) { 3.57 + jboolean ignore_unrecognized, Flag::Flags origin) { 3.58 3.59 JDK_Version since = JDK_Version(); 3.60 3.61 @@ -904,7 +904,7 @@ 3.62 jio_fprintf(defaultStream::error_stream(), 3.63 "Did you mean '%s%s%s'?\n", 3.64 (fuzzy_matched->is_bool()) ? "(+/-)" : "", 3.65 - fuzzy_matched->name, 3.66 + fuzzy_matched->_name, 3.67 (fuzzy_matched->is_bool()) ? "" : "=<value>"); 3.68 } 3.69 } 3.70 @@ -952,7 +952,7 @@ 3.71 // this allows a way to include spaces in string-valued options 3.72 token[pos] = '\0'; 3.73 logOption(token); 3.74 - result &= process_argument(token, ignore_unrecognized, CONFIG_FILE); 3.75 + result &= process_argument(token, ignore_unrecognized, Flag::CONFIG_FILE); 3.76 build_jvm_flags(token); 3.77 pos = 0; 3.78 in_white_space = true; 3.79 @@ -970,7 +970,7 @@ 3.80 } 3.81 if (pos > 0) { 3.82 token[pos] = '\0'; 3.83 - result &= process_argument(token, ignore_unrecognized, CONFIG_FILE); 3.84 + result &= process_argument(token, ignore_unrecognized, Flag::CONFIG_FILE); 3.85 build_jvm_flags(token); 3.86 } 3.87 fclose(stream); 3.88 @@ -2434,7 +2434,7 @@ 3.89 } 3.90 3.91 // Parse JavaVMInitArgs structure passed in 3.92 - result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, COMMAND_LINE); 3.93 + result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, Flag::COMMAND_LINE); 3.94 if (result != JNI_OK) { 3.95 return result; 3.96 } 3.97 @@ -2521,7 +2521,7 @@ 3.98 jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, 3.99 SysClassPath* scp_p, 3.100 bool* scp_assembly_required_p, 3.101 - FlagValueOrigin origin) { 3.102 + Flag::Flags origin) { 3.103 // Remaining part of option string 3.104 const char* tail; 3.105 3.106 @@ -3344,7 +3344,7 @@ 3.107 } 3.108 } 3.109 3.110 - return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR)); 3.111 + return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, Flag::ENVIRON_VAR)); 3.112 } 3.113 return JNI_OK; 3.114 }
4.1 --- a/src/share/vm/runtime/arguments.hpp Tue Sep 24 16:08:00 2013 -0700 4.2 +++ b/src/share/vm/runtime/arguments.hpp Thu Sep 26 12:07:53 2013 -0700 4.3 @@ -360,15 +360,15 @@ 4.4 4.5 // Argument parsing 4.6 static void do_pd_flag_adjustments(); 4.7 - static bool parse_argument(const char* arg, FlagValueOrigin origin); 4.8 - static bool process_argument(const char* arg, jboolean ignore_unrecognized, FlagValueOrigin origin); 4.9 + static bool parse_argument(const char* arg, Flag::Flags origin); 4.10 + static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin); 4.11 static void process_java_launcher_argument(const char*, void*); 4.12 static void process_java_compiler_argument(char* arg); 4.13 static jint parse_options_environment_variable(const char* name, SysClassPath* scp_p, bool* scp_assembly_required_p); 4.14 static jint parse_java_tool_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p); 4.15 static jint parse_java_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p); 4.16 static jint parse_vm_init_args(const JavaVMInitArgs* args); 4.17 - static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, SysClassPath* scp_p, bool* scp_assembly_required_p, FlagValueOrigin origin); 4.18 + static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, SysClassPath* scp_p, bool* scp_assembly_required_p, Flag::Flags origin); 4.19 static jint finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required); 4.20 static bool is_bad_option(const JavaVMOption* option, jboolean ignore, 4.21 const char* option_type);
5.1 --- a/src/share/vm/runtime/globals.cpp Tue Sep 24 16:08:00 2013 -0700 5.2 +++ b/src/share/vm/runtime/globals.cpp Thu Sep 26 12:07:53 2013 -0700 5.3 @@ -62,26 +62,174 @@ 5.4 MATERIALIZE_FLAGS_EXT 5.5 5.6 5.7 +void Flag::check_writable() { 5.8 + if (is_constant_in_binary()) { 5.9 + fatal(err_msg("flag is constant: %s", _name)); 5.10 + } 5.11 +} 5.12 + 5.13 +bool Flag::is_bool() const { 5.14 + return strcmp(_type, "bool") == 0; 5.15 +} 5.16 + 5.17 +bool Flag::get_bool() const { 5.18 + return *((bool*) _addr); 5.19 +} 5.20 + 5.21 +void Flag::set_bool(bool value) { 5.22 + check_writable(); 5.23 + *((bool*) _addr) = value; 5.24 +} 5.25 + 5.26 +bool Flag::is_intx() const { 5.27 + return strcmp(_type, "intx") == 0; 5.28 +} 5.29 + 5.30 +intx Flag::get_intx() const { 5.31 + return *((intx*) _addr); 5.32 +} 5.33 + 5.34 +void Flag::set_intx(intx value) { 5.35 + check_writable(); 5.36 + *((intx*) _addr) = value; 5.37 +} 5.38 + 5.39 +bool Flag::is_uintx() const { 5.40 + return strcmp(_type, "uintx") == 0; 5.41 +} 5.42 + 5.43 +uintx Flag::get_uintx() const { 5.44 + return *((uintx*) _addr); 5.45 +} 5.46 + 5.47 +void Flag::set_uintx(uintx value) { 5.48 + check_writable(); 5.49 + *((uintx*) _addr) = value; 5.50 +} 5.51 + 5.52 +bool Flag::is_uint64_t() const { 5.53 + return strcmp(_type, "uint64_t") == 0; 5.54 +} 5.55 + 5.56 +uint64_t Flag::get_uint64_t() const { 5.57 + return *((uint64_t*) _addr); 5.58 +} 5.59 + 5.60 +void Flag::set_uint64_t(uint64_t value) { 5.61 + check_writable(); 5.62 + *((uint64_t*) _addr) = value; 5.63 +} 5.64 + 5.65 +bool Flag::is_double() const { 5.66 + return strcmp(_type, "double") == 0; 5.67 +} 5.68 + 5.69 +double Flag::get_double() const { 5.70 + return *((double*) _addr); 5.71 +} 5.72 + 5.73 +void Flag::set_double(double value) { 5.74 + check_writable(); 5.75 + *((double*) _addr) = value; 5.76 +} 5.77 + 5.78 +bool Flag::is_ccstr() const { 5.79 + return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0; 5.80 +} 5.81 + 5.82 +bool Flag::ccstr_accumulates() const { 5.83 + return strcmp(_type, "ccstrlist") == 0; 5.84 +} 5.85 + 5.86 +ccstr Flag::get_ccstr() const { 5.87 + return *((ccstr*) _addr); 5.88 +} 5.89 + 5.90 +void Flag::set_ccstr(ccstr value) { 5.91 + check_writable(); 5.92 + *((ccstr*) _addr) = value; 5.93 +} 5.94 + 5.95 + 5.96 +Flag::Flags Flag::get_origin() { 5.97 + return Flags(_flags & VALUE_ORIGIN_MASK); 5.98 +} 5.99 + 5.100 +void Flag::set_origin(Flags origin) { 5.101 + assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity"); 5.102 + _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | origin); 5.103 +} 5.104 + 5.105 +bool Flag::is_default() { 5.106 + return (get_origin() == DEFAULT); 5.107 +} 5.108 + 5.109 +bool Flag::is_ergonomic() { 5.110 + return (get_origin() == ERGONOMIC); 5.111 +} 5.112 + 5.113 +bool Flag::is_command_line() { 5.114 + return (get_origin() == COMMAND_LINE); 5.115 +} 5.116 + 5.117 +bool Flag::is_product() const { 5.118 + return (_flags & KIND_PRODUCT) != 0; 5.119 +} 5.120 + 5.121 +bool Flag::is_manageable() const { 5.122 + return (_flags & KIND_MANAGEABLE) != 0; 5.123 +} 5.124 + 5.125 +bool Flag::is_diagnostic() const { 5.126 + return (_flags & KIND_DIAGNOSTIC) != 0; 5.127 +} 5.128 + 5.129 +bool Flag::is_experimental() const { 5.130 + return (_flags & KIND_EXPERIMENTAL) != 0; 5.131 +} 5.132 + 5.133 +bool Flag::is_notproduct() const { 5.134 + return (_flags & KIND_NOT_PRODUCT) != 0; 5.135 +} 5.136 + 5.137 +bool Flag::is_develop() const { 5.138 + return (_flags & KIND_DEVELOP) != 0; 5.139 +} 5.140 + 5.141 +bool Flag::is_read_write() const { 5.142 + return (_flags & KIND_READ_WRITE) != 0; 5.143 +} 5.144 + 5.145 +bool Flag::is_commercial() const { 5.146 + return (_flags & KIND_COMMERCIAL) != 0; 5.147 +} 5.148 + 5.149 +/** 5.150 + * Returns if this flag is a constant in the binary. Right now this is 5.151 + * true for notproduct and develop flags in product builds. 5.152 + */ 5.153 +bool Flag::is_constant_in_binary() const { 5.154 +#ifdef PRODUCT 5.155 + return is_notproduct() || is_develop(); 5.156 +#else 5.157 + return false; 5.158 +#endif 5.159 +} 5.160 + 5.161 bool Flag::is_unlocker() const { 5.162 - return strcmp(name, "UnlockDiagnosticVMOptions") == 0 || 5.163 - strcmp(name, "UnlockExperimentalVMOptions") == 0 || 5.164 + return strcmp(_name, "UnlockDiagnosticVMOptions") == 0 || 5.165 + strcmp(_name, "UnlockExperimentalVMOptions") == 0 || 5.166 is_unlocker_ext(); 5.167 } 5.168 5.169 bool Flag::is_unlocked() const { 5.170 - if (strcmp(kind, "{diagnostic}") == 0 || 5.171 - strcmp(kind, "{C2 diagnostic}") == 0 || 5.172 - strcmp(kind, "{ARCH diagnostic}") == 0 || 5.173 - strcmp(kind, "{Shark diagnostic}") == 0) { 5.174 + if (is_diagnostic()) { 5.175 return UnlockDiagnosticVMOptions; 5.176 - } else if (strcmp(kind, "{experimental}") == 0 || 5.177 - strcmp(kind, "{C2 experimental}") == 0 || 5.178 - strcmp(kind, "{ARCH experimental}") == 0 || 5.179 - strcmp(kind, "{Shark experimental}") == 0) { 5.180 + } 5.181 + if (is_experimental()) { 5.182 return UnlockExperimentalVMOptions; 5.183 - } else { 5.184 - return is_unlocked_ext(); 5.185 } 5.186 + return is_unlocked_ext(); 5.187 } 5.188 5.189 // Get custom message for this locked flag, or return NULL if 5.190 @@ -91,16 +239,14 @@ 5.191 } 5.192 5.193 bool Flag::is_writeable() const { 5.194 - return strcmp(kind, "{manageable}") == 0 || 5.195 - strcmp(kind, "{product rw}") == 0 || 5.196 - is_writeable_ext(); 5.197 + return is_manageable() || (is_product() && is_read_write()) || is_writeable_ext(); 5.198 } 5.199 5.200 // All flags except "manageable" are assumed to be internal flags. 5.201 // Long term, we need to define a mechanism to specify which flags 5.202 // are external/stable and change this function accordingly. 5.203 bool Flag::is_external() const { 5.204 - return strcmp(kind, "{manageable}") == 0 || is_external_ext(); 5.205 + return is_manageable() || is_external_ext(); 5.206 } 5.207 5.208 5.209 @@ -108,53 +254,113 @@ 5.210 #define FORMAT_BUFFER_LEN 16 5.211 5.212 void Flag::print_on(outputStream* st, bool withComments) { 5.213 - st->print("%9s %-40s %c= ", type, name, (origin != DEFAULT ? ':' : ' ')); 5.214 - if (is_bool()) st->print("%-16s", get_bool() ? "true" : "false"); 5.215 - if (is_intx()) st->print("%-16ld", get_intx()); 5.216 - if (is_uintx()) st->print("%-16lu", get_uintx()); 5.217 - if (is_uint64_t()) st->print("%-16lu", get_uint64_t()); 5.218 - if (is_double()) st->print("%-16f", get_double()); 5.219 + // Don't print notproduct and develop flags in a product build. 5.220 + if (is_constant_in_binary()) { 5.221 + return; 5.222 + } 5.223 5.224 + st->print("%9s %-40s %c= ", _type, _name, (!is_default() ? ':' : ' ')); 5.225 + 5.226 + if (is_bool()) { 5.227 + st->print("%-16s", get_bool() ? "true" : "false"); 5.228 + } 5.229 + if (is_intx()) { 5.230 + st->print("%-16ld", get_intx()); 5.231 + } 5.232 + if (is_uintx()) { 5.233 + st->print("%-16lu", get_uintx()); 5.234 + } 5.235 + if (is_uint64_t()) { 5.236 + st->print("%-16lu", get_uint64_t()); 5.237 + } 5.238 + if (is_double()) { 5.239 + st->print("%-16f", get_double()); 5.240 + } 5.241 if (is_ccstr()) { 5.242 - const char* cp = get_ccstr(); 5.243 - if (cp != NULL) { 5.244 - const char* eol; 5.245 - while ((eol = strchr(cp, '\n')) != NULL) { 5.246 - char format_buffer[FORMAT_BUFFER_LEN]; 5.247 - size_t llen = pointer_delta(eol, cp, sizeof(char)); 5.248 - jio_snprintf(format_buffer, FORMAT_BUFFER_LEN, 5.249 - "%%." SIZE_FORMAT "s", llen); 5.250 - st->print(format_buffer, cp); 5.251 - st->cr(); 5.252 - cp = eol+1; 5.253 - st->print("%5s %-35s += ", "", name); 5.254 - } 5.255 - st->print("%-16s", cp); 5.256 - } 5.257 - else st->print("%-16s", ""); 5.258 + const char* cp = get_ccstr(); 5.259 + if (cp != NULL) { 5.260 + const char* eol; 5.261 + while ((eol = strchr(cp, '\n')) != NULL) { 5.262 + char format_buffer[FORMAT_BUFFER_LEN]; 5.263 + size_t llen = pointer_delta(eol, cp, sizeof(char)); 5.264 + jio_snprintf(format_buffer, FORMAT_BUFFER_LEN, 5.265 + "%%." SIZE_FORMAT "s", llen); 5.266 + st->print(format_buffer, cp); 5.267 + st->cr(); 5.268 + cp = eol+1; 5.269 + st->print("%5s %-35s += ", "", _name); 5.270 + } 5.271 + st->print("%-16s", cp); 5.272 + } 5.273 + else st->print("%-16s", ""); 5.274 } 5.275 - st->print("%-20s", kind); 5.276 + 5.277 + st->print("%-20"); 5.278 + print_kind(st); 5.279 + 5.280 if (withComments) { 5.281 #ifndef PRODUCT 5.282 - st->print("%s", doc ); 5.283 + st->print("%s", _doc); 5.284 #endif 5.285 } 5.286 st->cr(); 5.287 } 5.288 5.289 +void Flag::print_kind(outputStream* st) { 5.290 + struct Data { 5.291 + int flag; 5.292 + const char* name; 5.293 + }; 5.294 + 5.295 + Data data[] = { 5.296 + { KIND_C1, "C1" }, 5.297 + { KIND_C2, "C2" }, 5.298 + { KIND_ARCH, "ARCH" }, 5.299 + { KIND_SHARK, "SHARK" }, 5.300 + { KIND_PLATFORM_DEPENDENT, "pd" }, 5.301 + { KIND_PRODUCT, "product" }, 5.302 + { KIND_MANAGEABLE, "manageable" }, 5.303 + { KIND_DIAGNOSTIC, "diagnostic" }, 5.304 + { KIND_NOT_PRODUCT, "notproduct" }, 5.305 + { KIND_DEVELOP, "develop" }, 5.306 + { KIND_LP64_PRODUCT, "lp64_product" }, 5.307 + { KIND_READ_WRITE, "rw" }, 5.308 + { -1, "" } 5.309 + }; 5.310 + 5.311 + if ((_flags & KIND_MASK) != 0) { 5.312 + st->print("{"); 5.313 + bool is_first = true; 5.314 + 5.315 + for (int i = 0; data[i].flag != -1; i++) { 5.316 + Data d = data[i]; 5.317 + if ((_flags & d.flag) != 0) { 5.318 + if (is_first) { 5.319 + is_first = false; 5.320 + } else { 5.321 + st->print(" "); 5.322 + } 5.323 + st->print(d.name); 5.324 + } 5.325 + } 5.326 + 5.327 + st->print("}"); 5.328 + } 5.329 +} 5.330 + 5.331 void Flag::print_as_flag(outputStream* st) { 5.332 if (is_bool()) { 5.333 - st->print("-XX:%s%s", get_bool() ? "+" : "-", name); 5.334 + st->print("-XX:%s%s", get_bool() ? "+" : "-", _name); 5.335 } else if (is_intx()) { 5.336 - st->print("-XX:%s=" INTX_FORMAT, name, get_intx()); 5.337 + st->print("-XX:%s=" INTX_FORMAT, _name, get_intx()); 5.338 } else if (is_uintx()) { 5.339 - st->print("-XX:%s=" UINTX_FORMAT, name, get_uintx()); 5.340 + st->print("-XX:%s=" UINTX_FORMAT, _name, get_uintx()); 5.341 } else if (is_uint64_t()) { 5.342 - st->print("-XX:%s=" UINT64_FORMAT, name, get_uint64_t()); 5.343 + st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t()); 5.344 } else if (is_double()) { 5.345 - st->print("-XX:%s=%f", name, get_double()); 5.346 + st->print("-XX:%s=%f", _name, get_double()); 5.347 } else if (is_ccstr()) { 5.348 - st->print("-XX:%s=", name); 5.349 + st->print("-XX:%s=", _name); 5.350 const char* cp = get_ccstr(); 5.351 if (cp != NULL) { 5.352 // Need to turn embedded '\n's back into separate arguments 5.353 @@ -167,7 +373,7 @@ 5.354 st->print("%c", *cp); 5.355 break; 5.356 case '\n': 5.357 - st->print(" -XX:%s=", name); 5.358 + st->print(" -XX:%s=", _name); 5.359 break; 5.360 } 5.361 } 5.362 @@ -180,79 +386,51 @@ 5.363 // 4991491 do not "optimize out" the was_set false values: omitting them 5.364 // tickles a Microsoft compiler bug causing flagTable to be malformed 5.365 5.366 -#define RUNTIME_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product}", DEFAULT }, 5.367 -#define RUNTIME_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{pd product}", DEFAULT }, 5.368 -#define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{diagnostic}", DEFAULT }, 5.369 -#define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{experimental}", DEFAULT }, 5.370 -#define RUNTIME_MANAGEABLE_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{manageable}", DEFAULT }, 5.371 -#define RUNTIME_PRODUCT_RW_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product rw}", DEFAULT }, 5.372 +#define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name) 5.373 5.374 -#ifdef PRODUCT 5.375 - #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.376 - #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */ 5.377 - #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) 5.378 -#else 5.379 - #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "", DEFAULT }, 5.380 - #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{pd}", DEFAULT }, 5.381 - #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{notproduct}", DEFAULT }, 5.382 -#endif 5.383 +#define RUNTIME_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) }, 5.384 +#define RUNTIME_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) }, 5.385 +#define RUNTIME_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) }, 5.386 +#define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) }, 5.387 +#define RUNTIME_MANAGEABLE_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) }, 5.388 +#define RUNTIME_PRODUCT_RW_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_READ_WRITE) }, 5.389 +#define RUNTIME_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP) }, 5.390 +#define RUNTIME_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) }, 5.391 +#define RUNTIME_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_NOT_PRODUCT) }, 5.392 5.393 #ifdef _LP64 5.394 - #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{lp64_product}", DEFAULT }, 5.395 +#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_LP64_PRODUCT) }, 5.396 #else 5.397 - #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.398 +#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.399 #endif // _LP64 5.400 5.401 -#define C1_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 product}", DEFAULT }, 5.402 -#define C1_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 pd product}", DEFAULT }, 5.403 -#define C1_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 diagnostic}", DEFAULT }, 5.404 -#ifdef PRODUCT 5.405 - #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.406 - #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */ 5.407 - #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) 5.408 -#else 5.409 - #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1}", DEFAULT }, 5.410 - #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{C1 pd}", DEFAULT }, 5.411 - #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1 notproduct}", DEFAULT }, 5.412 -#endif 5.413 +#define C1_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_PRODUCT) }, 5.414 +#define C1_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) }, 5.415 +#define C1_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DIAGNOSTIC) }, 5.416 +#define C1_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DEVELOP) }, 5.417 +#define C1_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) }, 5.418 +#define C1_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C1 | Flag::KIND_NOT_PRODUCT) }, 5.419 5.420 -#define C2_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 product}", DEFAULT }, 5.421 -#define C2_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 pd product}", DEFAULT }, 5.422 -#define C2_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 diagnostic}", DEFAULT }, 5.423 -#define C2_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 experimental}", DEFAULT }, 5.424 -#ifdef PRODUCT 5.425 - #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.426 - #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */ 5.427 - #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) 5.428 -#else 5.429 - #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2}", DEFAULT }, 5.430 - #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{C2 pd}", DEFAULT }, 5.431 - #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2 notproduct}", DEFAULT }, 5.432 -#endif 5.433 +#define C2_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_PRODUCT) }, 5.434 +#define C2_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) }, 5.435 +#define C2_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DIAGNOSTIC) }, 5.436 +#define C2_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_EXPERIMENTAL) }, 5.437 +#define C2_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DEVELOP) }, 5.438 +#define C2_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) }, 5.439 +#define C2_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_C2 | Flag::KIND_NOT_PRODUCT) }, 5.440 5.441 -#define ARCH_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH product}", DEFAULT }, 5.442 -#define ARCH_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH diagnostic}", DEFAULT }, 5.443 -#define ARCH_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH experimental}", DEFAULT }, 5.444 -#ifdef PRODUCT 5.445 - #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.446 - #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) 5.447 -#else 5.448 - #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH}", DEFAULT }, 5.449 - #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH notproduct}", DEFAULT }, 5.450 -#endif 5.451 +#define ARCH_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_PRODUCT) }, 5.452 +#define ARCH_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_DIAGNOSTIC) }, 5.453 +#define ARCH_EXPERIMENTAL_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_EXPERIMENTAL) }, 5.454 +#define ARCH_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_DEVELOP) }, 5.455 +#define ARCH_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_NOT_PRODUCT) }, 5.456 5.457 -#define SHARK_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark product}", DEFAULT }, 5.458 -#define SHARK_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark pd product}", DEFAULT }, 5.459 -#define SHARK_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark diagnostic}", DEFAULT }, 5.460 -#ifdef PRODUCT 5.461 - #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */ 5.462 - #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */ 5.463 - #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) 5.464 -#else 5.465 - #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark}", DEFAULT }, 5.466 - #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{Shark pd}", DEFAULT }, 5.467 - #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark notproduct}", DEFAULT }, 5.468 -#endif 5.469 +#define SHARK_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_PRODUCT) }, 5.470 +#define SHARK_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) }, 5.471 +#define SHARK_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_DIAGNOSTIC) }, 5.472 +#define SHARK_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_DEVELOP) }, 5.473 +#define SHARK_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) }, 5.474 +#define SHARK_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_SHARK | Flag::KIND_NOT_PRODUCT) }, 5.475 5.476 static Flag flagTable[] = { 5.477 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) 5.478 @@ -285,9 +463,14 @@ 5.479 5.480 // Search the flag table for a named flag 5.481 Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) { 5.482 - for (Flag* current = &flagTable[0]; current->name != NULL; current++) { 5.483 - if (str_equal(current->name, name, length)) { 5.484 - // Found a matching entry. Report locked flags only if allowed. 5.485 + for (Flag* current = &flagTable[0]; current->_name != NULL; current++) { 5.486 + if (str_equal(current->_name, name, length)) { 5.487 + // Found a matching entry. 5.488 + // Don't report notproduct and develop flags in product builds. 5.489 + if (current->is_constant_in_binary()) { 5.490 + return NULL; 5.491 + } 5.492 + // Report locked flags only if allowed. 5.493 if (!(current->is_unlocked() || current->is_unlocker())) { 5.494 if (!allow_locked) { 5.495 // disable use of locked flags, e.g. diagnostic, experimental, 5.496 @@ -327,8 +510,8 @@ 5.497 float score; 5.498 float max_score = -1; 5.499 5.500 - for (Flag* current = &flagTable[0]; current->name != NULL; current++) { 5.501 - score = str_similar(current->name, name, length); 5.502 + for (Flag* current = &flagTable[0]; current->_name != NULL; current++) { 5.503 + score = str_similar(current->_name, name, length); 5.504 if (score > max_score) { 5.505 max_score = score; 5.506 match = current; 5.507 @@ -357,25 +540,25 @@ 5.508 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) { 5.509 assert((size_t)flag < Flag::numFlags, "bad command line flag index"); 5.510 Flag* f = &Flag::flags[flag]; 5.511 - return (f->origin == DEFAULT); 5.512 + return f->is_default(); 5.513 } 5.514 5.515 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) { 5.516 assert((size_t)flag < Flag::numFlags, "bad command line flag index"); 5.517 Flag* f = &Flag::flags[flag]; 5.518 - return (f->origin == ERGONOMIC); 5.519 + return f->is_ergonomic(); 5.520 } 5.521 5.522 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) { 5.523 assert((size_t)flag < Flag::numFlags, "bad command line flag index"); 5.524 Flag* f = &Flag::flags[flag]; 5.525 - return (f->origin == COMMAND_LINE); 5.526 + return f->is_command_line(); 5.527 } 5.528 5.529 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) { 5.530 Flag* result = Flag::find_flag((char*)name, strlen(name)); 5.531 if (result == NULL) return false; 5.532 - *value = (result->origin == COMMAND_LINE); 5.533 + *value = result->is_command_line(); 5.534 return true; 5.535 } 5.536 5.537 @@ -387,22 +570,22 @@ 5.538 return true; 5.539 } 5.540 5.541 -bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin) { 5.542 +bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) { 5.543 Flag* result = Flag::find_flag(name, len); 5.544 if (result == NULL) return false; 5.545 if (!result->is_bool()) return false; 5.546 bool old_value = result->get_bool(); 5.547 result->set_bool(*value); 5.548 *value = old_value; 5.549 - result->origin = origin; 5.550 + result->set_origin(origin); 5.551 return true; 5.552 } 5.553 5.554 -void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, FlagValueOrigin origin) { 5.555 +void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) { 5.556 Flag* faddr = address_of_flag(flag); 5.557 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type"); 5.558 faddr->set_bool(value); 5.559 - faddr->origin = origin; 5.560 + faddr->set_origin(origin); 5.561 } 5.562 5.563 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) { 5.564 @@ -413,22 +596,22 @@ 5.565 return true; 5.566 } 5.567 5.568 -bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin) { 5.569 +bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) { 5.570 Flag* result = Flag::find_flag(name, len); 5.571 if (result == NULL) return false; 5.572 if (!result->is_intx()) return false; 5.573 intx old_value = result->get_intx(); 5.574 result->set_intx(*value); 5.575 *value = old_value; 5.576 - result->origin = origin; 5.577 + result->set_origin(origin); 5.578 return true; 5.579 } 5.580 5.581 -void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, FlagValueOrigin origin) { 5.582 +void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) { 5.583 Flag* faddr = address_of_flag(flag); 5.584 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type"); 5.585 faddr->set_intx(value); 5.586 - faddr->origin = origin; 5.587 + faddr->set_origin(origin); 5.588 } 5.589 5.590 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) { 5.591 @@ -439,22 +622,22 @@ 5.592 return true; 5.593 } 5.594 5.595 -bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin) { 5.596 +bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin) { 5.597 Flag* result = Flag::find_flag(name, len); 5.598 if (result == NULL) return false; 5.599 if (!result->is_uintx()) return false; 5.600 uintx old_value = result->get_uintx(); 5.601 result->set_uintx(*value); 5.602 *value = old_value; 5.603 - result->origin = origin; 5.604 + result->set_origin(origin); 5.605 return true; 5.606 } 5.607 5.608 -void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, FlagValueOrigin origin) { 5.609 +void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) { 5.610 Flag* faddr = address_of_flag(flag); 5.611 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type"); 5.612 faddr->set_uintx(value); 5.613 - faddr->origin = origin; 5.614 + faddr->set_origin(origin); 5.615 } 5.616 5.617 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) { 5.618 @@ -465,22 +648,22 @@ 5.619 return true; 5.620 } 5.621 5.622 -bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin) { 5.623 +bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) { 5.624 Flag* result = Flag::find_flag(name, len); 5.625 if (result == NULL) return false; 5.626 if (!result->is_uint64_t()) return false; 5.627 uint64_t old_value = result->get_uint64_t(); 5.628 result->set_uint64_t(*value); 5.629 *value = old_value; 5.630 - result->origin = origin; 5.631 + result->set_origin(origin); 5.632 return true; 5.633 } 5.634 5.635 -void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, FlagValueOrigin origin) { 5.636 +void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) { 5.637 Flag* faddr = address_of_flag(flag); 5.638 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type"); 5.639 faddr->set_uint64_t(value); 5.640 - faddr->origin = origin; 5.641 + faddr->set_origin(origin); 5.642 } 5.643 5.644 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) { 5.645 @@ -491,22 +674,22 @@ 5.646 return true; 5.647 } 5.648 5.649 -bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin) { 5.650 +bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) { 5.651 Flag* result = Flag::find_flag(name, len); 5.652 if (result == NULL) return false; 5.653 if (!result->is_double()) return false; 5.654 double old_value = result->get_double(); 5.655 result->set_double(*value); 5.656 *value = old_value; 5.657 - result->origin = origin; 5.658 + result->set_origin(origin); 5.659 return true; 5.660 } 5.661 5.662 -void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, FlagValueOrigin origin) { 5.663 +void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) { 5.664 Flag* faddr = address_of_flag(flag); 5.665 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type"); 5.666 faddr->set_double(value); 5.667 - faddr->origin = origin; 5.668 + faddr->set_origin(origin); 5.669 } 5.670 5.671 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) { 5.672 @@ -519,7 +702,7 @@ 5.673 5.674 // Contract: Flag will make private copy of the incoming value. 5.675 // Outgoing value is always malloc-ed, and caller MUST call free. 5.676 -bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin) { 5.677 +bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) { 5.678 Flag* result = Flag::find_flag(name, len); 5.679 if (result == NULL) return false; 5.680 if (!result->is_ccstr()) return false; 5.681 @@ -530,35 +713,35 @@ 5.682 strcpy(new_value, *value); 5.683 } 5.684 result->set_ccstr(new_value); 5.685 - if (result->origin == DEFAULT && old_value != NULL) { 5.686 + if (result->is_default() && old_value != NULL) { 5.687 // Prior value is NOT heap allocated, but was a literal constant. 5.688 char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal); 5.689 strcpy(old_value_to_free, old_value); 5.690 old_value = old_value_to_free; 5.691 } 5.692 *value = old_value; 5.693 - result->origin = origin; 5.694 + result->set_origin(origin); 5.695 return true; 5.696 } 5.697 5.698 // Contract: Flag will make private copy of the incoming value. 5.699 -void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, FlagValueOrigin origin) { 5.700 +void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) { 5.701 Flag* faddr = address_of_flag(flag); 5.702 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); 5.703 ccstr old_value = faddr->get_ccstr(); 5.704 char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal); 5.705 strcpy(new_value, value); 5.706 faddr->set_ccstr(new_value); 5.707 - if (faddr->origin != DEFAULT && old_value != NULL) { 5.708 + if (!faddr->is_default() && old_value != NULL) { 5.709 // Prior value is heap allocated so free it. 5.710 FREE_C_HEAP_ARRAY(char, old_value, mtInternal); 5.711 } 5.712 - faddr->origin = origin; 5.713 + faddr->set_origin(origin); 5.714 } 5.715 5.716 extern "C" { 5.717 static int compare_flags(const void* void_a, const void* void_b) { 5.718 - return strcmp((*((Flag**) void_a))->name, (*((Flag**) void_b))->name); 5.719 + return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name); 5.720 } 5.721 } 5.722 5.723 @@ -567,20 +750,19 @@ 5.724 // note: this method is called before the thread structure is in place 5.725 // which means resource allocation cannot be used. 5.726 5.727 - // Compute size 5.728 - int length= 0; 5.729 - while (flagTable[length].name != NULL) length++; 5.730 + // The last entry is the null entry. 5.731 + const size_t length = Flag::numFlags - 1; 5.732 5.733 // Sort 5.734 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal); 5.735 - for (int index = 0; index < length; index++) { 5.736 - array[index] = &flagTable[index]; 5.737 + for (size_t i = 0; i < length; i++) { 5.738 + array[i] = &flagTable[i]; 5.739 } 5.740 qsort(array, length, sizeof(Flag*), compare_flags); 5.741 5.742 // Print 5.743 - for (int i = 0; i < length; i++) { 5.744 - if (array[i]->origin /* naked field! */) { 5.745 + for (size_t i = 0; i < length; i++) { 5.746 + if (array[i]->get_origin() /* naked field! */) { 5.747 array[i]->print_as_flag(out); 5.748 out->print(" "); 5.749 } 5.750 @@ -603,20 +785,19 @@ 5.751 // note: this method is called before the thread structure is in place 5.752 // which means resource allocation cannot be used. 5.753 5.754 - // Compute size 5.755 - int length= 0; 5.756 - while (flagTable[length].name != NULL) length++; 5.757 + // The last entry is the null entry. 5.758 + const size_t length = Flag::numFlags - 1; 5.759 5.760 // Sort 5.761 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal); 5.762 - for (int index = 0; index < length; index++) { 5.763 - array[index] = &flagTable[index]; 5.764 + for (size_t i = 0; i < length; i++) { 5.765 + array[i] = &flagTable[i]; 5.766 } 5.767 qsort(array, length, sizeof(Flag*), compare_flags); 5.768 5.769 // Print 5.770 out->print_cr("[Global flags]"); 5.771 - for (int i = 0; i < length; i++) { 5.772 + for (size_t i = 0; i < length; i++) { 5.773 if (array[i]->is_unlocked()) { 5.774 array[i]->print_on(out, withComments); 5.775 }
6.1 --- a/src/share/vm/runtime/globals.hpp Tue Sep 24 16:08:00 2013 -0700 6.2 +++ b/src/share/vm/runtime/globals.hpp Thu Sep 26 12:07:53 2013 -0700 6.3 @@ -194,29 +194,49 @@ 6.4 typedef const char* ccstr; 6.5 typedef const char* ccstrlist; // represents string arguments which accumulate 6.6 6.7 -enum FlagValueOrigin { 6.8 - DEFAULT = 0, 6.9 - COMMAND_LINE = 1, 6.10 - ENVIRON_VAR = 2, 6.11 - CONFIG_FILE = 3, 6.12 - MANAGEMENT = 4, 6.13 - ERGONOMIC = 5, 6.14 - ATTACH_ON_DEMAND = 6, 6.15 - INTERNAL = 99 6.16 -}; 6.17 +struct Flag { 6.18 + enum Flags { 6.19 + // value origin 6.20 + DEFAULT = 0, 6.21 + COMMAND_LINE = 1, 6.22 + ENVIRON_VAR = 2, 6.23 + CONFIG_FILE = 3, 6.24 + MANAGEMENT = 4, 6.25 + ERGONOMIC = 5, 6.26 + ATTACH_ON_DEMAND = 6, 6.27 + INTERNAL = 7, 6.28 6.29 -struct Flag { 6.30 - const char *type; 6.31 - const char *name; 6.32 - void* addr; 6.33 + LAST_VALUE_ORIGIN = INTERNAL, 6.34 + VALUE_ORIGIN_BITS = 4, 6.35 + VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS), 6.36 6.37 - NOT_PRODUCT(const char *doc;) 6.38 + // flag kind 6.39 + KIND_PRODUCT = 1 << 4, 6.40 + KIND_MANAGEABLE = 1 << 5, 6.41 + KIND_DIAGNOSTIC = 1 << 6, 6.42 + KIND_EXPERIMENTAL = 1 << 7, 6.43 + KIND_NOT_PRODUCT = 1 << 8, 6.44 + KIND_DEVELOP = 1 << 9, 6.45 + KIND_PLATFORM_DEPENDENT = 1 << 10, 6.46 + KIND_READ_WRITE = 1 << 11, 6.47 + KIND_C1 = 1 << 12, 6.48 + KIND_C2 = 1 << 13, 6.49 + KIND_ARCH = 1 << 14, 6.50 + KIND_SHARK = 1 << 15, 6.51 + KIND_LP64_PRODUCT = 1 << 16, 6.52 + KIND_COMMERCIAL = 1 << 17, 6.53 6.54 - const char *kind; 6.55 - FlagValueOrigin origin; 6.56 + KIND_MASK = ~VALUE_ORIGIN_MASK 6.57 + }; 6.58 + 6.59 + const char* _type; 6.60 + const char* _name; 6.61 + void* _addr; 6.62 + NOT_PRODUCT(const char* _doc;) 6.63 + Flags _flags; 6.64 6.65 // points to all Flags static array 6.66 - static Flag *flags; 6.67 + static Flag* flags; 6.68 6.69 // number of flags 6.70 static size_t numFlags; 6.71 @@ -224,30 +244,50 @@ 6.72 static Flag* find_flag(const char* name, size_t length, bool allow_locked = false); 6.73 static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false); 6.74 6.75 - bool is_bool() const { return strcmp(type, "bool") == 0; } 6.76 - bool get_bool() const { return *((bool*) addr); } 6.77 - void set_bool(bool value) { *((bool*) addr) = value; } 6.78 + void check_writable(); 6.79 6.80 - bool is_intx() const { return strcmp(type, "intx") == 0; } 6.81 - intx get_intx() const { return *((intx*) addr); } 6.82 - void set_intx(intx value) { *((intx*) addr) = value; } 6.83 + bool is_bool() const; 6.84 + bool get_bool() const; 6.85 + void set_bool(bool value); 6.86 6.87 - bool is_uintx() const { return strcmp(type, "uintx") == 0; } 6.88 - uintx get_uintx() const { return *((uintx*) addr); } 6.89 - void set_uintx(uintx value) { *((uintx*) addr) = value; } 6.90 + bool is_intx() const; 6.91 + intx get_intx() const; 6.92 + void set_intx(intx value); 6.93 6.94 - bool is_uint64_t() const { return strcmp(type, "uint64_t") == 0; } 6.95 - uint64_t get_uint64_t() const { return *((uint64_t*) addr); } 6.96 - void set_uint64_t(uint64_t value) { *((uint64_t*) addr) = value; } 6.97 + bool is_uintx() const; 6.98 + uintx get_uintx() const; 6.99 + void set_uintx(uintx value); 6.100 6.101 - bool is_double() const { return strcmp(type, "double") == 0; } 6.102 - double get_double() const { return *((double*) addr); } 6.103 - void set_double(double value) { *((double*) addr) = value; } 6.104 + bool is_uint64_t() const; 6.105 + uint64_t get_uint64_t() const; 6.106 + void set_uint64_t(uint64_t value); 6.107 6.108 - bool is_ccstr() const { return strcmp(type, "ccstr") == 0 || strcmp(type, "ccstrlist") == 0; } 6.109 - bool ccstr_accumulates() const { return strcmp(type, "ccstrlist") == 0; } 6.110 - ccstr get_ccstr() const { return *((ccstr*) addr); } 6.111 - void set_ccstr(ccstr value) { *((ccstr*) addr) = value; } 6.112 + bool is_double() const; 6.113 + double get_double() const; 6.114 + void set_double(double value); 6.115 + 6.116 + bool is_ccstr() const; 6.117 + bool ccstr_accumulates() const; 6.118 + ccstr get_ccstr() const; 6.119 + void set_ccstr(ccstr value); 6.120 + 6.121 + Flags get_origin(); 6.122 + void set_origin(Flags origin); 6.123 + 6.124 + bool is_default(); 6.125 + bool is_ergonomic(); 6.126 + bool is_command_line(); 6.127 + 6.128 + bool is_product() const; 6.129 + bool is_manageable() const; 6.130 + bool is_diagnostic() const; 6.131 + bool is_experimental() const; 6.132 + bool is_notproduct() const; 6.133 + bool is_develop() const; 6.134 + bool is_read_write() const; 6.135 + bool is_commercial() const; 6.136 + 6.137 + bool is_constant_in_binary() const; 6.138 6.139 bool is_unlocker() const; 6.140 bool is_unlocked() const; 6.141 @@ -263,6 +303,7 @@ 6.142 void get_locked_message_ext(char*, int) const; 6.143 6.144 void print_on(outputStream* st, bool withComments = false ); 6.145 + void print_kind(outputStream* st); 6.146 void print_as_flag(outputStream* st); 6.147 }; 6.148 6.149 @@ -310,33 +351,33 @@ 6.150 public: 6.151 static bool boolAt(char* name, size_t len, bool* value); 6.152 static bool boolAt(char* name, bool* value) { return boolAt(name, strlen(name), value); } 6.153 - static bool boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin); 6.154 - static bool boolAtPut(char* name, bool* value, FlagValueOrigin origin) { return boolAtPut(name, strlen(name), value, origin); } 6.155 + static bool boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin); 6.156 + static bool boolAtPut(char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); } 6.157 6.158 static bool intxAt(char* name, size_t len, intx* value); 6.159 static bool intxAt(char* name, intx* value) { return intxAt(name, strlen(name), value); } 6.160 - static bool intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin); 6.161 - static bool intxAtPut(char* name, intx* value, FlagValueOrigin origin) { return intxAtPut(name, strlen(name), value, origin); } 6.162 + static bool intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin); 6.163 + static bool intxAtPut(char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); } 6.164 6.165 static bool uintxAt(char* name, size_t len, uintx* value); 6.166 static bool uintxAt(char* name, uintx* value) { return uintxAt(name, strlen(name), value); } 6.167 - static bool uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin); 6.168 - static bool uintxAtPut(char* name, uintx* value, FlagValueOrigin origin) { return uintxAtPut(name, strlen(name), value, origin); } 6.169 + static bool uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin); 6.170 + static bool uintxAtPut(char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); } 6.171 6.172 static bool uint64_tAt(char* name, size_t len, uint64_t* value); 6.173 static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); } 6.174 - static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin); 6.175 - static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin origin) { return uint64_tAtPut(name, strlen(name), value, origin); } 6.176 + static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin); 6.177 + static bool uint64_tAtPut(char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); } 6.178 6.179 static bool doubleAt(char* name, size_t len, double* value); 6.180 static bool doubleAt(char* name, double* value) { return doubleAt(name, strlen(name), value); } 6.181 - static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin); 6.182 - static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); } 6.183 + static bool doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin); 6.184 + static bool doubleAtPut(char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); } 6.185 6.186 static bool ccstrAt(char* name, size_t len, ccstr* value); 6.187 static bool ccstrAt(char* name, ccstr* value) { return ccstrAt(name, strlen(name), value); } 6.188 - static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin); 6.189 - static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); } 6.190 + static bool ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin); 6.191 + static bool ccstrAtPut(char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); } 6.192 6.193 // Returns false if name is not a command line flag. 6.194 static bool wasSetOnCmdline(const char* name, bool* value); 6.195 @@ -3727,20 +3768,20 @@ 6.196 */ 6.197 6.198 // Interface macros 6.199 -#define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name; 6.200 -#define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name; 6.201 -#define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name; 6.202 +#define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name; 6.203 +#define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name; 6.204 +#define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name; 6.205 #define DECLARE_EXPERIMENTAL_FLAG(type, name, value, doc) extern "C" type name; 6.206 -#define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name; 6.207 -#define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name; 6.208 +#define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name; 6.209 +#define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name; 6.210 #ifdef PRODUCT 6.211 -#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) const type name = value; 6.212 -#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) const type name = pd_##name; 6.213 -#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) 6.214 +#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type CONST_##name; const type name = value; 6.215 +#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type CONST_##name; const type name = pd_##name; 6.216 +#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type CONST_##name; 6.217 #else 6.218 -#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name; 6.219 -#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name; 6.220 -#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name; 6.221 +#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name; 6.222 +#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name; 6.223 +#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name; 6.224 #endif 6.225 // Special LP64 flags, product only needed for now. 6.226 #ifdef _LP64 6.227 @@ -3750,23 +3791,23 @@ 6.228 #endif // _LP64 6.229 6.230 // Implementation macros 6.231 -#define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value; 6.232 -#define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name; 6.233 -#define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value; 6.234 +#define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value; 6.235 +#define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name; 6.236 +#define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value; 6.237 #define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value; 6.238 -#define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value; 6.239 -#define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value; 6.240 +#define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value; 6.241 +#define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value; 6.242 #ifdef PRODUCT 6.243 -#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) /* flag name is constant */ 6.244 -#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) /* flag name is constant */ 6.245 -#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) 6.246 +#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type CONST_##name = value; 6.247 +#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type CONST_##name = pd_##name; 6.248 +#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type CONST_##name = value; 6.249 #else 6.250 -#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value; 6.251 -#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name; 6.252 -#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value; 6.253 +#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value; 6.254 +#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name; 6.255 +#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value; 6.256 #endif 6.257 #ifdef _LP64 6.258 -#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value; 6.259 +#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value; 6.260 #else 6.261 #define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */ 6.262 #endif // _LP64
7.1 --- a/src/share/vm/runtime/globals_extension.hpp Tue Sep 24 16:08:00 2013 -0700 7.2 +++ b/src/share/vm/runtime/globals_extension.hpp Thu Sep 26 12:07:53 2013 -0700 7.3 @@ -34,64 +34,42 @@ 7.4 // Parens left off in the following for the enum decl below. 7.5 #define FLAG_MEMBER(flag) Flag_##flag 7.6 7.7 -#define RUNTIME_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.8 -#define RUNTIME_PD_PRODUCT_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.9 -#define RUNTIME_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.10 +#define RUNTIME_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.11 +#define RUNTIME_PD_PRODUCT_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.12 +#define RUNTIME_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.13 #define RUNTIME_EXPERIMENTAL_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.14 -#define RUNTIME_MANAGEABLE_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.15 -#define RUNTIME_PRODUCT_RW_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.16 -#ifdef PRODUCT 7.17 - #define RUNTIME_DEVELOP_FLAG_MEMBER(type, name, value, doc) /* flag is constant */ 7.18 - #define RUNTIME_PD_DEVELOP_FLAG_MEMBER(type, name, doc) /* flag is constant */ 7.19 - #define RUNTIME_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) 7.20 +#define RUNTIME_MANAGEABLE_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.21 +#define RUNTIME_PRODUCT_RW_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.22 +#define RUNTIME_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.23 +#define RUNTIME_PD_DEVELOP_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.24 +#define RUNTIME_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.25 + 7.26 +#ifdef _LP64 7.27 +#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.28 #else 7.29 - #define RUNTIME_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.30 - #define RUNTIME_PD_DEVELOP_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.31 - #define RUNTIME_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.32 -#endif 7.33 -#ifdef _LP64 7.34 -#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.35 -#else 7.36 -#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER(type, name, value, doc) /* flag is constant */ 7.37 +#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER(type, name, value, doc) /* flag is constant */ 7.38 #endif // _LP64 7.39 7.40 -#define C1_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.41 -#define C1_PD_PRODUCT_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.42 -#define C1_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.43 -#ifdef PRODUCT 7.44 - #define C1_DEVELOP_FLAG_MEMBER(type, name, value, doc) /* flag is constant */ 7.45 - #define C1_PD_DEVELOP_FLAG_MEMBER(type, name, doc) /* flag is constant */ 7.46 - #define C1_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) 7.47 -#else 7.48 - #define C1_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.49 - #define C1_PD_DEVELOP_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.50 - #define C1_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.51 -#endif 7.52 +#define C1_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.53 +#define C1_PD_PRODUCT_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.54 +#define C1_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.55 +#define C1_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.56 +#define C1_PD_DEVELOP_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.57 +#define C1_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.58 7.59 -#define C2_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.60 -#define C2_PD_PRODUCT_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.61 -#define C2_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.62 -#define C2_EXPERIMENTAL_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.63 -#ifdef PRODUCT 7.64 - #define C2_DEVELOP_FLAG_MEMBER(type, name, value, doc) /* flag is constant */ 7.65 - #define C2_PD_DEVELOP_FLAG_MEMBER(type, name, doc) /* flag is constant */ 7.66 - #define C2_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) 7.67 -#else 7.68 - #define C2_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.69 - #define C2_PD_DEVELOP_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.70 - #define C2_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.71 -#endif 7.72 +#define C2_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.73 +#define C2_PD_PRODUCT_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.74 +#define C2_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.75 +#define C2_EXPERIMENTAL_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.76 +#define C2_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.77 +#define C2_PD_DEVELOP_FLAG_MEMBER(type, name, doc) FLAG_MEMBER(name), 7.78 +#define C2_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.79 7.80 #define ARCH_PRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.81 #define ARCH_DIAGNOSTIC_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.82 #define ARCH_EXPERIMENTAL_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.83 -#ifdef PRODUCT 7.84 - #define ARCH_DEVELOP_FLAG_MEMBER(type, name, value, doc) /* flag is constant */ 7.85 - #define ARCH_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) 7.86 -#else 7.87 - #define ARCH_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.88 - #define ARCH_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.89 -#endif 7.90 +#define ARCH_DEVELOP_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.91 +#define ARCH_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name), 7.92 7.93 typedef enum { 7.94 RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, RUNTIME_PD_DEVELOP_FLAG_MEMBER, RUNTIME_PRODUCT_FLAG_MEMBER, RUNTIME_PD_PRODUCT_FLAG_MEMBER, RUNTIME_DIAGNOSTIC_FLAG_MEMBER, RUNTIME_EXPERIMENTAL_FLAG_MEMBER, RUNTIME_NOTPRODUCT_FLAG_MEMBER, RUNTIME_MANAGEABLE_FLAG_MEMBER, RUNTIME_PRODUCT_RW_FLAG_MEMBER, RUNTIME_LP64_PRODUCT_FLAG_MEMBER) 7.95 @@ -114,64 +92,42 @@ 7.96 7.97 #define FLAG_MEMBER_WITH_TYPE(flag,type) Flag_##flag##_##type 7.98 7.99 -#define RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.100 -#define RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.101 -#define RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.102 +#define RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.103 +#define RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.104 +#define RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.105 #define RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.106 -#define RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.107 -#define RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.108 -#ifdef PRODUCT 7.109 - #define RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) /* flag is constant */ 7.110 - #define RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) /* flag is constant */ 7.111 - #define RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) 7.112 +#define RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.113 +#define RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.114 +#define RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.115 +#define RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.116 +#define RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.117 + 7.118 +#define C1_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.119 +#define C1_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.120 +#define C1_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.121 +#define C1_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.122 +#define C1_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.123 +#define C1_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.124 + 7.125 +#ifdef _LP64 7.126 +#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.127 #else 7.128 - #define RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.129 - #define RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.130 - #define RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.131 -#endif 7.132 - 7.133 -#define C1_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.134 -#define C1_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.135 -#define C1_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.136 -#ifdef PRODUCT 7.137 - #define C1_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) /* flag is constant */ 7.138 - #define C1_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) /* flag is constant */ 7.139 - #define C1_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) 7.140 -#else 7.141 - #define C1_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.142 - #define C1_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.143 - #define C1_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.144 -#endif 7.145 -#ifdef _LP64 7.146 -#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.147 -#else 7.148 -#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) /* flag is constant */ 7.149 +#define RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) /* flag is constant */ 7.150 #endif // _LP64 7.151 7.152 -#define C2_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.153 -#define C2_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.154 -#define C2_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.155 +#define C2_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.156 +#define C2_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.157 +#define C2_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.158 #define C2_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.159 -#ifdef PRODUCT 7.160 - #define C2_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) /* flag is constant */ 7.161 - #define C2_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) /* flag is constant */ 7.162 - #define C2_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) 7.163 -#else 7.164 - #define C2_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.165 - #define C2_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.166 - #define C2_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.167 -#endif 7.168 +#define C2_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.169 +#define C2_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.170 +#define C2_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.171 7.172 #define ARCH_PRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.173 #define ARCH_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.174 -#define ARCH_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.175 -#ifdef PRODUCT 7.176 - #define ARCH_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) /* flag is constant */ 7.177 - #define ARCH_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) 7.178 -#else 7.179 - #define ARCH_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.180 - #define ARCH_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.181 -#endif 7.182 +#define ARCH_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.183 +#define ARCH_DEVELOP_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.184 +#define ARCH_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type), 7.185 7.186 typedef enum { 7.187 RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE, 7.188 @@ -233,19 +189,19 @@ 7.189 7.190 #define FLAG_SET_DEFAULT(name, value) ((name) = (value)) 7.191 7.192 -#define FLAG_SET_CMDLINE(type, name, value) (CommandLineFlagsEx::type##AtPut(FLAG_MEMBER_WITH_TYPE(name,type), (type)(value), COMMAND_LINE)) 7.193 -#define FLAG_SET_ERGO(type, name, value) (CommandLineFlagsEx::type##AtPut(FLAG_MEMBER_WITH_TYPE(name,type), (type)(value), ERGONOMIC)) 7.194 +#define FLAG_SET_CMDLINE(type, name, value) (CommandLineFlagsEx::type##AtPut(FLAG_MEMBER_WITH_TYPE(name,type), (type)(value), Flag::COMMAND_LINE)) 7.195 +#define FLAG_SET_ERGO(type, name, value) (CommandLineFlagsEx::type##AtPut(FLAG_MEMBER_WITH_TYPE(name,type), (type)(value), Flag::ERGONOMIC)) 7.196 7.197 // Can't put the following in CommandLineFlags because 7.198 // of a circular dependency on the enum definition. 7.199 class CommandLineFlagsEx : CommandLineFlags { 7.200 public: 7.201 - static void boolAtPut(CommandLineFlagWithType flag, bool value, FlagValueOrigin origin); 7.202 - static void intxAtPut(CommandLineFlagWithType flag, intx value, FlagValueOrigin origin); 7.203 - static void uintxAtPut(CommandLineFlagWithType flag, uintx value, FlagValueOrigin origin); 7.204 - static void uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, FlagValueOrigin origin); 7.205 - static void doubleAtPut(CommandLineFlagWithType flag, double value, FlagValueOrigin origin); 7.206 - static void ccstrAtPut(CommandLineFlagWithType flag, ccstr value, FlagValueOrigin origin); 7.207 + static void boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin); 7.208 + static void intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin); 7.209 + static void uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin); 7.210 + static void uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin); 7.211 + static void doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin); 7.212 + static void ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin); 7.213 7.214 static bool is_default(CommandLineFlag flag); 7.215 static bool is_ergo(CommandLineFlag flag);
8.1 --- a/src/share/vm/runtime/vmStructs.cpp Tue Sep 24 16:08:00 2013 -0700 8.2 +++ b/src/share/vm/runtime/vmStructs.cpp Thu Sep 26 12:07:53 2013 -0700 8.3 @@ -1185,11 +1185,10 @@ 8.4 /* -XX flags */ \ 8.5 /*********************/ \ 8.6 \ 8.7 - nonstatic_field(Flag, type, const char*) \ 8.8 - nonstatic_field(Flag, name, const char*) \ 8.9 - unchecked_nonstatic_field(Flag, addr, sizeof(void*)) /* NOTE: no type */ \ 8.10 - nonstatic_field(Flag, kind, const char*) \ 8.11 - nonstatic_field(Flag, origin, FlagValueOrigin) \ 8.12 + nonstatic_field(Flag, _type, const char*) \ 8.13 + nonstatic_field(Flag, _name, const char*) \ 8.14 + unchecked_nonstatic_field(Flag, _addr, sizeof(void*)) /* NOTE: no type */ \ 8.15 + nonstatic_field(Flag, _flags, Flag::Flags) \ 8.16 static_field(Flag, flags, Flag*) \ 8.17 static_field(Flag, numFlags, size_t) \ 8.18 \ 8.19 @@ -2074,7 +2073,7 @@ 8.20 declare_integer_type(JavaThreadState) \ 8.21 declare_integer_type(Location::Type) \ 8.22 declare_integer_type(Location::Where) \ 8.23 - declare_integer_type(FlagValueOrigin) \ 8.24 + declare_integer_type(Flag::Flags) \ 8.25 COMPILER2_PRESENT(declare_integer_type(OptoReg::Name)) \ 8.26 \ 8.27 declare_toplevel_type(CHeapObj<mtInternal>) \ 8.28 @@ -2082,7 +2081,7 @@ 8.29 declare_type(Array<u1>, MetaspaceObj) \ 8.30 declare_type(Array<u2>, MetaspaceObj) \ 8.31 declare_type(Array<Klass*>, MetaspaceObj) \ 8.32 - declare_type(Array<Method*>, MetaspaceObj) \ 8.33 + declare_type(Array<Method*>, MetaspaceObj) \ 8.34 \ 8.35 declare_integer_type(AccessFlags) /* FIXME: wrong type (not integer) */\ 8.36 declare_toplevel_type(address) /* FIXME: should this be an integer type? */\
9.1 --- a/src/share/vm/services/attachListener.cpp Tue Sep 24 16:08:00 2013 -0700 9.2 +++ b/src/share/vm/services/attachListener.cpp Thu Sep 26 12:07:53 2013 -0700 9.3 @@ -245,7 +245,7 @@ 9.4 } 9.5 value = (tmp != 0); 9.6 } 9.7 - bool res = CommandLineFlags::boolAtPut((char*)name, &value, ATTACH_ON_DEMAND); 9.8 + bool res = CommandLineFlags::boolAtPut((char*)name, &value, Flag::ATTACH_ON_DEMAND); 9.9 if (! res) { 9.10 out->print_cr("setting flag %s failed", name); 9.11 } 9.12 @@ -263,7 +263,7 @@ 9.13 return JNI_ERR; 9.14 } 9.15 } 9.16 - bool res = CommandLineFlags::intxAtPut((char*)name, &value, ATTACH_ON_DEMAND); 9.17 + bool res = CommandLineFlags::intxAtPut((char*)name, &value, Flag::ATTACH_ON_DEMAND); 9.18 if (! res) { 9.19 out->print_cr("setting flag %s failed", name); 9.20 } 9.21 @@ -282,7 +282,7 @@ 9.22 return JNI_ERR; 9.23 } 9.24 } 9.25 - bool res = CommandLineFlags::uintxAtPut((char*)name, &value, ATTACH_ON_DEMAND); 9.26 + bool res = CommandLineFlags::uintxAtPut((char*)name, &value, Flag::ATTACH_ON_DEMAND); 9.27 if (! res) { 9.28 out->print_cr("setting flag %s failed", name); 9.29 } 9.30 @@ -301,7 +301,7 @@ 9.31 return JNI_ERR; 9.32 } 9.33 } 9.34 - bool res = CommandLineFlags::uint64_tAtPut((char*)name, &value, ATTACH_ON_DEMAND); 9.35 + bool res = CommandLineFlags::uint64_tAtPut((char*)name, &value, Flag::ATTACH_ON_DEMAND); 9.36 if (! res) { 9.37 out->print_cr("setting flag %s failed", name); 9.38 } 9.39 @@ -316,7 +316,7 @@ 9.40 out->print_cr("flag value must be a string"); 9.41 return JNI_ERR; 9.42 } 9.43 - bool res = CommandLineFlags::ccstrAtPut((char*)name, &value, ATTACH_ON_DEMAND); 9.44 + bool res = CommandLineFlags::ccstrAtPut((char*)name, &value, Flag::ATTACH_ON_DEMAND); 9.45 if (res) { 9.46 FREE_C_HEAP_ARRAY(char, value, mtInternal); 9.47 } else {
10.1 --- a/src/share/vm/services/classLoadingService.cpp Tue Sep 24 16:08:00 2013 -0700 10.2 +++ b/src/share/vm/services/classLoadingService.cpp Thu Sep 26 12:07:53 2013 -0700 10.3 @@ -202,7 +202,7 @@ 10.4 MutexLocker m(Management_lock); 10.5 10.6 // verbose will be set to the previous value 10.7 - bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassLoading", &verbose, MANAGEMENT); 10.8 + bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassLoading", &verbose, Flag::MANAGEMENT); 10.9 assert(succeed, "Setting TraceClassLoading flag fails"); 10.10 reset_trace_class_unloading(); 10.11 10.12 @@ -213,7 +213,7 @@ 10.13 void ClassLoadingService::reset_trace_class_unloading() { 10.14 assert(Management_lock->owned_by_self(), "Must own the Management_lock"); 10.15 bool value = MemoryService::get_verbose() || ClassLoadingService::get_verbose(); 10.16 - bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassUnloading", &value, MANAGEMENT); 10.17 + bool succeed = CommandLineFlags::boolAtPut((char*)"TraceClassUnloading", &value, Flag::MANAGEMENT); 10.18 assert(succeed, "Setting TraceClassUnLoading flag fails"); 10.19 } 10.20
11.1 --- a/src/share/vm/services/dtraceAttacher.cpp Tue Sep 24 16:08:00 2013 -0700 11.2 +++ b/src/share/vm/services/dtraceAttacher.cpp Thu Sep 26 12:07:53 2013 -0700 11.3 @@ -51,7 +51,7 @@ 11.4 11.5 static void set_bool_flag(const char* flag, bool value) { 11.6 CommandLineFlags::boolAtPut((char*)flag, strlen(flag), &value, 11.7 - ATTACH_ON_DEMAND); 11.8 + Flag::ATTACH_ON_DEMAND); 11.9 } 11.10 11.11 // Enable only the "fine grained" flags. Do *not* touch
12.1 --- a/src/share/vm/services/management.cpp Tue Sep 24 16:08:00 2013 -0700 12.2 +++ b/src/share/vm/services/management.cpp Thu Sep 26 12:07:53 2013 -0700 12.3 @@ -1643,9 +1643,13 @@ 12.4 int num_entries = 0; 12.5 for (int i = 0; i < nFlags; i++) { 12.6 Flag* flag = &Flag::flags[i]; 12.7 + // Exclude notproduct and develop flags in product builds. 12.8 + if (flag->is_constant_in_binary()) { 12.9 + continue; 12.10 + } 12.11 // Exclude the locked (experimental, diagnostic) flags 12.12 if (flag->is_unlocked() || flag->is_unlocker()) { 12.13 - Handle s = java_lang_String::create_from_str(flag->name, CHECK_0); 12.14 + Handle s = java_lang_String::create_from_str(flag->_name, CHECK_0); 12.15 flags_ah->obj_at_put(num_entries, s()); 12.16 num_entries++; 12.17 } 12.18 @@ -1669,7 +1673,7 @@ 12.19 bool add_global_entry(JNIEnv* env, Handle name, jmmVMGlobal *global, Flag *flag, TRAPS) { 12.20 Handle flag_name; 12.21 if (name() == NULL) { 12.22 - flag_name = java_lang_String::create_from_str(flag->name, CHECK_false); 12.23 + flag_name = java_lang_String::create_from_str(flag->_name, CHECK_false); 12.24 } else { 12.25 flag_name = name; 12.26 } 12.27 @@ -1698,23 +1702,23 @@ 12.28 12.29 global->writeable = flag->is_writeable(); 12.30 global->external = flag->is_external(); 12.31 - switch (flag->origin) { 12.32 - case DEFAULT: 12.33 + switch (flag->get_origin()) { 12.34 + case Flag::DEFAULT: 12.35 global->origin = JMM_VMGLOBAL_ORIGIN_DEFAULT; 12.36 break; 12.37 - case COMMAND_LINE: 12.38 + case Flag::COMMAND_LINE: 12.39 global->origin = JMM_VMGLOBAL_ORIGIN_COMMAND_LINE; 12.40 break; 12.41 - case ENVIRON_VAR: 12.42 + case Flag::ENVIRON_VAR: 12.43 global->origin = JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR; 12.44 break; 12.45 - case CONFIG_FILE: 12.46 + case Flag::CONFIG_FILE: 12.47 global->origin = JMM_VMGLOBAL_ORIGIN_CONFIG_FILE; 12.48 break; 12.49 - case MANAGEMENT: 12.50 + case Flag::MANAGEMENT: 12.51 global->origin = JMM_VMGLOBAL_ORIGIN_MANAGEMENT; 12.52 break; 12.53 - case ERGONOMIC: 12.54 + case Flag::ERGONOMIC: 12.55 global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC; 12.56 break; 12.57 default: 12.58 @@ -1781,6 +1785,10 @@ 12.59 int num_entries = 0; 12.60 for (int i = 0; i < nFlags && num_entries < count; i++) { 12.61 Flag* flag = &Flag::flags[i]; 12.62 + // Exclude notproduct and develop flags in product builds. 12.63 + if (flag->is_constant_in_binary()) { 12.64 + continue; 12.65 + } 12.66 // Exclude the locked (diagnostic, experimental) flags 12.67 if ((flag->is_unlocked() || flag->is_unlocker()) && 12.68 add_global_entry(env, null_h, &globals[num_entries], flag, THREAD)) { 12.69 @@ -1813,23 +1821,23 @@ 12.70 bool succeed; 12.71 if (flag->is_bool()) { 12.72 bool bvalue = (new_value.z == JNI_TRUE ? true : false); 12.73 - succeed = CommandLineFlags::boolAtPut(name, &bvalue, MANAGEMENT); 12.74 + succeed = CommandLineFlags::boolAtPut(name, &bvalue, Flag::MANAGEMENT); 12.75 } else if (flag->is_intx()) { 12.76 intx ivalue = (intx)new_value.j; 12.77 - succeed = CommandLineFlags::intxAtPut(name, &ivalue, MANAGEMENT); 12.78 + succeed = CommandLineFlags::intxAtPut(name, &ivalue, Flag::MANAGEMENT); 12.79 } else if (flag->is_uintx()) { 12.80 uintx uvalue = (uintx)new_value.j; 12.81 - succeed = CommandLineFlags::uintxAtPut(name, &uvalue, MANAGEMENT); 12.82 + succeed = CommandLineFlags::uintxAtPut(name, &uvalue, Flag::MANAGEMENT); 12.83 } else if (flag->is_uint64_t()) { 12.84 uint64_t uvalue = (uint64_t)new_value.j; 12.85 - succeed = CommandLineFlags::uint64_tAtPut(name, &uvalue, MANAGEMENT); 12.86 + succeed = CommandLineFlags::uint64_tAtPut(name, &uvalue, Flag::MANAGEMENT); 12.87 } else if (flag->is_ccstr()) { 12.88 oop str = JNIHandles::resolve_external_guard(new_value.l); 12.89 if (str == NULL) { 12.90 THROW(vmSymbols::java_lang_NullPointerException()); 12.91 } 12.92 ccstr svalue = java_lang_String::as_utf8_string(str); 12.93 - succeed = CommandLineFlags::ccstrAtPut(name, &svalue, MANAGEMENT); 12.94 + succeed = CommandLineFlags::ccstrAtPut(name, &svalue, Flag::MANAGEMENT); 12.95 } 12.96 assert(succeed, "Setting flag should succeed"); 12.97 JVM_END
13.1 --- a/src/share/vm/services/memoryService.cpp Tue Sep 24 16:08:00 2013 -0700 13.2 +++ b/src/share/vm/services/memoryService.cpp Thu Sep 26 12:07:53 2013 -0700 13.3 @@ -515,7 +515,7 @@ 13.4 bool MemoryService::set_verbose(bool verbose) { 13.5 MutexLocker m(Management_lock); 13.6 // verbose will be set to the previous value 13.7 - bool succeed = CommandLineFlags::boolAtPut((char*)"PrintGC", &verbose, MANAGEMENT); 13.8 + bool succeed = CommandLineFlags::boolAtPut((char*)"PrintGC", &verbose, Flag::MANAGEMENT); 13.9 assert(succeed, "Setting PrintGC flag fails"); 13.10 ClassLoadingService::reset_trace_class_unloading(); 13.11 13.12 @@ -618,4 +618,3 @@ 13.13 MemoryService::gc_end(_fullGC, _recordPostGCUsage, _recordAccumulatedGCTime, 13.14 _recordGCEndTime, _countCollection, _cause); 13.15 } 13.16 -
