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_EXPERIMENTAL, "experimental" },
 325       { KIND_COMMERCIAL, "commercial" },
 326       { KIND_NOT_PRODUCT, "notproduct" },
 327       { KIND_DEVELOP, "develop" },
 328       { KIND_LP64_PRODUCT, "lp64_product" },
 329       { KIND_READ_WRITE, "rw" },
 330       { -1, "" }
 331   };
 332 
 333   if ((_flags & KIND_MASK) != 0) {
 334     st->print("{");
 335     bool is_first = true;
 336 
 337     for (int i = 0; data[i].flag != -1; i++) {
 338       Data d = data[i];
 339       if ((_flags & d.flag) != 0) {
 340         if (is_first) {
 341           is_first = false;
 342         } else {
 343           st->print(" ");
 344         }
 345         st->print(d.name);
 346       }
 347     }
 348 
 349     st->print("}");
 350   }
 351 }
 352 
 353 void Flag::print_as_flag(outputStream* st) {
 354   if (is_bool()) {
 355     st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
 356   } else if (is_intx()) {
 357     st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
 358   } else if (is_uintx()) {
 359     st->print("-XX:%s=" UINTX_FORMAT, _name, get_uintx());
 360   } else if (is_uint64_t()) {
 361     st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t());
 362   } else if (is_double()) {
 363     st->print("-XX:%s=%f", _name, get_double());
 364   } else if (is_ccstr()) {
 365     st->print("-XX:%s=", _name);
 366     const char* cp = get_ccstr();
 367     if (cp != NULL) {
 368       // Need to turn embedded '\n's back into separate arguments
 369       // Not so efficient to print one character at a time,
 370       // but the choice is to do the transformation to a buffer
 371       // and print that.  And this need not be efficient.
 372       for (; *cp != '\0'; cp += 1) {
 373         switch (*cp) {
 374           default:
 375             st->print("%c", *cp);
 376             break;
 377           case '\n':
 378             st->print(" -XX:%s=", _name);
 379             break;
 380         }
 381       }
 382     }
 383   } else {
 384     ShouldNotReachHere();
 385   }
 386 }
 387 
 388 // 4991491 do not "optimize out" the was_set false values: omitting them
 389 // tickles a Microsoft compiler bug causing flagTable to be malformed
 390 
 391 #define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)
 392 
 393 #define RUNTIME_PRODUCT_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) },
 394 #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) },
 395 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) },
 396 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) },
 397 #define RUNTIME_MANAGEABLE_FLAG_STRUCT(  type, name, value, doc) { #type, XSTR(name), &name,      NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) },
 398 #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) },
 399 #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) },
 400 #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) },
 401 #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) },
 402 
 403 #ifdef _LP64
 404 #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) },
 405 #else
 406 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
 407 #endif // _LP64
 408 
 409 #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) },
 410 #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) },
 411 #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) },
 412 #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) },
 413 #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) },
 414 #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) },
 415 
 416 #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) },
 417 #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) },
 418 #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) },
 419 #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) },
 420 #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) },
 421 #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) },
 422 #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) },
 423 
 424 #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) },
 425 #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) },
 426 #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) },
 427 #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) },
 428 #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) },
 429 
 430 #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) },
 431 #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) },
 432 #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) },
 433 #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) },
 434 #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) },
 435 #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) },
 436 
 437 static Flag flagTable[] = {
 438  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)
 439  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)
 440 #if INCLUDE_ALL_GCS
 441  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)
 442 #endif // INCLUDE_ALL_GCS
 443 #ifdef COMPILER1
 444  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)
 445 #endif
 446 #ifdef COMPILER2
 447  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)
 448 #endif
 449 #ifdef SHARK
 450  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)
 451 #endif
 452  ARCH_FLAGS(ARCH_DEVELOP_FLAG_STRUCT, ARCH_PRODUCT_FLAG_STRUCT, ARCH_DIAGNOSTIC_FLAG_STRUCT, ARCH_EXPERIMENTAL_FLAG_STRUCT, ARCH_NOTPRODUCT_FLAG_STRUCT)
 453  FLAGTABLE_EXT
 454  {0, NULL, NULL}
 455 };
 456 
 457 Flag* Flag::flags = flagTable;
 458 size_t Flag::numFlags = (sizeof(flagTable) / sizeof(Flag));
 459 
 460 inline bool str_equal(const char* s, const char* q, size_t len) {
 461   // s is null terminated, q is not!
 462   if (strlen(s) != (unsigned int) len) return false;
 463   return strncmp(s, q, len) == 0;
 464 }
 465 
 466 // Search the flag table for a named flag
 467 Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) {
 468   for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
 469     if (str_equal(current->_name, name, length)) {
 470       // Found a matching entry.
 471       // Don't report notproduct and develop flags in product builds.
 472       if (current->is_constant_in_binary()) {
 473         return NULL;
 474       }
 475       // Report locked flags only if allowed.
 476       if (!(current->is_unlocked() || current->is_unlocker())) {
 477         if (!allow_locked) {
 478           // disable use of locked flags, e.g. diagnostic, experimental,
 479           // commercial... until they are explicitly unlocked
 480           return NULL;
 481         }
 482       }
 483       return current;
 484     }
 485   }
 486   // Flag name is not in the flag table
 487   return NULL;
 488 }
 489 
 490 // Compute string similarity based on Dice's coefficient
 491 static float str_similar(const char* str1, const char* str2, size_t len2) {
 492   int len1 = (int) strlen(str1);
 493   int total = len1 + (int) len2;
 494 
 495   int hit = 0;
 496 
 497   for (int i = 0; i < len1 -1; ++i) {
 498     for (int j = 0; j < (int) len2 -1; ++j) {
 499       if ((str1[i] == str2[j]) && (str1[i+1] == str2[j+1])) {
 500         ++hit;
 501         break;
 502       }
 503     }
 504   }
 505 
 506   return 2.0f * (float) hit / (float) total;
 507 }
 508 
 509 Flag* Flag::fuzzy_match(const char* name, size_t length, bool allow_locked) {
 510   float VMOptionsFuzzyMatchSimilarity = 0.7f;
 511   Flag* match = NULL;
 512   float score;
 513   float max_score = -1;
 514 
 515   for (Flag* current = &flagTable[0]; current->_name != NULL; current++) {
 516     score = str_similar(current->_name, name, length);
 517     if (score > max_score) {
 518       max_score = score;
 519       match = current;
 520     }
 521   }
 522 
 523   if (!(match->is_unlocked() || match->is_unlocker())) {
 524     if (!allow_locked) {
 525       return NULL;
 526     }
 527   }
 528 
 529   if (max_score < VMOptionsFuzzyMatchSimilarity) {
 530     return NULL;
 531   }
 532 
 533   return match;
 534 }
 535 
 536 // Returns the address of the index'th element
 537 static Flag* address_of_flag(CommandLineFlagWithType flag) {
 538   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 539   return &Flag::flags[flag];
 540 }
 541 
 542 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
 543   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 544   Flag* f = &Flag::flags[flag];
 545   return f->is_default();
 546 }
 547 
 548 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
 549   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 550   Flag* f = &Flag::flags[flag];
 551   return f->is_ergonomic();
 552 }
 553 
 554 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
 555   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 556   Flag* f = &Flag::flags[flag];
 557   return f->is_command_line();
 558 }
 559 
 560 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
 561   Flag* result = Flag::find_flag((char*)name, strlen(name));
 562   if (result == NULL) return false;
 563   *value = result->is_command_line();
 564   return true;
 565 }
 566 
 567 bool CommandLineFlags::boolAt(char* name, size_t len, bool* value) {
 568   Flag* result = Flag::find_flag(name, len);
 569   if (result == NULL) return false;
 570   if (!result->is_bool()) return false;
 571   *value = result->get_bool();
 572   return true;
 573 }
 574 
 575 bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) {
 576   Flag* result = Flag::find_flag(name, len);
 577   if (result == NULL) return false;
 578   if (!result->is_bool()) return false;
 579   bool old_value = result->get_bool();
 580   result->set_bool(*value);
 581   *value = old_value;
 582   result->set_origin(origin);
 583   return true;
 584 }
 585 
 586 void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
 587   Flag* faddr = address_of_flag(flag);
 588   guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
 589   faddr->set_bool(value);
 590   faddr->set_origin(origin);
 591 }
 592 
 593 bool CommandLineFlags::intxAt(char* name, size_t len, intx* value) {
 594   Flag* result = Flag::find_flag(name, len);
 595   if (result == NULL) return false;
 596   if (!result->is_intx()) return false;
 597   *value = result->get_intx();
 598   return true;
 599 }
 600 
 601 bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) {
 602   Flag* result = Flag::find_flag(name, len);
 603   if (result == NULL) return false;
 604   if (!result->is_intx()) return false;
 605   intx old_value = result->get_intx();
 606   result->set_intx(*value);
 607   *value = old_value;
 608   result->set_origin(origin);
 609   return true;
 610 }
 611 
 612 void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
 613   Flag* faddr = address_of_flag(flag);
 614   guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
 615   faddr->set_intx(value);
 616   faddr->set_origin(origin);
 617 }
 618 
 619 bool CommandLineFlags::uintxAt(char* name, size_t len, uintx* value) {
 620   Flag* result = Flag::find_flag(name, len);
 621   if (result == NULL) return false;
 622   if (!result->is_uintx()) return false;
 623   *value = result->get_uintx();
 624   return true;
 625 }
 626 
 627 bool CommandLineFlags::uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin) {
 628   Flag* result = Flag::find_flag(name, len);
 629   if (result == NULL) return false;
 630   if (!result->is_uintx()) return false;
 631   uintx old_value = result->get_uintx();
 632   result->set_uintx(*value);
 633   *value = old_value;
 634   result->set_origin(origin);
 635   return true;
 636 }
 637 
 638 void CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
 639   Flag* faddr = address_of_flag(flag);
 640   guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
 641   faddr->set_uintx(value);
 642   faddr->set_origin(origin);
 643 }
 644 
 645 bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) {
 646   Flag* result = Flag::find_flag(name, len);
 647   if (result == NULL) return false;
 648   if (!result->is_uint64_t()) return false;
 649   *value = result->get_uint64_t();
 650   return true;
 651 }
 652 
 653 bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) {
 654   Flag* result = Flag::find_flag(name, len);
 655   if (result == NULL) return false;
 656   if (!result->is_uint64_t()) return false;
 657   uint64_t old_value = result->get_uint64_t();
 658   result->set_uint64_t(*value);
 659   *value = old_value;
 660   result->set_origin(origin);
 661   return true;
 662 }
 663 
 664 void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
 665   Flag* faddr = address_of_flag(flag);
 666   guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
 667   faddr->set_uint64_t(value);
 668   faddr->set_origin(origin);
 669 }
 670 
 671 bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) {
 672   Flag* result = Flag::find_flag(name, len);
 673   if (result == NULL) return false;
 674   if (!result->is_double()) return false;
 675   *value = result->get_double();
 676   return true;
 677 }
 678 
 679 bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) {
 680   Flag* result = Flag::find_flag(name, len);
 681   if (result == NULL) return false;
 682   if (!result->is_double()) return false;
 683   double old_value = result->get_double();
 684   result->set_double(*value);
 685   *value = old_value;
 686   result->set_origin(origin);
 687   return true;
 688 }
 689 
 690 void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
 691   Flag* faddr = address_of_flag(flag);
 692   guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
 693   faddr->set_double(value);
 694   faddr->set_origin(origin);
 695 }
 696 
 697 bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
 698   Flag* result = Flag::find_flag(name, len);
 699   if (result == NULL) return false;
 700   if (!result->is_ccstr()) return false;
 701   *value = result->get_ccstr();
 702   return true;
 703 }
 704 
 705 // Contract:  Flag will make private copy of the incoming value.
 706 // Outgoing value is always malloc-ed, and caller MUST call free.
 707 bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) {
 708   Flag* result = Flag::find_flag(name, len);
 709   if (result == NULL) return false;
 710   if (!result->is_ccstr()) return false;
 711   ccstr old_value = result->get_ccstr();
 712   char* new_value = NULL;
 713   if (*value != NULL) {
 714     new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal);
 715     strcpy(new_value, *value);
 716   }
 717   result->set_ccstr(new_value);
 718   if (result->is_default() && old_value != NULL) {
 719     // Prior value is NOT heap allocated, but was a literal constant.
 720     char* old_value_to_free = NEW_C_HEAP_ARRAY(char, strlen(old_value)+1, mtInternal);
 721     strcpy(old_value_to_free, old_value);
 722     old_value = old_value_to_free;
 723   }
 724   *value = old_value;
 725   result->set_origin(origin);
 726   return true;
 727 }
 728 
 729 // Contract:  Flag will make private copy of the incoming value.
 730 void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
 731   Flag* faddr = address_of_flag(flag);
 732   guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
 733   ccstr old_value = faddr->get_ccstr();
 734   char* new_value = NEW_C_HEAP_ARRAY(char, strlen(value)+1, mtInternal);
 735   strcpy(new_value, value);
 736   faddr->set_ccstr(new_value);
 737   if (!faddr->is_default() && old_value != NULL) {
 738     // Prior value is heap allocated so free it.
 739     FREE_C_HEAP_ARRAY(char, old_value, mtInternal);
 740   }
 741   faddr->set_origin(origin);
 742 }
 743 
 744 extern "C" {
 745   static int compare_flags(const void* void_a, const void* void_b) {
 746     return strcmp((*((Flag**) void_a))->_name, (*((Flag**) void_b))->_name);
 747   }
 748 }
 749 
 750 void CommandLineFlags::printSetFlags(outputStream* out) {
 751   // Print which flags were set on the command line
 752   // note: this method is called before the thread structure is in place
 753   //       which means resource allocation cannot be used.
 754 
 755   // The last entry is the null entry.
 756   const size_t length = Flag::numFlags - 1;
 757 
 758   // Sort
 759   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
 760   for (size_t i = 0; i < length; i++) {
 761     array[i] = &flagTable[i];
 762   }
 763   qsort(array, length, sizeof(Flag*), compare_flags);
 764 
 765   // Print
 766   for (size_t i = 0; i < length; i++) {
 767     if (array[i]->get_origin() /* naked field! */) {
 768       array[i]->print_as_flag(out);
 769       out->print(" ");
 770     }
 771   }
 772   out->cr();
 773   FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
 774 }
 775 
 776 #ifndef PRODUCT
 777 
 778 
 779 void CommandLineFlags::verify() {
 780   assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict");
 781 }
 782 
 783 #endif // PRODUCT
 784 
 785 void CommandLineFlags::printFlags(outputStream* out, bool withComments) {
 786   // Print the flags sorted by name
 787   // note: this method is called before the thread structure is in place
 788   //       which means resource allocation cannot be used.
 789 
 790   // The last entry is the null entry.
 791   const size_t length = Flag::numFlags - 1;
 792 
 793   // Sort
 794   Flag** array = NEW_C_HEAP_ARRAY(Flag*, length, mtInternal);
 795   for (size_t i = 0; i < length; i++) {
 796     array[i] = &flagTable[i];
 797   }
 798   qsort(array, length, sizeof(Flag*), compare_flags);
 799 
 800   // Print
 801   out->print_cr("[Global flags]");
 802   for (size_t i = 0; i < length; i++) {
 803     if (array[i]->is_unlocked()) {
 804       array[i]->print_on(out, withComments);
 805     }
 806   }
 807   FREE_C_HEAP_ARRAY(Flag*, array, mtInternal);
 808 }