1 /*
   2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "oops/oop.inline.hpp"
  28 #include "runtime/arguments.hpp"
  29 #include "runtime/globals.hpp"
  30 #include "runtime/globals_extension.hpp"
  31 #include "utilities/ostream.hpp"
  32 #include "utilities/macros.hpp"
  33 #include "utilities/top.hpp"
  34 #if INCLUDE_ALL_GCS
  35 #include "gc_implementation/g1/g1_globals.hpp"
  36 #endif // INCLUDE_ALL_GCS
  37 #ifdef COMPILER1
  38 #include "c1/c1_globals.hpp"
  39 #endif
  40 #ifdef COMPILER2
  41 #include "opto/c2_globals.hpp"
  42 #endif
  43 #ifdef SHARK
  44 #include "shark/shark_globals.hpp"
  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 }