src/share/vm/runtime/globals.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8024545 Sdiff src/share/vm/runtime

src/share/vm/runtime/globals.cpp

Print this page




  45 #endif
  46 
  47 RUNTIME_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, \
  48               MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, \
  49               MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_EXPERIMENTAL_FLAG, \
  50               MATERIALIZE_NOTPRODUCT_FLAG, \
  51               MATERIALIZE_MANAGEABLE_FLAG, MATERIALIZE_PRODUCT_RW_FLAG, \
  52               MATERIALIZE_LP64_PRODUCT_FLAG)
  53 
  54 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, \
  55                  MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, \
  56                  MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_NOTPRODUCT_FLAG)
  57 
  58 ARCH_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PRODUCT_FLAG, \
  59            MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_EXPERIMENTAL_FLAG, \
  60            MATERIALIZE_NOTPRODUCT_FLAG)
  61 
  62 MATERIALIZE_FLAGS_EXT
  63 
  64 


























































































































































  65 bool Flag::is_unlocker() const {
  66   return strcmp(name, "UnlockDiagnosticVMOptions") == 0     ||
  67          strcmp(name, "UnlockExperimentalVMOptions") == 0   ||
  68          is_unlocker_ext();
  69 }
  70 
  71 bool Flag::is_unlocked() const {
  72   if (strcmp(kind, "{diagnostic}") == 0 ||
  73       strcmp(kind, "{C2 diagnostic}") == 0 ||
  74       strcmp(kind, "{ARCH diagnostic}") == 0 ||
  75       strcmp(kind, "{Shark diagnostic}") == 0) {
  76     return UnlockDiagnosticVMOptions;
  77   } else if (strcmp(kind, "{experimental}") == 0 ||
  78              strcmp(kind, "{C2 experimental}") == 0 ||
  79              strcmp(kind, "{ARCH experimental}") == 0 ||
  80              strcmp(kind, "{Shark experimental}") == 0) {
  81     return UnlockExperimentalVMOptions;
  82   } else {
  83     return is_unlocked_ext();
  84   }

  85 }
  86 
  87 // Get custom message for this locked flag, or return NULL if
  88 // none is available.
  89 void Flag::get_locked_message(char* buf, int buflen) const {
  90   get_locked_message_ext(buf, buflen);
  91 }
  92 
  93 bool Flag::is_writeable() const {
  94   return strcmp(kind, "{manageable}") == 0 ||
  95          strcmp(kind, "{product rw}") == 0 ||
  96          is_writeable_ext();
  97 }
  98 
  99 // All flags except "manageable" are assumed to be internal flags.
 100 // Long term, we need to define a mechanism to specify which flags
 101 // are external/stable and change this function accordingly.
 102 bool Flag::is_external() const {
 103   return strcmp(kind, "{manageable}") == 0 || is_external_ext();
 104 }
 105 
 106 
 107 // Length of format string (e.g. "%.1234s") for printing ccstr below
 108 #define FORMAT_BUFFER_LEN 16
 109 
 110 void Flag::print_on(outputStream* st, bool withComments) {
 111   st->print("%9s %-40s %c= ", type, name, (origin != DEFAULT ? ':' : ' '));
 112   if (is_bool())     st->print("%-16s", get_bool() ? "true" : "false");
 113   if (is_intx())     st->print("%-16ld", get_intx());
 114   if (is_uintx())    st->print("%-16lu", get_uintx());
 115   if (is_uint64_t()) st->print("%-16lu", get_uint64_t());
 116   if (is_double())   st->print("%-16f", get_double());
 117 















 118   if (is_ccstr()) {
 119      const char* cp = get_ccstr();
 120      if (cp != NULL) {
 121        const char* eol;
 122        while ((eol = strchr(cp, '\n')) != NULL) {
 123          char format_buffer[FORMAT_BUFFER_LEN];
 124          size_t llen = pointer_delta(eol, cp, sizeof(char));
 125          jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
 126                      "%%." SIZE_FORMAT "s", llen);
 127          st->print(format_buffer, cp);
 128          st->cr();
 129          cp = eol+1;
 130          st->print("%5s %-35s += ", "", name);
 131        }
 132        st->print("%-16s", cp);
 133      }
 134      else st->print("%-16s", "");
 135   }
 136   st->print("%-20s", kind);



 137   if (withComments) {
 138 #ifndef PRODUCT
 139     st->print("%s", doc );
 140 #endif
 141   }
 142   st->cr();
 143 }
 144 










































 145 void Flag::print_as_flag(outputStream* st) {
 146   if (is_bool()) {
 147     st->print("-XX:%s%s", get_bool() ? "+" : "-", name);
 148   } else if (is_intx()) {
 149     st->print("-XX:%s=" INTX_FORMAT, name, get_intx());
 150   } else if (is_uintx()) {
 151     st->print("-XX:%s=" UINTX_FORMAT, name, get_uintx());
 152   } else if (is_uint64_t()) {
 153     st->print("-XX:%s=" UINT64_FORMAT, name, get_uint64_t());
 154   } else if (is_double()) {
 155     st->print("-XX:%s=%f", name, get_double());
 156   } else if (is_ccstr()) {
 157     st->print("-XX:%s=", name);
 158     const char* cp = get_ccstr();
 159     if (cp != NULL) {
 160       // Need to turn embedded '\n's back into separate arguments
 161       // Not so efficient to print one character at a time,
 162       // but the choice is to do the transformation to a buffer
 163       // and print that.  And this need not be efficient.
 164       for (; *cp != '\0'; cp += 1) {
 165         switch (*cp) {
 166           default:
 167             st->print("%c", *cp);
 168             break;
 169           case '\n':
 170             st->print(" -XX:%s=", name);
 171             break;
 172         }
 173       }
 174     }
 175   } else {
 176     ShouldNotReachHere();
 177   }
 178 }
 179 
 180 // 4991491 do not "optimize out" the was_set false values: omitting them
 181 // tickles a Microsoft compiler bug causing flagTable to be malformed
 182 
 183 #define RUNTIME_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product}", DEFAULT },
 184 #define RUNTIME_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{pd product}", DEFAULT },
 185 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{diagnostic}", DEFAULT },
 186 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{experimental}", DEFAULT },
 187 #define RUNTIME_MANAGEABLE_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{manageable}", DEFAULT },
 188 #define RUNTIME_PRODUCT_RW_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{product rw}", DEFAULT },
 189 
 190 #ifdef PRODUCT
 191   #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 192   #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
 193   #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
 194 #else
 195   #define RUNTIME_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "", DEFAULT },
 196   #define RUNTIME_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{pd}", DEFAULT },
 197   #define RUNTIME_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{notproduct}", DEFAULT },
 198 #endif
 199 
 200 #ifdef _LP64
 201   #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{lp64_product}", DEFAULT },
 202 #else
 203   #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 204 #endif // _LP64
 205 
 206 #define C1_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 product}", DEFAULT },
 207 #define C1_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 pd product}", DEFAULT },
 208 #define C1_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C1 diagnostic}", DEFAULT },
 209 #ifdef PRODUCT
 210   #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 211   #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
 212   #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
 213 #else
 214   #define C1_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1}", DEFAULT },
 215   #define C1_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{C1 pd}", DEFAULT },
 216   #define C1_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C1 notproduct}", DEFAULT },
 217 #endif
 218 
 219 #define C2_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 product}", DEFAULT },
 220 #define C2_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 pd product}", DEFAULT },
 221 #define C2_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 diagnostic}", DEFAULT },
 222 #define C2_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{C2 experimental}", DEFAULT },
 223 #ifdef PRODUCT
 224   #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 225   #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
 226   #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
 227 #else
 228   #define C2_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2}", DEFAULT },
 229   #define C2_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{C2 pd}", DEFAULT },
 230   #define C2_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{C2 notproduct}", DEFAULT },
 231 #endif
 232 
 233 #define ARCH_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH product}", DEFAULT },
 234 #define ARCH_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH diagnostic}", DEFAULT },
 235 #define ARCH_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{ARCH experimental}", DEFAULT },
 236 #ifdef PRODUCT
 237   #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 238   #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
 239 #else
 240   #define ARCH_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH}", DEFAULT },
 241   #define ARCH_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{ARCH notproduct}", DEFAULT },
 242 #endif
 243 
 244 #define SHARK_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark product}", DEFAULT },
 245 #define SHARK_PD_PRODUCT_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark pd product}", DEFAULT },
 246 #define SHARK_DIAGNOSTIC_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) "{Shark diagnostic}", DEFAULT },
 247 #ifdef PRODUCT
 248   #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 249   #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     /* flag is constant */
 250   #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc)
 251 #else
 252   #define SHARK_DEVELOP_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark}", DEFAULT },
 253   #define SHARK_PD_DEVELOP_FLAG_STRUCT(type, name, doc)     { #type, XSTR(name), &name, doc, "{Shark pd}", DEFAULT },
 254   #define SHARK_NOTPRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, doc, "{Shark notproduct}", DEFAULT },
 255 #endif
 256 
 257 static Flag flagTable[] = {
 258  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)
 259  RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT)
 260 #if INCLUDE_ALL_GCS
 261  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)
 262 #endif // INCLUDE_ALL_GCS
 263 #ifdef COMPILER1
 264  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)
 265 #endif
 266 #ifdef COMPILER2
 267  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)
 268 #endif
 269 #ifdef SHARK
 270  SHARK_FLAGS(SHARK_DEVELOP_FLAG_STRUCT, SHARK_PD_DEVELOP_FLAG_STRUCT, SHARK_PRODUCT_FLAG_STRUCT, SHARK_PD_PRODUCT_FLAG_STRUCT, SHARK_DIAGNOSTIC_FLAG_STRUCT, SHARK_NOTPRODUCT_FLAG_STRUCT)
 271 #endif
 272  ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, ARCH_PRODUCT_FLAG_STRUCT, ARCH_DIAGNOSTIC_FLAG_STRUCT, ARCH_EXPERIMENTAL_FLAG_STRUCT, ARCH_NOTPRODUCT_FLAG_STRUCT)
 273  FLAGTABLE_EXT
 274  {0, NULL, NULL}
 275 };
 276 
 277 Flag* Flag::flags = flagTable;
 278 size_t Flag::numFlags = (sizeof(flagTable) / sizeof(Flag));
 279 
 280 inline bool str_equal(const char* s, const char* q, size_t len) {
 281   // s is null terminated, q is not!
 282   if (strlen(s) != (unsigned int) len) return false;
 283   return strncmp(s, q, len) == 0;
 284 }
 285 
 286 // Search the flag table for a named flag
 287 Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) {
 288   for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
 289     if (str_equal(current->name, name, length)) {
 290       // Found a matching entry.  Report locked flags only if allowed.





 291       if (!(current->is_unlocked() || current->is_unlocker())) {
 292         if (!allow_locked) {
 293           // disable use of locked flags, e.g. diagnostic, experimental,
 294           // commercial... until they are explicitly unlocked
 295           return NULL;
 296         }
 297       }
 298       return current;
 299     }
 300   }
 301   // Flag name is not in the flag table
 302   return NULL;
 303 }
 304 
 305 // Compute string similarity based on Dice's coefficient
 306 static float str_similar(const char* str1, const char* str2, size_t len2) {
 307   int len1 = (int) strlen(str1);
 308   int total = len1 + (int) len2;
 309 
 310   int hit = 0;
 311 
 312   for (int i = 0; i < len1 -1; ++i) {
 313     for (int j = 0; j < (int) len2 -1; ++j) {
 314       if ((str1[i] == str2[j]) && (str1[i+1] == str2[j+1])) {
 315         ++hit;
 316         break;
 317       }
 318     }
 319   }
 320 
 321   return 2.0f * (float) hit / (float) total;
 322 }
 323 
 324 Flag* Flag::fuzzy_match(const char* name, size_t length, bool allow_locked) {
 325   float VMOptionsFuzzyMatchSimilarity = 0.7f;
 326   Flag* match = NULL;
 327   float score;
 328   float max_score = -1;
 329 
 330   for (Flag* current = &flagTable[0]; current->name != NULL; current++) {
 331     score = str_similar(current->name, name, length);
 332     if (score > max_score) {
 333       max_score = score;
 334       match = current;
 335     }
 336   }
 337 
 338   if (!(match->is_unlocked() || match->is_unlocker())) {
 339     if (!allow_locked) {
 340       return NULL;
 341     }
 342   }
 343 
 344   if (max_score < VMOptionsFuzzyMatchSimilarity) {
 345     return NULL;
 346   }
 347 
 348   return match;
 349 }
 350 
 351 // Returns the address of the index'th element
 352 static Flag* address_of_flag(CommandLineFlagWithType flag) {
 353   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 354   return &Flag::flags[flag];
 355 }
 356 
 357 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
 358   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 359   Flag* f = &Flag::flags[flag];
 360   return (f->origin == DEFAULT);
 361 }
 362 
 363 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
 364   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 365   Flag* f = &Flag::flags[flag];
 366   return (f->origin == ERGONOMIC);
 367 }
 368 
 369 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
 370   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 371   Flag* f = &Flag::flags[flag];
 372   return (f->origin == COMMAND_LINE);
 373 }
 374 
 375 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
 376   Flag* result = Flag::find_flag((char*)name, strlen(name));
 377   if (result == NULL) return false;
 378   *value = (result->origin == COMMAND_LINE);
 379   return true;
 380 }
 381 
 382 bool CommandLineFlags::boolAt(char* name, size_t len, bool* value) {
 383   Flag* result = Flag::find_flag(name, len);
 384   if (result == NULL) return false;
 385   if (!result->is_bool()) return false;
 386   *value = result->get_bool();
 387   return true;
 388 }
 389 
 390 bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin) {
 391   Flag* result = Flag::find_flag(name, len);
 392   if (result == NULL) return false;
 393   if (!result->is_bool()) return false;
 394   bool old_value = result->get_bool();
 395   result->set_bool(*value);
 396   *value = old_value;
 397   result->origin = origin;
 398   return true;
 399 }
 400 
 401 void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, FlagValueOrigin origin) {
 402   Flag* faddr = address_of_flag(flag);
 403   guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
 404   faddr->set_bool(value);
 405   faddr->origin = origin;
 406 }
 407 
 408 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) {
 409   Flag* result = Flag::find_flag(name, len);
 410   if (result == NULL) return false;
 411   if (!result->is_intx()) return false;
 412   *value = result->get_intx();
 413   return true;
 414 }
 415 
 416 bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin) {
 417   Flag* result = Flag::find_flag(name, len);
 418   if (result == NULL) return false;
 419   if (!result->is_intx()) return false;
 420   intx old_value = result->get_intx();
 421   result->set_intx(*value);
 422   *value = old_value;
 423   result->origin = origin;
 424   return true;
 425 }
 426 
 427 void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, FlagValueOrigin origin) {
 428   Flag* faddr = address_of_flag(flag);
 429   guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
 430   faddr->set_intx(value);
 431   faddr->origin = origin;
 432 }
 433 
 434 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) {
 435   Flag* result = Flag::find_flag(name, len);
 436   if (result == NULL) return false;
 437   if (!result->is_uintx()) return false;
 438   *value = result->get_uintx();
 439   return true;
 440 }
 441 
 442 bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin) {
 443   Flag* result = Flag::find_flag(name, len);
 444   if (result == NULL) return false;
 445   if (!result->is_uintx()) return false;
 446   uintx old_value = result->get_uintx();
 447   result->set_uintx(*value);
 448   *value = old_value;
 449   result->origin = origin;
 450   return true;
 451 }
 452 
 453 void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, FlagValueOrigin origin) {
 454   Flag* faddr = address_of_flag(flag);
 455   guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
 456   faddr->set_uintx(value);
 457   faddr->origin = origin;
 458 }
 459 
 460 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) {
 461   Flag* result = Flag::find_flag(name, len);
 462   if (result == NULL) return false;
 463   if (!result->is_uint64_t()) return false;
 464   *value = result->get_uint64_t();
 465   return true;
 466 }
 467 
 468 bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin) {
 469   Flag* result = Flag::find_flag(name, len);
 470   if (result == NULL) return false;
 471   if (!result->is_uint64_t()) return false;
 472   uint64_t old_value = result->get_uint64_t();
 473   result->set_uint64_t(*value);
 474   *value = old_value;
 475   result->origin = origin;
 476   return true;
 477 }
 478 
 479 void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, FlagValueOrigin origin) {
 480   Flag* faddr = address_of_flag(flag);
 481   guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
 482   faddr->set_uint64_t(value);
 483   faddr->origin = origin;
 484 }
 485 
 486 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) {
 487   Flag* result = Flag::find_flag(name, len);
 488   if (result == NULL) return false;
 489   if (!result->is_double()) return false;
 490   *value = result->get_double();
 491   return true;
 492 }
 493 
 494 bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin) {
 495   Flag* result = Flag::find_flag(name, len);
 496   if (result == NULL) return false;
 497   if (!result->is_double()) return false;
 498   double old_value = result->get_double();
 499   result->set_double(*value);
 500   *value = old_value;
 501   result->origin = origin;
 502   return true;
 503 }
 504 
 505 void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, FlagValueOrigin origin) {
 506   Flag* faddr = address_of_flag(flag);
 507   guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
 508   faddr->set_double(value);
 509   faddr->origin = origin;
 510 }
 511 
 512 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
 513   Flag* result = Flag::find_flag(name, len);
 514   if (result == NULL) return false;
 515   if (!result->is_ccstr()) return false;
 516   *value = result->get_ccstr();
 517   return true;
 518 }
 519 
 520 // Contract:  Flag will make private copy of the incoming value.
 521 // Outgoing value is always malloc-ed, and caller MUST call free.
 522 bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin) {
 523   Flag* result = Flag::find_flag(name, len);
 524   if (result == NULL) return false;
 525   if (!result->is_ccstr()) return false;
 526   ccstr old_value = result->get_ccstr();
 527   char* new_value = NULL;
 528   if (*value != NULL) {
 529     new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal);
 530     strcpy(new_value, *value);
 531   }
 532   result->set_ccstr(new_value);
 533   if (result->origin == DEFAULT && old_value != NULL) {
 534     // Prior value is NOT heap allocated, but was a literal constant.
 535     char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal);
 536     strcpy(old_value_to_free, old_value);
 537     old_value = old_value_to_free;
 538   }
 539   *value = old_value;
 540   result->origin = origin;
 541   return true;
 542 }
 543 
 544 // Contract:  Flag will make private copy of the incoming value.
 545 void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, FlagValueOrigin origin) {
 546   Flag* faddr = address_of_flag(flag);
 547   guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
 548   ccstr old_value = faddr->get_ccstr();
 549   char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
 550   strcpy(new_value, value);
 551   faddr->set_ccstr(new_value);
 552   if (faddr->origin != DEFAULT && old_value != NULL) {
 553     // Prior value is heap allocated so free it.
 554     FREE_C_HEAP_ARRAY(char, old_value, mtInternal);
 555   }
 556   faddr->origin = origin;
 557 }
 558 
 559 extern "C" {
 560   static int compare_flags(const void* void_a, const void* void_b) {
 561     return strcmp((*((Flag**) void_a))->name, (*((Flag**) void_b))->name);
 562   }
 563 }
 564 
 565 void CommandLineFlags::printSetFlags(outputStream* out) {
 566   // Print which flags were set on the command line
 567   // note: this method is called before the thread structure is in place
 568   //       which means resource allocation cannot be used.
 569 
 570   // Compute size
 571   int length= 0;
 572   while (flagTable[length].name != NULL) length++;
 573 
 574   // Sort
 575   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
 576   for (int index = 0; index < length; index++) {
 577     array[index] = &flagTable[index];
 578   }
 579   qsort(array, length, sizeof(Flag*), compare_flags);
 580 
 581   // Print
 582   for (int i = 0; i < length; i++) {
 583     if (array[i]->origin /* naked field! */) {
 584       array[i]->print_as_flag(out);
 585       out->print(" ");
 586     }
 587   }
 588   out->cr();
 589   FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
 590 }
 591 
 592 #ifndef PRODUCT
 593 
 594 
 595 void CommandLineFlags::verify() {
 596   assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
 597 }
 598 
 599 #endif // PRODUCT
 600 
 601 void CommandLineFlags::printFlags(outputStream* out, bool withComments) {
 602   // Print the flags sorted by name
 603   // note: this method is called before the thread structure is in place
 604   //       which means resource allocation cannot be used.
 605 
 606   // Compute size
 607   int length= 0;
 608   while (flagTable[length].name != NULL) length++;
 609 
 610   // Sort
 611   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
 612   for (int index = 0; index < length; index++) {
 613     array[index] = &flagTable[index];
 614   }
 615   qsort(array, length, sizeof(Flag*), compare_flags);
 616 
 617   // Print
 618   out->print_cr("[Global flags]");
 619   for (int i = 0; i < length; i++) {
 620     if (array[i]->is_unlocked()) {
 621       array[i]->print_on(out, withComments);
 622     }
 623   }
 624   FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
 625 }


  45 #endif
  46 
  47 RUNTIME_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, \
  48               MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, \
  49               MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_EXPERIMENTAL_FLAG, \
  50               MATERIALIZE_NOTPRODUCT_FLAG, \
  51               MATERIALIZE_MANAGEABLE_FLAG, MATERIALIZE_PRODUCT_RW_FLAG, \
  52               MATERIALIZE_LP64_PRODUCT_FLAG)
  53 
  54 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, \
  55                  MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, \
  56                  MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_NOTPRODUCT_FLAG)
  57 
  58 ARCH_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PRODUCT_FLAG, \
  59            MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_EXPERIMENTAL_FLAG, \
  60            MATERIALIZE_NOTPRODUCT_FLAG)
  61 
  62 MATERIALIZE_FLAGS_EXT
  63 
  64 
  65 void Flag::check_writable() {
  66   if (is_constant_in_binary()) {
  67     fatal(err_msg("flag is constant: %s", _name));
  68   }
  69 }
  70 
  71 bool Flag::is_bool() const {
  72   return strcmp(_type, "bool") == 0;
  73 }
  74 
  75 bool Flag::get_bool() const {
  76   return *((bool*) _addr);
  77 }
  78 
  79 void Flag::set_bool(bool value) {
  80   check_writable();
  81   *((bool*) _addr) = value;
  82 }
  83 
  84 bool Flag::is_intx() const {
  85   return strcmp(_type, "intx")  == 0;
  86 }
  87 
  88 intx Flag::get_intx() const {
  89   return *((intx*) _addr);
  90 }
  91 
  92 void Flag::set_intx(intx value) {
  93   check_writable();
  94   *((intx*) _addr) = value;
  95 }
  96 
  97 bool Flag::is_uintx() const {
  98   return strcmp(_type, "uintx") == 0;
  99 }
 100 
 101 uintx Flag::get_uintx() const {
 102   return *((uintx*) _addr);
 103 }
 104 
 105 void Flag::set_uintx(uintx value) {
 106   check_writable();
 107   *((uintx*) _addr) = value;
 108 }
 109 
 110 bool Flag::is_uint64_t() const {
 111   return strcmp(_type, "uint64_t") == 0;
 112 }
 113 
 114 uint64_t Flag::get_uint64_t() const {
 115   return *((uint64_t*) _addr);
 116 }
 117 
 118 void Flag::set_uint64_t(uint64_t value) {
 119   check_writable();
 120   *((uint64_t*) _addr) = value;
 121 }
 122 
 123 bool Flag::is_double() const {
 124   return strcmp(_type, "double") == 0;
 125 }
 126 
 127 double Flag::get_double() const {
 128   return *((double*) _addr);
 129 }
 130 
 131 void Flag::set_double(double value) {
 132   check_writable();
 133   *((double*) _addr) = value;
 134 }
 135 
 136 bool Flag::is_ccstr() const {
 137   return strcmp(_type, "ccstr") == 0 || strcmp(_type, "ccstrlist") == 0;
 138 }
 139 
 140 bool Flag::ccstr_accumulates() const {
 141   return strcmp(_type, "ccstrlist") == 0;
 142 }
 143 
 144 ccstr Flag::get_ccstr() const {
 145   return *((ccstr*) _addr);
 146 }
 147 
 148 void Flag::set_ccstr(ccstr value) {
 149   check_writable();
 150   *((ccstr*) _addr) = value;
 151 }
 152 
 153 
 154 Flag::Flags Flag::get_origin() {
 155   return Flags(_flags & VALUE_ORIGIN_MASK);
 156 }
 157 
 158 void Flag::set_origin(Flags origin) {
 159   assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity");
 160   _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | origin);
 161 }
 162 
 163 bool Flag::is_default() {
 164   return (get_origin() == DEFAULT);
 165 }
 166 
 167 bool Flag::is_ergonomic() {
 168   return (get_origin() == ERGONOMIC);
 169 }
 170 
 171 bool Flag::is_command_line() {
 172   return (get_origin() == COMMAND_LINE);
 173 }
 174 
 175 bool Flag::is_product() const {
 176   return (_flags & KIND_PRODUCT) != 0;
 177 }
 178 
 179 bool Flag::is_manageable() const {
 180   return (_flags & KIND_MANAGEABLE) != 0;
 181 }
 182 
 183 bool Flag::is_diagnostic() const {
 184   return (_flags & KIND_DIAGNOSTIC) != 0;
 185 }
 186 
 187 bool Flag::is_experimental() const {
 188   return (_flags & KIND_EXPERIMENTAL) != 0;
 189 }
 190 
 191 bool Flag::is_notproduct() const {
 192   return (_flags & KIND_NOT_PRODUCT) != 0;
 193 }
 194 
 195 bool Flag::is_develop() const {
 196   return (_flags & KIND_DEVELOP) != 0;
 197 }
 198 
 199 bool Flag::is_read_write() const {
 200   return (_flags & KIND_READ_WRITE) != 0;
 201 }
 202 
 203 bool Flag::is_commercial() const {
 204   return (_flags & KIND_COMMERCIAL) != 0;
 205 }
 206 
 207 /**
 208  * Returns if this flag is a constant in the binary.  Right now this is
 209  * true for notproduct and develop flags in product builds.
 210  */
 211 bool Flag::is_constant_in_binary() const {
 212 #ifdef PRODUCT
 213     return is_notproduct() || is_develop();
 214 #else
 215     return false;
 216 #endif
 217 }
 218 
 219 bool Flag::is_unlocker() const {
 220   return strcmp(_name, "UnlockDiagnosticVMOptions") == 0     ||
 221          strcmp(_name, "UnlockExperimentalVMOptions") == 0   ||
 222          is_unlocker_ext();
 223 }
 224 
 225 bool Flag::is_unlocked() const {
 226   if (is_diagnostic()) {



 227     return UnlockDiagnosticVMOptions;
 228   }
 229   if (is_experimental()) {


 230     return UnlockExperimentalVMOptions;


 231   }
 232   return is_unlocked_ext();
 233 }
 234 
 235 // Get custom message for this locked flag, or return NULL if
 236 // none is available.
 237 void Flag::get_locked_message(char* buf, int buflen) const {
 238   get_locked_message_ext(buf, buflen);
 239 }
 240 
 241 bool Flag::is_writeable() const {
 242   return is_manageable() || (is_product() && is_read_write()) || is_writeable_ext();


 243 }
 244 
 245 // All flags except "manageable" are assumed to be internal flags.
 246 // Long term, we need to define a mechanism to specify which flags
 247 // are external/stable and change this function accordingly.
 248 bool Flag::is_external() const {
 249   return is_manageable() || is_external_ext();
 250 }
 251 
 252 
 253 // Length of format string (e.g. "%.1234s") for printing ccstr below
 254 #define FORMAT_BUFFER_LEN 16
 255 
 256 void Flag::print_on(outputStream* st, bool withComments) {
 257   // Don't print notproduct and develop flags in a product build.
 258   if (is_constant_in_binary()) {
 259     return;
 260   }
 261 
 262   st->print("%9s %-40s %c= ", _type, _name, (!is_default() ? ':' : ' '));
 263 
 264   if (is_bool()) {
 265     st->print("%-16s", get_bool() ? "true" : "false");
 266   }
 267   if (is_intx()) {
 268     st->print("%-16ld", get_intx());
 269   }
 270   if (is_uintx()) {
 271     st->print("%-16lu", get_uintx());
 272   }
 273   if (is_uint64_t()) {
 274     st->print("%-16lu", get_uint64_t());
 275   }
 276   if (is_double()) {
 277     st->print("%-16f", get_double());
 278   }
 279   if (is_ccstr()) {
 280     const char* cp = get_ccstr();
 281     if (cp != NULL) {
 282       const char* eol;
 283       while ((eol = strchr(cp, '\n')) != NULL) {
 284         char format_buffer[FORMAT_BUFFER_LEN];
 285         size_t llen = pointer_delta(eol, cp, sizeof(char));
 286         jio_snprintf(format_buffer, FORMAT_BUFFER_LEN,
 287             "%%." SIZE_FORMAT "s", llen);
 288         st->print(format_buffer, cp);
 289         st->cr();
 290         cp = eol+1;
 291         st->print("%5s %-35s += ", "", _name);
 292       }
 293       st->print("%-16s", cp);
 294     }
 295     else st->print("%-16s", "");
 296   }
 297 
 298   st->print("%-20");
 299   print_kind(st);
 300 
 301   if (withComments) {
 302 #ifndef PRODUCT
 303     st->print("%s", _doc);
 304 #endif
 305   }
 306   st->cr();
 307 }
 308 
 309 void Flag::print_kind(outputStream* st) {
 310   struct Data {
 311     int flag;
 312     const char* name;
 313   };
 314 
 315   Data data[] = {
 316       { KIND_C1, "C1" },
 317       { KIND_C2, "C2" },
 318       { KIND_ARCH, "ARCH" },
 319       { KIND_SHARK, "SHARK" },
 320       { KIND_PLATFORM_DEPENDENT, "pd" },
 321       { KIND_PRODUCT, "product" },
 322       { KIND_MANAGEABLE, "manageable" },
 323       { KIND_DIAGNOSTIC, "diagnostic" },
 324       { KIND_NOT_PRODUCT, "notproduct" },
 325       { KIND_DEVELOP, "develop" },
 326       { KIND_LP64_PRODUCT, "lp64_product" },
 327       { KIND_READ_WRITE, "rw" },
 328       { -1, "" }
 329   };
 330 
 331   if ((_flags & KIND_MASK) != 0) {
 332     st->print("{");
 333     bool is_first = true;
 334 
 335     for (int i = 0; data[i].flag != -1; i++) {
 336       Data d = data[i];
 337       if ((_flags & d.flag) != 0) {
 338         if (is_first) {
 339           is_first = false;
 340         } else {
 341           st->print(" ");
 342         }
 343         st->print(d.name);
 344       }
 345     }
 346 
 347     st->print("}");
 348   }
 349 }
 350 
 351 void Flag::print_as_flag(outputStream* st) {
 352   if (is_bool()) {
 353     st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
 354   } else if (is_intx()) {
 355     st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
 356   } else if (is_uintx()) {
 357     st->print("-XX:%s=" UINTX_FORMAT, _name, get_uintx());
 358   } else if (is_uint64_t()) {
 359     st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t());
 360   } else if (is_double()) {
 361     st->print("-XX:%s=%f", _name, get_double());
 362   } else if (is_ccstr()) {
 363     st->print("-XX:%s=", _name);
 364     const char* cp = get_ccstr();
 365     if (cp != NULL) {
 366       // Need to turn embedded '\n's back into separate arguments
 367       // Not so efficient to print one character at a time,
 368       // but the choice is to do the transformation to a buffer
 369       // and print that.  And this need not be efficient.
 370       for (; *cp != '\0'; cp += 1) {
 371         switch (*cp) {
 372           default:
 373             st->print("%c", *cp);
 374             break;
 375           case '\n':
 376             st->print(" -XX:%s=", _name);
 377             break;
 378         }
 379       }
 380     }
 381   } else {
 382     ShouldNotReachHere();
 383   }
 384 }
 385 
 386 // 4991491 do not "optimize out" the was_set false values: omitting them
 387 // tickles a Microsoft compiler bug causing flagTable to be malformed
 388 
 389 #define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)





 390 
 391 #define RUNTIME_PRODUCT_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) },
 392 #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) },
 393 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) },
 394 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) },
 395 #define RUNTIME_MANAGEABLE_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) },
 396 #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) },
 397 #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) },
 398 #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) },
 399 #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) },
 400 
 401 #ifdef _LP64
 402 #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) },
 403 #else
 404 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 405 #endif // _LP64
 406 
 407 #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) },
 408 #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) },
 409 #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) },
 410 #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) },
 411 #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) },
 412 #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) },
 413 
 414 #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) },
 415 #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) },
 416 #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) },
 417 #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) },
 418 #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) },
 419 #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) },
 420 #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) },
 421 
 422 #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) },
 423 #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) },
 424 #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) },
 425 #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) },
 426 #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) },
 427 
 428 #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) },
 429 #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) },
 430 #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) },
 431 #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) },
 432 #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) },
 433 #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) },























 434 
 435 static Flag flagTable[] = {
 436  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)
 437  RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT)
 438 #if INCLUDE_ALL_GCS
 439  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)
 440 #endif // INCLUDE_ALL_GCS
 441 #ifdef COMPILER1
 442  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)
 443 #endif
 444 #ifdef COMPILER2
 445  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)
 446 #endif
 447 #ifdef SHARK
 448  SHARK_FLAGS(SHARK_DEVELOP_FLAG_STRUCT, SHARK_PD_DEVELOP_FLAG_STRUCT, SHARK_PRODUCT_FLAG_STRUCT, SHARK_PD_PRODUCT_FLAG_STRUCT, SHARK_DIAGNOSTIC_FLAG_STRUCT, SHARK_NOTPRODUCT_FLAG_STRUCT)
 449 #endif
 450  ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, ARCH_PRODUCT_FLAG_STRUCT, ARCH_DIAGNOSTIC_FLAG_STRUCT, ARCH_EXPERIMENTAL_FLAG_STRUCT, ARCH_NOTPRODUCT_FLAG_STRUCT)
 451  FLAGTABLE_EXT
 452  {0, NULL, NULL}
 453 };
 454 
 455 Flag* Flag::flags = flagTable;
 456 size_t Flag::numFlags = (sizeof(flagTable) / sizeof(Flag));
 457 
 458 inline bool str_equal(const char* s, const char* q, size_t len) {
 459   // s is null terminated, q is not!
 460   if (strlen(s) != (unsigned int) len) return false;
 461   return strncmp(s, q, len) == 0;
 462 }
 463 
 464 // Search the flag table for a named flag
 465 Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) {
 466   for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
 467     if (str_equal(current->_name, name, length)) {
 468       // Found a matching entry.
 469       // Don't report notproduct and develop flags in product builds.
 470       if (current->is_constant_in_binary()) {
 471         return NULL;
 472       }
 473       // Report locked flags only if allowed.
 474       if (!(current->is_unlocked() || current->is_unlocker())) {
 475         if (!allow_locked) {
 476           // disable use of locked flags, e.g. diagnostic, experimental,
 477           // commercial... until they are explicitly unlocked
 478           return NULL;
 479         }
 480       }
 481       return current;
 482     }
 483   }
 484   // Flag name is not in the flag table
 485   return NULL;
 486 }
 487 
 488 // Compute string similarity based on Dice's coefficient
 489 static float str_similar(const char* str1, const char* str2, size_t len2) {
 490   int len1 = (int) strlen(str1);
 491   int total = len1 + (int) len2;
 492 
 493   int hit = 0;
 494 
 495   for (int i = 0; i < len1 -1; ++i) {
 496     for (int j = 0; j < (int) len2 -1; ++j) {
 497       if ((str1[i] == str2[j]) && (str1[i+1] == str2[j+1])) {
 498         ++hit;
 499         break;
 500       }
 501     }
 502   }
 503 
 504   return 2.0f * (float) hit / (float) total;
 505 }
 506 
 507 Flag* Flag::fuzzy_match(const char* name, size_t length, bool allow_locked) {
 508   float VMOptionsFuzzyMatchSimilarity = 0.7f;
 509   Flag* match = NULL;
 510   float score;
 511   float max_score = -1;
 512 
 513   for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
 514     score = str_similar(current->_name, name, length);
 515     if (score > max_score) {
 516       max_score = score;
 517       match = current;
 518     }
 519   }
 520 
 521   if (!(match->is_unlocked() || match->is_unlocker())) {
 522     if (!allow_locked) {
 523       return NULL;
 524     }
 525   }
 526 
 527   if (max_score < VMOptionsFuzzyMatchSimilarity) {
 528     return NULL;
 529   }
 530 
 531   return match;
 532 }
 533 
 534 // Returns the address of the index'th element
 535 static Flag* address_of_flag(CommandLineFlagWithType flag) {
 536   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 537   return &Flag::flags[flag];
 538 }
 539 
 540 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
 541   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 542   Flag* f = &Flag::flags[flag];
 543   return f->is_default();
 544 }
 545 
 546 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
 547   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 548   Flag* f = &Flag::flags[flag];
 549   return f->is_ergonomic();
 550 }
 551 
 552 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
 553   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 554   Flag* f = &Flag::flags[flag];
 555   return f->is_command_line();
 556 }
 557 
 558 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
 559   Flag* result = Flag::find_flag((char*)name, strlen(name));
 560   if (result == NULL) return false;
 561   *value = result->is_command_line();
 562   return true;
 563 }
 564 
 565 bool CommandLineFlags::boolAt(char* name, size_t len, bool* value) {
 566   Flag* result = Flag::find_flag(name, len);
 567   if (result == NULL) return false;
 568   if (!result->is_bool()) return false;
 569   *value = result->get_bool();
 570   return true;
 571 }
 572 
 573 bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) {
 574   Flag* result = Flag::find_flag(name, len);
 575   if (result == NULL) return false;
 576   if (!result->is_bool()) return false;
 577   bool old_value = result->get_bool();
 578   result->set_bool(*value);
 579   *value = old_value;
 580   result->set_origin(origin);
 581   return true;
 582 }
 583 
 584 void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
 585   Flag* faddr = address_of_flag(flag);
 586   guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
 587   faddr->set_bool(value);
 588   faddr->set_origin(origin);
 589 }
 590 
 591 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) {
 592   Flag* result = Flag::find_flag(name, len);
 593   if (result == NULL) return false;
 594   if (!result->is_intx()) return false;
 595   *value = result->get_intx();
 596   return true;
 597 }
 598 
 599 bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) {
 600   Flag* result = Flag::find_flag(name, len);
 601   if (result == NULL) return false;
 602   if (!result->is_intx()) return false;
 603   intx old_value = result->get_intx();
 604   result->set_intx(*value);
 605   *value = old_value;
 606   result->set_origin(origin);
 607   return true;
 608 }
 609 
 610 void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
 611   Flag* faddr = address_of_flag(flag);
 612   guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
 613   faddr->set_intx(value);
 614   faddr->set_origin(origin);
 615 }
 616 
 617 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) {
 618   Flag* result = Flag::find_flag(name, len);
 619   if (result == NULL) return false;
 620   if (!result->is_uintx()) return false;
 621   *value = result->get_uintx();
 622   return true;
 623 }
 624 
 625 bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin) {
 626   Flag* result = Flag::find_flag(name, len);
 627   if (result == NULL) return false;
 628   if (!result->is_uintx()) return false;
 629   uintx old_value = result->get_uintx();
 630   result->set_uintx(*value);
 631   *value = old_value;
 632   result->set_origin(origin);
 633   return true;
 634 }
 635 
 636 void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
 637   Flag* faddr = address_of_flag(flag);
 638   guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
 639   faddr->set_uintx(value);
 640   faddr->set_origin(origin);
 641 }
 642 
 643 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) {
 644   Flag* result = Flag::find_flag(name, len);
 645   if (result == NULL) return false;
 646   if (!result->is_uint64_t()) return false;
 647   *value = result->get_uint64_t();
 648   return true;
 649 }
 650 
 651 bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) {
 652   Flag* result = Flag::find_flag(name, len);
 653   if (result == NULL) return false;
 654   if (!result->is_uint64_t()) return false;
 655   uint64_t old_value = result->get_uint64_t();
 656   result->set_uint64_t(*value);
 657   *value = old_value;
 658   result->set_origin(origin);
 659   return true;
 660 }
 661 
 662 void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
 663   Flag* faddr = address_of_flag(flag);
 664   guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
 665   faddr->set_uint64_t(value);
 666   faddr->set_origin(origin);
 667 }
 668 
 669 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) {
 670   Flag* result = Flag::find_flag(name, len);
 671   if (result == NULL) return false;
 672   if (!result->is_double()) return false;
 673   *value = result->get_double();
 674   return true;
 675 }
 676 
 677 bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) {
 678   Flag* result = Flag::find_flag(name, len);
 679   if (result == NULL) return false;
 680   if (!result->is_double()) return false;
 681   double old_value = result->get_double();
 682   result->set_double(*value);
 683   *value = old_value;
 684   result->set_origin(origin);
 685   return true;
 686 }
 687 
 688 void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
 689   Flag* faddr = address_of_flag(flag);
 690   guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
 691   faddr->set_double(value);
 692   faddr->set_origin(origin);
 693 }
 694 
 695 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
 696   Flag* result = Flag::find_flag(name, len);
 697   if (result == NULL) return false;
 698   if (!result->is_ccstr()) return false;
 699   *value = result->get_ccstr();
 700   return true;
 701 }
 702 
 703 // Contract:  Flag will make private copy of the incoming value.
 704 // Outgoing value is always malloc-ed, and caller MUST call free.
 705 bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) {
 706   Flag* result = Flag::find_flag(name, len);
 707   if (result == NULL) return false;
 708   if (!result->is_ccstr()) return false;
 709   ccstr old_value = result->get_ccstr();
 710   char* new_value = NULL;
 711   if (*value != NULL) {
 712     new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal);
 713     strcpy(new_value, *value);
 714   }
 715   result->set_ccstr(new_value);
 716   if (result->is_default() && old_value != NULL) {
 717     // Prior value is NOT heap allocated, but was a literal constant.
 718     char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal);
 719     strcpy(old_value_to_free, old_value);
 720     old_value = old_value_to_free;
 721   }
 722   *value = old_value;
 723   result->set_origin(origin);
 724   return true;
 725 }
 726 
 727 // Contract:  Flag will make private copy of the incoming value.
 728 void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
 729   Flag* faddr = address_of_flag(flag);
 730   guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
 731   ccstr old_value = faddr->get_ccstr();
 732   char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
 733   strcpy(new_value, value);
 734   faddr->set_ccstr(new_value);
 735   if (!faddr->is_default() && old_value != NULL) {
 736     // Prior value is heap allocated so free it.
 737     FREE_C_HEAP_ARRAY(char, old_value, mtInternal);
 738   }
 739   faddr->set_origin(origin);
 740 }
 741 
 742 extern "C" {
 743   static int compare_flags(const void* void_a, const void* void_b) {
 744     return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name);
 745   }
 746 }
 747 
 748 void CommandLineFlags::printSetFlags(outputStream* out) {
 749   // Print which flags were set on the command line
 750   // note: this method is called before the thread structure is in place
 751   //       which means resource allocation cannot be used.
 752 
 753   // The last entry is the null entry.
 754   const size_t length = Flag::numFlags - 1;

 755 
 756   // Sort
 757   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
 758   for (size_t i = 0; i < length; i++) {
 759     array[i] = &flagTable[i];
 760   }
 761   qsort(array, length, sizeof(Flag*), compare_flags);
 762 
 763   // Print
 764   for (size_t i = 0; i < length; i++) {
 765     if (array[i]->get_origin() /* naked field! */) {
 766       array[i]->print_as_flag(out);
 767       out->print(" ");
 768     }
 769   }
 770   out->cr();
 771   FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
 772 }
 773 
 774 #ifndef PRODUCT
 775 
 776 
 777 void CommandLineFlags::verify() {
 778   assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
 779 }
 780 
 781 #endif // PRODUCT
 782 
 783 void CommandLineFlags::printFlags(outputStream* out, bool withComments) {
 784   // Print the flags sorted by name
 785   // note: this method is called before the thread structure is in place
 786   //       which means resource allocation cannot be used.
 787 
 788   // The last entry is the null entry.
 789   const size_t length = Flag::numFlags - 1;

 790 
 791   // Sort
 792   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
 793   for (size_t i = 0; i < length; i++) {
 794     array[i] = &flagTable[i];
 795   }
 796   qsort(array, length, sizeof(Flag*), compare_flags);
 797 
 798   // Print
 799   out->print_cr("[Global flags]");
 800   for (size_t i = 0; i < length; i++) {
 801     if (array[i]->is_unlocked()) {
 802       array[i]->print_on(out, withComments);
 803     }
 804   }
 805   FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
 806 }
src/share/vm/runtime/globals.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File