1.1 --- a/src/share/vm/runtime/globals.cpp Wed Oct 16 10:52:41 2013 +0200
1.2 +++ b/src/share/vm/runtime/globals.cpp Tue Nov 05 17:38:04 2013 -0800
1.3 @@ -62,26 +62,174 @@
1.4 MATERIALIZE_FLAGS_EXT
1.5
1.6
1.7 +void Flag::check_writable() {
1.8 + if (is_constant_in_binary()) {
1.9 + fatal(err_msg("flag is constant: %s", _name));
1.10 + }
1.11 +}
1.12 +
1.13 +bool Flag::is_bool() const {
1.14 + return strcmp(_type, "bool") == 0;
1.15 +}
1.16 +
1.17 +bool Flag::get_bool() const {
1.18 + return *((bool*) _addr);
1.19 +}
1.20 +
1.21 +void Flag::set_bool(bool value) {
1.22 + check_writable();
1.23 + *((bool*) _addr) = value;
1.24 +}
1.25 +
1.26 +bool Flag::is_intx() const {
1.27 + return strcmp(_type, "intx") == 0;
1.28 +}
1.29 +
1.30 +intx Flag::get_intx() const {
1.31 + return *((intx*) _addr);
1.32 +}
1.33 +
1.34 +void Flag::set_intx(intx value) {
1.35 + check_writable();
1.36 + *((intx*) _addr) = value;
1.37 +}
1.38 +
1.39 +bool Flag::is_uintx() const {
1.40 + return strcmp(_type, "uintx") == 0;
1.41 +}
1.42 +
1.43 +uintx Flag::get_uintx() const {
1.44 + return *((uintx*) _addr);
1.45 +}
1.46 +
1.47 +void Flag::set_uintx(uintx value) {
1.48 + check_writable();
1.49 + *((uintx*) _addr) = value;
1.50 +}
1.51 +
1.52 +bool Flag::is_uint64_t() const {
1.53 + return strcmp(_type, "uint64_t") == 0;
1.54 +}
1.55 +
1.56 +uint64_t Flag::get_uint64_t() const {
1.57 + return *((uint64_t*) _addr);
1.58 +}
1.59 +
1.60 +void Flag::set_uint64_t(uint64_t value) {
1.61 + check_writable();
1.62 + *((uint64_t*) _addr) = value;
1.63 +}
1.64 +
1.65 +bool Flag::is_double() const {
1.66 + return strcmp(_type, "double") == 0;
1.67 +}
1.68 +
1.69 +double Flag::get_double() const {
1.70 + return *((double*) _addr);
1.71 +}
1.72 +
1.73 +void Flag::set_double(double value) {
1.74 + check_writable();
1.75 + *((double*) _addr) = value;
1.76 +}
1.77 +
1.78 +bool Flag::is_ccstr() const {
1.79 + return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0;
1.80 +}
1.81 +
1.82 +bool Flag::ccstr_accumulates() const {
1.83 + return strcmp(_type, "ccstrlist") == 0;
1.84 +}
1.85 +
1.86 +ccstr Flag::get_ccstr() const {
1.87 + return *((ccstr*) _addr);
1.88 +}
1.89 +
1.90 +void Flag::set_ccstr(ccstr value) {
1.91 + check_writable();
1.92 + *((ccstr*) _addr) = value;
1.93 +}
1.94 +
1.95 +
1.96 +Flag::Flags Flag::get_origin() {
1.97 + return Flags(_flags & VALUE_ORIGIN_MASK);
1.98 +}
1.99 +
1.100 +void Flag::set_origin(Flags origin) {
1.101 + assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity");
1.102 + _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | origin);
1.103 +}
1.104 +
1.105 +bool Flag::is_default() {
1.106 + return (get_origin() == DEFAULT);
1.107 +}
1.108 +
1.109 +bool Flag::is_ergonomic() {
1.110 + return (get_origin() == ERGONOMIC);
1.111 +}
1.112 +
1.113 +bool Flag::is_command_line() {
1.114 + return (get_origin() == COMMAND_LINE);
1.115 +}
1.116 +
1.117 +bool Flag::is_product() const {
1.118 + return (_flags & KIND_PRODUCT) != 0;
1.119 +}
1.120 +
1.121 +bool Flag::is_manageable() const {
1.122 + return (_flags & KIND_MANAGEABLE) != 0;
1.123 +}
1.124 +
1.125 +bool Flag::is_diagnostic() const {
1.126 + return (_flags & KIND_DIAGNOSTIC) != 0;
1.127 +}
1.128 +
1.129 +bool Flag::is_experimental() const {
1.130 + return (_flags & KIND_EXPERIMENTAL) != 0;
1.131 +}
1.132 +
1.133 +bool Flag::is_notproduct() const {
1.134 + return (_flags & KIND_NOT_PRODUCT) != 0;
1.135 +}
1.136 +
1.137 +bool Flag::is_develop() const {
1.138 + return (_flags & KIND_DEVELOP) != 0;
1.139 +}
1.140 +
1.141 +bool Flag::is_read_write() const {
1.142 + return (_flags & KIND_READ_WRITE) != 0;
1.143 +}
1.144 +
1.145 +bool Flag::is_commercial() const {
1.146 + return (_flags & KIND_COMMERCIAL) != 0;
1.147 +}
1.148 +
1.149 +/**
1.150 + * Returns if this flag is a constant in the binary. Right now this is
1.151 + * true for notproduct and develop flags in product builds.
1.152 + */
1.153 +bool Flag::is_constant_in_binary() const {
1.154 +#ifdef PRODUCT
1.155 + return is_notproduct() || is_develop();
1.156 +#else
1.157 + return false;
1.158 +#endif
1.159 +}
1.160 +
1.161 bool Flag::is_unlocker() const {
1.162 - return strcmp(name, "UnlockDiagnosticVMOptions") == 0 ||
1.163 - strcmp(name, "UnlockExperimentalVMOptions") == 0 ||
1.164 + return strcmp(_name, "UnlockDiagnosticVMOptions") == 0 ||
1.165 + strcmp(_name, "UnlockExperimentalVMOptions") == 0 ||
1.166 is_unlocker_ext();
1.167 }
1.168
1.169 bool Flag::is_unlocked() const {
1.170 - if (strcmp(kind, "{diagnostic}") == 0 ||
1.171 - strcmp(kind, "{C2 diagnostic}") == 0 ||
1.172 - strcmp(kind, "{ARCH diagnostic}") == 0 ||
1.173 - strcmp(kind, "{Shark diagnostic}") == 0) {
1.174 + if (is_diagnostic()) {
1.175 return UnlockDiagnosticVMOptions;
1.176 - } else if (strcmp(kind, "{experimental}") == 0 ||
1.177 - strcmp(kind, "{C2 experimental}") == 0 ||
1.178 - strcmp(kind, "{ARCH experimental}") == 0 ||
1.179 - strcmp(kind, "{Shark experimental}") == 0) {
1.180 + }
1.181 + if (is_experimental()) {
1.182 return UnlockExperimentalVMOptions;
1.183 - } else {
1.184 - return is_unlocked_ext();
1.185 }
1.186 + return is_unlocked_ext();
1.187 }
1.188
1.189 // Get custom message for this locked flag, or return NULL if
1.190 @@ -91,16 +239,14 @@
1.191 }
1.192
1.193 bool Flag::is_writeable() const {
1.194 - return strcmp(kind, "{manageable}") == 0 ||
1.195 - strcmp(kind, "{product rw}") == 0 ||
1.196 - is_writeable_ext();
1.197 + return is_manageable() || (is_product() && is_read_write()) || is_writeable_ext();
1.198 }
1.199
1.200 // All flags except "manageable" are assumed to be internal flags.
1.201 // Long term, we need to define a mechanism to specify which flags
1.202 // are external/stable and change this function accordingly.
1.203 bool Flag::is_external() const {
1.204 - return strcmp(kind, "{manageable}") == 0 || is_external_ext();
1.205 + return is_manageable() || is_external_ext();
1.206 }
1.207
1.208
1.209 @@ -108,53 +254,113 @@
1.210 #define FORMAT_BUFFER_LEN 16
1.211
1.212 void Flag::print_on(outputStream* st, bool withComments) {
1.213 - st->print("%9s %-40s %c= ", type, name, (origin != DEFAULT ? ':' : ' '));
1.214 - if (is_bool()) st->print("%-16s", get_bool() ? "true" : "false");
1.215 - if (is_intx()) st->print("%-16ld", get_intx());
1.216 - if (is_uintx()) st->print("%-16lu", get_uintx());
1.217 - if (is_uint64_t()) st->print("%-16lu", get_uint64_t());
1.218 - if (is_double()) st->print("%-16f", get_double());
1.219 + // Don't print notproduct and develop flags in a product build.
1.220 + if (is_constant_in_binary()) {
1.221 + return;
1.222 + }
1.223
1.224 + st->print("%9s %-40s %c= ", _type, _name, (!is_default() ? ':' : ' '));
1.225 +
1.226 + if (is_bool()) {
1.227 + st->print("%-16s", get_bool() ? "true" : "false");
1.228 + }
1.229 + if (is_intx()) {
1.230 + st->print("%-16ld", get_intx());
1.231 + }
1.232 + if (is_uintx()) {
1.233 + st->print("%-16lu", get_uintx());
1.234 + }
1.235 + if (is_uint64_t()) {
1.236 + st->print("%-16lu", get_uint64_t());
1.237 + }
1.238 + if (is_double()) {
1.239 + st->print("%-16f", get_double());
1.240 + }
1.241 if (is_ccstr()) {
1.242 - const char* cp = get_ccstr();
1.243 - if (cp != NULL) {
1.244 - const char* eol;
1.245 - while ((eol = strchr(cp, '\n')) != NULL) {
1.246 - char format_buffer[FORMAT_BUFFER_LEN];
1.247 - size_t llen = pointer_delta(eol, cp, sizeof(char));
1.248 - jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
1.249 - "%%." SIZE_FORMAT "s", llen);
1.250 - st->print(format_buffer, cp);
1.251 - st->cr();
1.252 - cp = eol+1;
1.253 - st->print("%5s %-35s += ", "", name);
1.254 - }
1.255 - st->print("%-16s", cp);
1.256 - }
1.257 - else st->print("%-16s", "");
1.258 + const char* cp = get_ccstr();
1.259 + if (cp != NULL) {
1.260 + const char* eol;
1.261 + while ((eol = strchr(cp, '\n')) != NULL) {
1.262 + char format_buffer[FORMAT_BUFFER_LEN];
1.263 + size_t llen = pointer_delta(eol, cp, sizeof(char));
1.264 + jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
1.265 + "%%." SIZE_FORMAT "s", llen);
1.266 + st->print(format_buffer, cp);
1.267 + st->cr();
1.268 + cp = eol+1;
1.269 + st->print("%5s %-35s += ", "", _name);
1.270 + }
1.271 + st->print("%-16s", cp);
1.272 + }
1.273 + else st->print("%-16s", "");
1.274 }
1.275 - st->print("%-20s", kind);
1.276 +
1.277 + st->print("%-20");
1.278 + print_kind(st);
1.279 +
1.280 if (withComments) {
1.281 #ifndef PRODUCT
1.282 - st->print("%s", doc );
1.283 + st->print("%s", _doc);
1.284 #endif
1.285 }
1.286 st->cr();
1.287 }
1.288
1.289 +void Flag::print_kind(outputStream* st) {
1.290 + struct Data {
1.291 + int flag;
1.292 + const char* name;
1.293 + };
1.294 +
1.295 + Data data[] = {
1.296 + { KIND_C1, "C1" },
1.297 + { KIND_C2, "C2" },
1.298 + { KIND_ARCH, "ARCH" },
1.299 + { KIND_SHARK, "SHARK" },
1.300 + { KIND_PLATFORM_DEPENDENT, "pd" },
1.301 + { KIND_PRODUCT, "product" },
1.302 + { KIND_MANAGEABLE, "manageable" },
1.303 + { KIND_DIAGNOSTIC, "diagnostic" },
1.304 + { KIND_NOT_PRODUCT, "notproduct" },
1.305 + { KIND_DEVELOP, "develop" },
1.306 + { KIND_LP64_PRODUCT, "lp64_product" },
1.307 + { KIND_READ_WRITE, "rw" },
1.308 + { -1, "" }
1.309 + };
1.310 +
1.311 + if ((_flags & KIND_MASK) != 0) {
1.312 + st->print("{");
1.313 + bool is_first = true;
1.314 +
1.315 + for (int i = 0; data[i].flag != -1; i++) {
1.316 + Data d = data[i];
1.317 + if ((_flags & d.flag) != 0) {
1.318 + if (is_first) {
1.319 + is_first = false;
1.320 + } else {
1.321 + st->print(" ");
1.322 + }
1.323 + st->print(d.name);
1.324 + }
1.325 + }
1.326 +
1.327 + st->print("}");
1.328 + }
1.329 +}
1.330 +
1.331 void Flag::print_as_flag(outputStream* st) {
1.332 if (is_bool()) {
1.333 - st->print("-XX:%s%s", get_bool() ? "+" : "-", name);
1.334 + st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
1.335 } else if (is_intx()) {
1.336 - st->print("-XX:%s=" INTX_FORMAT, name, get_intx());
1.337 + st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
1.338 } else if (is_uintx()) {
1.339 - st->print("-XX:%s=" UINTX_FORMAT, name, get_uintx());
1.340 + st->print("-XX:%s=" UINTX_FORMAT, _name, get_uintx());
1.341 } else if (is_uint64_t()) {
1.342 - st->print("-XX:%s=" UINT64_FORMAT, name, get_uint64_t());
1.343 + st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t());
1.344 } else if (is_double()) {
1.345 - st->print("-XX:%s=%f", name, get_double());
1.346 + st->print("-XX:%s=%f", _name, get_double());
1.347 } else if (is_ccstr()) {
1.348 - st->print("-XX:%s=", name);
1.349 + st->print("-XX:%s=", _name);
1.350 const char* cp = get_ccstr();
1.351 if (cp != NULL) {
1.352 // Need to turn embedded '\n's back into separate arguments
1.353 @@ -167,7 +373,7 @@
1.354 st->print("%c", *cp);
1.355 break;
1.356 case '\n':
1.357 - st->print(" -XX:%s=", name);
1.358 + st->print(" -XX:%s=", _name);
1.359 break;
1.360 }
1.361 }
1.362 @@ -180,78 +386,51 @@
1.363 // 4991491 do not "optimize out" the was_set false values: omitting them
1.364 // tickles a Microsoft compiler bug causing flagTable to be malformed
1.365
1.366 -#define RUNTIME_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product}", DEFAULT },
1.367 -#define RUNTIME_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{pd product}", DEFAULT },
1.368 -#define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{diagnostic}", DEFAULT },
1.369 -#define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{experimental}", DEFAULT },
1.370 -#define RUNTIME_MANAGEABLE_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{manageable}", DEFAULT },
1.371 -#define RUNTIME_PRODUCT_RW_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product rw}", DEFAULT },
1.372 +#define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)
1.373
1.374 -#ifdef PRODUCT
1.375 - #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.376 - #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
1.377 - #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
1.378 -#else
1.379 - #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "", DEFAULT },
1.380 - #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{pd}", DEFAULT },
1.381 - #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{notproduct}", DEFAULT },
1.382 -#endif
1.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) },
1.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) },
1.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) },
1.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) },
1.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) },
1.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) },
1.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) },
1.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) },
1.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) },
1.392
1.393 #ifdef _LP64
1.394 - #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{lp64_product}", DEFAULT },
1.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) },
1.396 #else
1.397 - #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.398 +#define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.399 #endif // _LP64
1.400
1.401 -#define C1_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 product}", DEFAULT },
1.402 -#define C1_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 pd product}", DEFAULT },
1.403 -#ifdef PRODUCT
1.404 - #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.405 - #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
1.406 - #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
1.407 -#else
1.408 - #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1}", DEFAULT },
1.409 - #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{C1 pd}", DEFAULT },
1.410 - #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1 notproduct}", DEFAULT },
1.411 -#endif
1.412 +#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) },
1.413 +#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) },
1.414 +#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) },
1.415 +#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) },
1.416 +#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) },
1.417 +#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) },
1.418
1.419 -#define C2_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 product}", DEFAULT },
1.420 -#define C2_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 pd product}", DEFAULT },
1.421 -#define C2_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 diagnostic}", DEFAULT },
1.422 -#define C2_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 experimental}", DEFAULT },
1.423 -#ifdef PRODUCT
1.424 - #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.425 - #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
1.426 - #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
1.427 -#else
1.428 - #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2}", DEFAULT },
1.429 - #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{C2 pd}", DEFAULT },
1.430 - #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2 notproduct}", DEFAULT },
1.431 -#endif
1.432 +#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) },
1.433 +#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) },
1.434 +#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) },
1.435 +#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) },
1.436 +#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) },
1.437 +#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) },
1.438 +#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) },
1.439
1.440 -#define ARCH_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH product}", DEFAULT },
1.441 -#define ARCH_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH diagnostic}", DEFAULT },
1.442 -#define ARCH_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH experimental}", DEFAULT },
1.443 -#ifdef PRODUCT
1.444 - #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.445 - #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
1.446 -#else
1.447 - #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH}", DEFAULT },
1.448 - #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH notproduct}", DEFAULT },
1.449 -#endif
1.450 +#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) },
1.451 +#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) },
1.452 +#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) },
1.453 +#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) },
1.454 +#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) },
1.455
1.456 -#define SHARK_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark product}", DEFAULT },
1.457 -#define SHARK_PD_PRODUCT_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark pd product}", DEFAULT },
1.458 -#define SHARK_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark diagnostic}", DEFAULT },
1.459 -#ifdef PRODUCT
1.460 - #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
1.461 - #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc) /* flag is constant */
1.462 - #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
1.463 -#else
1.464 - #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark}", DEFAULT },
1.465 - #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc) { #type, XSTR(name), &name, doc, "{Shark pd}", DEFAULT },
1.466 - #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark notproduct}", DEFAULT },
1.467 -#endif
1.468 +#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) },
1.469 +#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) },
1.470 +#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) },
1.471 +#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) },
1.472 +#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) },
1.473 +#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) },
1.474
1.475 static Flag flagTable[] = {
1.476 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)
1.477 @@ -260,7 +439,7 @@
1.478 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)
1.479 #endif // INCLUDE_ALL_GCS
1.480 #ifdef COMPILER1
1.481 - C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, C1_PD_DEVELOP_FLAG_STRUCT, C1_PRODUCT_FLAG_STRUCT, C1_PD_PRODUCT_FLAG_STRUCT, C1_NOTPRODUCT_FLAG_STRUCT)
1.482 + C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, C1_PD_DEVELOP_FLAG_STRUCT, C1_PRODUCT_FLAG_STRUCT, C1_PD_PRODUCT_FLAG_STRUCT, C1_DIAGNOSTIC_FLAG_STRUCT, C1_NOTPRODUCT_FLAG_STRUCT)
1.483 #endif
1.484 #ifdef COMPILER2
1.485 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)
1.486 @@ -284,9 +463,14 @@
1.487
1.488 // Search the flag table for a named flag
1.489 Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) {
1.490 - for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
1.491 - if (str_equal(current->name, name, length)) {
1.492 - // Found a matching entry. Report locked flags only if allowed.
1.493 + for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
1.494 + if (str_equal(current->_name, name, length)) {
1.495 + // Found a matching entry.
1.496 + // Don't report notproduct and develop flags in product builds.
1.497 + if (current->is_constant_in_binary()) {
1.498 + return NULL;
1.499 + }
1.500 + // Report locked flags only if allowed.
1.501 if (!(current->is_unlocked() || current->is_unlocker())) {
1.502 if (!allow_locked) {
1.503 // disable use of locked flags, e.g. diagnostic, experimental,
1.504 @@ -326,8 +510,8 @@
1.505 float score;
1.506 float max_score = -1;
1.507
1.508 - for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
1.509 - score = str_similar(current->name, name, length);
1.510 + for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
1.511 + score = str_similar(current->_name, name, length);
1.512 if (score > max_score) {
1.513 max_score = score;
1.514 match = current;
1.515 @@ -356,25 +540,25 @@
1.516 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
1.517 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
1.518 Flag* f = &Flag::flags[flag];
1.519 - return (f->origin == DEFAULT);
1.520 + return f->is_default();
1.521 }
1.522
1.523 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
1.524 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
1.525 Flag* f = &Flag::flags[flag];
1.526 - return (f->origin == ERGONOMIC);
1.527 + return f->is_ergonomic();
1.528 }
1.529
1.530 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
1.531 assert((size_t)flag < Flag::numFlags, "bad command line flag index");
1.532 Flag* f = &Flag::flags[flag];
1.533 - return (f->origin == COMMAND_LINE);
1.534 + return f->is_command_line();
1.535 }
1.536
1.537 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
1.538 Flag* result = Flag::find_flag((char*)name, strlen(name));
1.539 if (result == NULL) return false;
1.540 - *value = (result->origin == COMMAND_LINE);
1.541 + *value = result->is_command_line();
1.542 return true;
1.543 }
1.544
1.545 @@ -386,22 +570,22 @@
1.546 return true;
1.547 }
1.548
1.549 -bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin) {
1.550 +bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) {
1.551 Flag* result = Flag::find_flag(name, len);
1.552 if (result == NULL) return false;
1.553 if (!result->is_bool()) return false;
1.554 bool old_value = result->get_bool();
1.555 result->set_bool(*value);
1.556 *value = old_value;
1.557 - result->origin = origin;
1.558 + result->set_origin(origin);
1.559 return true;
1.560 }
1.561
1.562 -void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, FlagValueOrigin origin) {
1.563 +void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
1.564 Flag* faddr = address_of_flag(flag);
1.565 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
1.566 faddr->set_bool(value);
1.567 - faddr->origin = origin;
1.568 + faddr->set_origin(origin);
1.569 }
1.570
1.571 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) {
1.572 @@ -412,22 +596,22 @@
1.573 return true;
1.574 }
1.575
1.576 -bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin) {
1.577 +bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) {
1.578 Flag* result = Flag::find_flag(name, len);
1.579 if (result == NULL) return false;
1.580 if (!result->is_intx()) return false;
1.581 intx old_value = result->get_intx();
1.582 result->set_intx(*value);
1.583 *value = old_value;
1.584 - result->origin = origin;
1.585 + result->set_origin(origin);
1.586 return true;
1.587 }
1.588
1.589 -void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, FlagValueOrigin origin) {
1.590 +void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
1.591 Flag* faddr = address_of_flag(flag);
1.592 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
1.593 faddr->set_intx(value);
1.594 - faddr->origin = origin;
1.595 + faddr->set_origin(origin);
1.596 }
1.597
1.598 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) {
1.599 @@ -438,22 +622,22 @@
1.600 return true;
1.601 }
1.602
1.603 -bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin) {
1.604 +bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin) {
1.605 Flag* result = Flag::find_flag(name, len);
1.606 if (result == NULL) return false;
1.607 if (!result->is_uintx()) return false;
1.608 uintx old_value = result->get_uintx();
1.609 result->set_uintx(*value);
1.610 *value = old_value;
1.611 - result->origin = origin;
1.612 + result->set_origin(origin);
1.613 return true;
1.614 }
1.615
1.616 -void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, FlagValueOrigin origin) {
1.617 +void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
1.618 Flag* faddr = address_of_flag(flag);
1.619 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
1.620 faddr->set_uintx(value);
1.621 - faddr->origin = origin;
1.622 + faddr->set_origin(origin);
1.623 }
1.624
1.625 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) {
1.626 @@ -464,22 +648,22 @@
1.627 return true;
1.628 }
1.629
1.630 -bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin) {
1.631 +bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1.632 Flag* result = Flag::find_flag(name, len);
1.633 if (result == NULL) return false;
1.634 if (!result->is_uint64_t()) return false;
1.635 uint64_t old_value = result->get_uint64_t();
1.636 result->set_uint64_t(*value);
1.637 *value = old_value;
1.638 - result->origin = origin;
1.639 + result->set_origin(origin);
1.640 return true;
1.641 }
1.642
1.643 -void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, FlagValueOrigin origin) {
1.644 +void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1.645 Flag* faddr = address_of_flag(flag);
1.646 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1.647 faddr->set_uint64_t(value);
1.648 - faddr->origin = origin;
1.649 + faddr->set_origin(origin);
1.650 }
1.651
1.652 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) {
1.653 @@ -490,22 +674,22 @@
1.654 return true;
1.655 }
1.656
1.657 -bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin) {
1.658 +bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) {
1.659 Flag* result = Flag::find_flag(name, len);
1.660 if (result == NULL) return false;
1.661 if (!result->is_double()) return false;
1.662 double old_value = result->get_double();
1.663 result->set_double(*value);
1.664 *value = old_value;
1.665 - result->origin = origin;
1.666 + result->set_origin(origin);
1.667 return true;
1.668 }
1.669
1.670 -void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, FlagValueOrigin origin) {
1.671 +void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1.672 Flag* faddr = address_of_flag(flag);
1.673 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1.674 faddr->set_double(value);
1.675 - faddr->origin = origin;
1.676 + faddr->set_origin(origin);
1.677 }
1.678
1.679 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
1.680 @@ -518,7 +702,7 @@
1.681
1.682 // Contract: Flag will make private copy of the incoming value.
1.683 // Outgoing value is always malloc-ed, and caller MUST call free.
1.684 -bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin) {
1.685 +bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) {
1.686 Flag* result = Flag::find_flag(name, len);
1.687 if (result == NULL) return false;
1.688 if (!result->is_ccstr()) return false;
1.689 @@ -529,35 +713,35 @@
1.690 strcpy(new_value, *value);
1.691 }
1.692 result->set_ccstr(new_value);
1.693 - if (result->origin == DEFAULT && old_value != NULL) {
1.694 + if (result->is_default() && old_value != NULL) {
1.695 // Prior value is NOT heap allocated, but was a literal constant.
1.696 char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal);
1.697 strcpy(old_value_to_free, old_value);
1.698 old_value = old_value_to_free;
1.699 }
1.700 *value = old_value;
1.701 - result->origin = origin;
1.702 + result->set_origin(origin);
1.703 return true;
1.704 }
1.705
1.706 // Contract: Flag will make private copy of the incoming value.
1.707 -void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, FlagValueOrigin origin) {
1.708 +void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
1.709 Flag* faddr = address_of_flag(flag);
1.710 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
1.711 ccstr old_value = faddr->get_ccstr();
1.712 char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
1.713 strcpy(new_value, value);
1.714 faddr->set_ccstr(new_value);
1.715 - if (faddr->origin != DEFAULT && old_value != NULL) {
1.716 + if (!faddr->is_default() && old_value != NULL) {
1.717 // Prior value is heap allocated so free it.
1.718 FREE_C_HEAP_ARRAY(char, old_value, mtInternal);
1.719 }
1.720 - faddr->origin = origin;
1.721 + faddr->set_origin(origin);
1.722 }
1.723
1.724 extern "C" {
1.725 static int compare_flags(const void* void_a, const void* void_b) {
1.726 - return strcmp((*((Flag**) void_a))->name, (*((Flag**) void_b))->name);
1.727 + return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name);
1.728 }
1.729 }
1.730
1.731 @@ -566,20 +750,19 @@
1.732 // note: this method is called before the thread structure is in place
1.733 // which means resource allocation cannot be used.
1.734
1.735 - // Compute size
1.736 - int length= 0;
1.737 - while (flagTable[length].name != NULL) length++;
1.738 + // The last entry is the null entry.
1.739 + const size_t length = Flag::numFlags - 1;
1.740
1.741 // Sort
1.742 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
1.743 - for (int index = 0; index < length; index++) {
1.744 - array[index] = &flagTable[index];
1.745 + for (size_t i = 0; i < length; i++) {
1.746 + array[i] = &flagTable[i];
1.747 }
1.748 qsort(array, length, sizeof(Flag*), compare_flags);
1.749
1.750 // Print
1.751 - for (int i = 0; i < length; i++) {
1.752 - if (array[i]->origin /* naked field! */) {
1.753 + for (size_t i = 0; i < length; i++) {
1.754 + if (array[i]->get_origin() /* naked field! */) {
1.755 array[i]->print_as_flag(out);
1.756 out->print(" ");
1.757 }
1.758 @@ -602,20 +785,19 @@
1.759 // note: this method is called before the thread structure is in place
1.760 // which means resource allocation cannot be used.
1.761
1.762 - // Compute size
1.763 - int length= 0;
1.764 - while (flagTable[length].name != NULL) length++;
1.765 + // The last entry is the null entry.
1.766 + const size_t length = Flag::numFlags - 1;
1.767
1.768 // Sort
1.769 Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
1.770 - for (int index = 0; index < length; index++) {
1.771 - array[index] = &flagTable[index];
1.772 + for (size_t i = 0; i < length; i++) {
1.773 + array[i] = &flagTable[i];
1.774 }
1.775 qsort(array, length, sizeof(Flag*), compare_flags);
1.776
1.777 // Print
1.778 out->print_cr("[Global flags]");
1.779 - for (int i = 0; i < length; i++) {
1.780 + for (size_t i = 0; i < length; i++) {
1.781 if (array[i]->is_unlocked()) {
1.782 array[i]->print_on(out, withComments);
1.783 }
