/* * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "jfr/jfrEvents.hpp" #include "jvm_io.h" #include "memory/allocation.inline.hpp" #include "runtime/arguments.hpp" #include "runtime/flags/jvmFlag.hpp" #include "runtime/flags/jvmFlagAccess.hpp" #include "runtime/flags/jvmFlagLookup.hpp" #include "runtime/globals_extension.hpp" #include "utilities/bitMap.hpp" #include "utilities/defaultStream.hpp" #include "utilities/stringUtils.hpp" static bool is_product_build() { #ifdef PRODUCT return true; #else return false; #endif } void JVMFlag::set_origin(JVMFlagOrigin new_origin) { int old_flags = _flags; int origin = static_cast(new_origin); assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity"); int was_in_cmdline = (new_origin == JVMFlagOrigin::COMMAND_LINE) ? WAS_SET_ON_COMMAND_LINE : 0; _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | origin | was_in_cmdline); if ((old_flags & WAS_SET_ON_COMMAND_LINE) != 0) { assert((_flags & WAS_SET_ON_COMMAND_LINE) != 0, "once initialized, should never change"); } } /** * Returns if this flag is a constant in the binary. Right now this is * true for develop flags in product builds. */ bool JVMFlag::is_constant_in_binary() const { #ifdef PRODUCT return is_develop(); #else return false; #endif } bool JVMFlag::is_unlocker() const { return strcmp(_name, "UnlockDiagnosticVMOptions") == 0 || strcmp(_name, "UnlockExperimentalVMOptions") == 0; } bool JVMFlag::is_unlocked() const { if (is_diagnostic()) { return UnlockDiagnosticVMOptions; } if (is_experimental()) { return UnlockExperimentalVMOptions; } return true; } void JVMFlag::clear_diagnostic() { assert(is_diagnostic(), "sanity"); _flags = Flags(_flags & ~KIND_DIAGNOSTIC); assert(!is_diagnostic(), "sanity"); } void JVMFlag::clear_experimental() { assert(is_experimental(), "sanity"); _flags = Flags(_flags & ~KIND_EXPERIMENTAL); assert(!is_experimental(), "sanity"); } void JVMFlag::set_product() { assert(!is_product(), "sanity"); _flags = Flags(_flags | KIND_PRODUCT); assert(is_product(), "sanity"); } // Get custom message for this locked flag, or null if // none is available. Returns message type produced. JVMFlag::MsgType JVMFlag::get_locked_message(char* buf, int buflen) const { buf[0] = '\0'; if (is_diagnostic() && !is_unlocked()) { jio_snprintf(buf, buflen, "Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n" "Error: The unlock option must precede '%s'.\n", _name, _name); return JVMFlag::DIAGNOSTIC_FLAG_BUT_LOCKED; } if (is_experimental() && !is_unlocked()) { jio_snprintf(buf, buflen, "Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n" "Error: The unlock option must precede '%s'.\n", _name, _name); return JVMFlag::EXPERIMENTAL_FLAG_BUT_LOCKED; } if (is_develop() && is_product_build()) { jio_snprintf(buf, buflen, "Error: VM option '%s' is develop and is available only in debug version of VM.\n", _name); return JVMFlag::DEVELOPER_FLAG_BUT_PRODUCT_BUILD; } return JVMFlag::NONE; } // Helper function for JVMFlag::print_on(). // Fills current line up to requested position. // Should the current position already be past the requested position, // one separator blank is enforced. static void fill_to_pos(outputStream* st, unsigned int req_pos) { if ((unsigned int)st->position() < req_pos) { st->fill_to(req_pos); // need to fill with blanks to reach req_pos } else { st->print(" "); // enforce blank separation. Previous field too long. } } void JVMFlag::print_on(outputStream* st, bool withComments, bool printRanges) const { // Don't print develop flags in a product build. if (is_constant_in_binary()) { return; } if (!printRanges) { // The command line options -XX:+PrintFlags* cause this function to be called // for each existing flag to print information pertinent to this flag. The data // is displayed in columnar form, with the following layout: // col1 - data type, right-justified // col2 - name, left-justified // col3 - ' =' double-char, leading space to align with possible '+=' // col4 - value left-justified // col5 - kind right-justified // col6 - origin left-justified // col7 - comments left-justified // // The column widths are fixed. They are defined such that, for most cases, // an eye-pleasing tabular output is created. // // Sample output: // bool ThreadPriorityVerbose = false {product} {default} // uintx ThresholdTolerance = 10 {product} {default} // size_t TLABSize = 0 {product} {default} // uintx SurvivorRatio = 8 {product} {default} // double InitialRAMPercentage = 1.562500 {product} {default} // ccstr CompileCommandFile = MyFile.cmd {product} {command line} // ccstrlist CompileOnly = Method1 // CompileOnly += Method2 {product} {command line} // | | | | | | | // | | | | | | +-- col7 // | | | | | +-- col6 // | | | | +-- col5 // | | | +-- col4 // | | +-- col3 // | +-- col2 // +-- col1 const unsigned int col_spacing = 1; const unsigned int col1_pos = 0; const unsigned int col1_width = 9; const unsigned int col2_pos = col1_pos + col1_width + col_spacing; const unsigned int col2_width = 39; const unsigned int col3_pos = col2_pos + col2_width + col_spacing; const unsigned int col3_width = 2; const unsigned int col4_pos = col3_pos + col3_width + col_spacing; const unsigned int col4_width = 30; const unsigned int col5_pos = col4_pos + col4_width + col_spacing; const unsigned int col5_width = 20; const unsigned int col6_pos = col5_pos + col5_width + col_spacing; const unsigned int col6_width = 15; const unsigned int col7_pos = col6_pos + col6_width + col_spacing; const unsigned int col7_width = 1; st->fill_to(col1_pos); st->print("%*s", col1_width, type_string()); // right-justified, therefore width is required. fill_to_pos(st, col2_pos); st->print("%s", _name); fill_to_pos(st, col3_pos); st->print(" ="); // use " =" for proper alignment with multiline ccstr output. fill_to_pos(st, col4_pos); if (is_bool()) { st->print("%s", get_bool() ? "true" : "false"); } else if (is_int()) { st->print("%d", get_int()); } else if (is_uint()) { st->print("%u", get_uint()); } else if (is_intx()) { st->print("%zd", get_intx()); } else if (is_uintx()) { st->print("%zu", get_uintx()); } else if (is_uint64_t()) { st->print(UINT64_FORMAT, get_uint64_t()); } else if (is_size_t()) { st->print("%zu", get_size_t()); } else if (is_double()) { st->print("%f", get_double()); } else if (is_ccstr()) { // Honor characters in ccstr: print multiple lines. const char* cp = get_ccstr(); if (cp != nullptr) { const char* eol; while ((eol = strchr(cp, '\n')) != nullptr) { size_t llen = pointer_delta(eol, cp, sizeof(char)); st->print("%.*s", (int)llen, cp); st->cr(); cp = eol+1; fill_to_pos(st, col2_pos); st->print("%s", _name); fill_to_pos(st, col3_pos); st->print("+="); fill_to_pos(st, col4_pos); } st->print("%s", cp); } } else { st->print("unhandled type %s", type_string()); st->cr(); return; } fill_to_pos(st, col5_pos); print_kind(st, col5_width); fill_to_pos(st, col6_pos); print_origin(st, col6_width); #ifndef PRODUCT if (withComments) { fill_to_pos(st, col7_pos); st->print("%s", _doc); } #endif st->cr(); } else if (!is_bool() && !is_ccstr()) { // The command line options -XX:+PrintFlags* cause this function to be called // for each existing flag to print information pertinent to this flag. The data // is displayed in columnar form, with the following layout: // col1 - data type, right-justified // col2 - name, left-justified // col4 - range [ min ... max] // col5 - kind right-justified // col6 - origin left-justified // col7 - comments left-justified // // The column widths are fixed. They are defined such that, for most cases, // an eye-pleasing tabular output is created. // // Sample output: // intx MinPassesBeforeFlush [ 0 ... 9223372036854775807 ] {diagnostic} {default} // double MinRAMPercentage [ 0.000 ... 100.000 ] {product} {default} // uintx MinSurvivorRatio [ 3 ... 18446744073709551615 ] {product} {default} // size_t MinTLABSize [ 1 ... 9223372036854775807 ] {product} {default} // intx MaxInlineSize [ 0 ... 2147483647 ] {product} {default} // | | | | | | // | | | | | +-- col7 // | | | | +-- col6 // | | | +-- col5 // | | +-- col4 // | +-- col2 // +-- col1 const unsigned int col_spacing = 1; const unsigned int col1_pos = 0; const unsigned int col1_width = 9; const unsigned int col2_pos = col1_pos + col1_width + col_spacing; const unsigned int col2_width = 49; const unsigned int col3_pos = col2_pos + col2_width + col_spacing; const unsigned int col3_width = 0; const unsigned int col4_pos = col3_pos + col3_width + col_spacing; const unsigned int col4_width = 60; const unsigned int col5_pos = col4_pos + col4_width + col_spacing; const unsigned int col5_width = 35; const unsigned int col6_pos = col5_pos + col5_width + col_spacing; const unsigned int col6_width = 15; const unsigned int col7_pos = col6_pos + col6_width + col_spacing; const unsigned int col7_width = 1; st->fill_to(col1_pos); st->print("%*s", col1_width, type_string()); // right-justified, therefore width is required. fill_to_pos(st, col2_pos); st->print("%s", _name); fill_to_pos(st, col4_pos); JVMFlagAccess::print_range(st, this); fill_to_pos(st, col5_pos); print_kind(st, col5_width); fill_to_pos(st, col6_pos); print_origin(st, col6_width); #ifndef PRODUCT if (withComments) { fill_to_pos(st, col7_pos); st->print("%s", _doc); } #endif st->cr(); } } void JVMFlag::print_kind(outputStream* st, unsigned int width) const { struct Data { int flag; const char* name; }; Data data[] = { { KIND_JVMCI, "JVMCI" }, { KIND_C1, "C1" }, { KIND_C2, "C2" }, { KIND_ARCH, "ARCH" }, { KIND_PLATFORM_DEPENDENT, "pd" }, { KIND_PRODUCT, "product" }, { KIND_MANAGEABLE, "manageable" }, { KIND_DIAGNOSTIC, "diagnostic" }, { KIND_EXPERIMENTAL, "experimental" }, { KIND_DEVELOP, "develop" }, { KIND_LP64_PRODUCT, "lp64_product" }, { -1, "" } }; if ((_flags & KIND_MASK) != 0) { bool is_first = true; const size_t buffer_size = 64; size_t buffer_used = 0; char kind[buffer_size]; jio_snprintf(kind, buffer_size, "{"); buffer_used++; for (int i = 0; data[i].flag != -1; i++) { Data d = data[i]; if ((_flags & d.flag) != 0) { if (is_first) { is_first = false; } else { assert(buffer_used + 1 < buffer_size, "Too small buffer"); jio_snprintf(kind + buffer_used, buffer_size - buffer_used, " "); buffer_used++; } size_t length = strlen(d.name); assert(buffer_used + length < buffer_size, "Too small buffer"); jio_snprintf(kind + buffer_used, buffer_size - buffer_used, "%s", d.name); buffer_used += length; } } assert(buffer_used + 2 <= buffer_size, "Too small buffer"); jio_snprintf(kind + buffer_used, buffer_size - buffer_used, "}"); st->print("%*s", width, kind); } } void JVMFlag::print_origin(outputStream* st, unsigned int width) const { st->print("{"); switch(get_origin()) { case JVMFlagOrigin::DEFAULT: st->print("default"); break; case JVMFlagOrigin::COMMAND_LINE: st->print("command line"); break; case JVMFlagOrigin::ENVIRON_VAR: st->print("environment"); break; case JVMFlagOrigin::CONFIG_FILE: st->print("config file"); break; case JVMFlagOrigin::MANAGEMENT: st->print("management"); break; case JVMFlagOrigin::ERGONOMIC: if (_flags & WAS_SET_ON_COMMAND_LINE) { st->print("command line, "); } st->print("ergonomic"); break; case JVMFlagOrigin::ATTACH_ON_DEMAND: st->print("attach"); break; case JVMFlagOrigin::INTERNAL: st->print("internal"); break; case JVMFlagOrigin::JIMAGE_RESOURCE: st->print("jimage"); break; } st->print("}"); } void JVMFlag::print_as_flag(outputStream* st) const { if (is_bool()) { st->print("-XX:%s%s", get_bool() ? "+" : "-", _name); } else if (is_int()) { st->print("-XX:%s=%d", _name, get_int()); } else if (is_uint()) { st->print("-XX:%s=%u", _name, get_uint()); } else if (is_intx()) { st->print("-XX:%s=%zd", _name, get_intx()); } else if (is_uintx()) { st->print("-XX:%s=%zu", _name, get_uintx()); } else if (is_uint64_t()) { st->print("-XX:%s=" UINT64_FORMAT, _name, get_uint64_t()); } else if (is_size_t()) { st->print("-XX:%s=%zu", _name, get_size_t()); } else if (is_double()) { st->print("-XX:%s=%f", _name, get_double()); } else if (is_ccstr()) { st->print("-XX:%s=", _name); const char* cp = get_ccstr(); if (cp != nullptr) { // Need to turn embedded '\n's back into separate arguments // Not so efficient to print one character at a time, // but the choice is to do the transformation to a buffer // and print that. And this need not be efficient. for (; *cp != '\0'; cp += 1) { switch (*cp) { default: st->print("%c", *cp); break; case '\n': st->print(" -XX:%s=", _name); break; } } } } else { ShouldNotReachHere(); } } //---------------------------------------------------------------------- // Build flagTable[] // Find out the number of LP64/ARCH/JVMCI/COMPILER1/COMPILER2 flags, // for JVMFlag::flag_group() #define ENUM_F(type, name, ...) enum_##name, #define IGNORE_F(...) // dev dev-pd pro pro-pd range constraint enum FlagCounter_LP64 { LP64_RUNTIME_FLAGS( ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F) num_flags_LP64 }; enum FlagCounter_ARCH { ARCH_FLAGS( ENUM_F, ENUM_F, IGNORE_F, IGNORE_F) num_flags_ARCH }; enum FlagCounter_JVMCI { JVMCI_ONLY(JVMCI_FLAGS( ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F)) num_flags_JVMCI }; enum FlagCounter_C1 { COMPILER1_PRESENT(C1_FLAGS(ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F)) num_flags_C1 }; enum FlagCounter_C2 { COMPILER2_PRESENT(C2_FLAGS(ENUM_F, ENUM_F, ENUM_F, ENUM_F, IGNORE_F, IGNORE_F)) num_flags_C2 }; const int first_flag_enum_LP64 = 0; const int first_flag_enum_ARCH = first_flag_enum_LP64 + num_flags_LP64; const int first_flag_enum_JVMCI = first_flag_enum_ARCH + num_flags_ARCH; const int first_flag_enum_C1 = first_flag_enum_JVMCI + num_flags_JVMCI; const int first_flag_enum_C2 = first_flag_enum_C1 + num_flags_C1; const int first_flag_enum_other = first_flag_enum_C2 + num_flags_C2; static constexpr int flag_group(int flag_enum) { if (flag_enum < first_flag_enum_ARCH) return JVMFlag::KIND_LP64_PRODUCT; if (flag_enum < first_flag_enum_JVMCI) return JVMFlag::KIND_ARCH; if (flag_enum < first_flag_enum_C1) return JVMFlag::KIND_JVMCI; if (flag_enum < first_flag_enum_C2) return JVMFlag::KIND_C1; if (flag_enum < first_flag_enum_other) return JVMFlag::KIND_C2; return 0; } constexpr JVMFlag::JVMFlag(int flag_enum, FlagType type, const char* name, void* addr, int flags, int extra_flags, const char* doc) : _addr(addr), _name(name), _flags(), _type(type) NOT_PRODUCT(COMMA _doc(doc)) { flags = flags | extra_flags | static_cast(JVMFlagOrigin::DEFAULT) | flag_group(flag_enum); if ((flags & JVMFlag::KIND_PRODUCT) != 0) { if (flags & (JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL)) { // Backwards compatibility. This will be relaxed in JDK-7123237. flags &= ~(JVMFlag::KIND_PRODUCT); } } _flags = static_cast(flags); } constexpr JVMFlag::JVMFlag(int flag_enum, FlagType type, const char* name, void* addr, int flags, const char* doc) : JVMFlag(flag_enum, type, name, addr, flags, /*extra_flags*/0, doc) {} const int PRODUCT_KIND = JVMFlag::KIND_PRODUCT; const int PRODUCT_KIND_PD = JVMFlag::KIND_PRODUCT | JVMFlag::KIND_PLATFORM_DEPENDENT; const int DEVELOP_KIND = JVMFlag::KIND_DEVELOP; const int DEVELOP_KIND_PD = JVMFlag::KIND_DEVELOP | JVMFlag::KIND_PLATFORM_DEPENDENT; #define FLAG_TYPE(type) (JVMFlag::TYPE_ ## type) #define INITIALIZE_DEVELOP_FLAG( type, name, value, ...) JVMFlag(FLAG_MEMBER_ENUM(name), FLAG_TYPE(type), XSTR(name), (void*)&name, DEVELOP_KIND, __VA_ARGS__), #define INITIALIZE_DEVELOP_FLAG_PD(type, name, ...) JVMFlag(FLAG_MEMBER_ENUM(name), FLAG_TYPE(type), XSTR(name), (void*)&name, DEVELOP_KIND_PD, __VA_ARGS__), #define INITIALIZE_PRODUCT_FLAG( type, name, value, ...) JVMFlag(FLAG_MEMBER_ENUM(name), FLAG_TYPE(type), XSTR(name), (void*)&name, PRODUCT_KIND, __VA_ARGS__), #define INITIALIZE_PRODUCT_FLAG_PD(type, name, ...) JVMFlag(FLAG_MEMBER_ENUM(name), FLAG_TYPE(type), XSTR(name), (void*)&name, PRODUCT_KIND_PD, __VA_ARGS__), // Handy aliases to match the symbols used in the flag specification macros. const int DIAGNOSTIC = JVMFlag::KIND_DIAGNOSTIC; const int MANAGEABLE = JVMFlag::KIND_MANAGEABLE; const int EXPERIMENTAL = JVMFlag::KIND_EXPERIMENTAL; #define MATERIALIZE_ALL_FLAGS \ ALL_FLAGS(INITIALIZE_DEVELOP_FLAG, \ INITIALIZE_DEVELOP_FLAG_PD, \ INITIALIZE_PRODUCT_FLAG, \ INITIALIZE_PRODUCT_FLAG_PD, \ IGNORE_RANGE, \ IGNORE_CONSTRAINT) static JVMFlag flagTable[NUM_JVMFlagsEnum + 1] = { MATERIALIZE_ALL_FLAGS JVMFlag() // The iteration code wants a flag with a null name at the end of the table. }; // We want flagTable[] to be completely initialized at C++ compilation time, which requires // that all arguments passed to JVMFlag() constructors be constexpr. The following line // checks for this -- if any non-constexpr arguments are passed, the C++ compiler will // generate an error. // // constexpr implies internal linkage. This means the flagTable_verify_constexpr[] variable // will not be included in jvmFlag.o, so there's no footprint cost for having this variable. // // Note that we cannot declare flagTable[] as constexpr because JVMFlag::_flags is modified // at runtime. constexpr JVMFlag flagTable_verify_constexpr[] = { MATERIALIZE_ALL_FLAGS }; JVMFlag* JVMFlag::flags = flagTable; size_t JVMFlag::numFlags = (sizeof(flagTable) / sizeof(JVMFlag)); #define JVM_FLAG_TYPE_SIGNATURE(t) JVMFlag::type_signature(), const int JVMFlag::type_signatures[] = { JVM_FLAG_NON_STRING_TYPES_DO(JVM_FLAG_TYPE_SIGNATURE) JVMFlag::type_signature(), JVMFlag::type_signature() }; // Search the flag table for a named flag JVMFlag* JVMFlag::find_flag(const char* name, size_t length, bool allow_locked, bool return_flag) { JVMFlag* flag = JVMFlagLookup::find(name, length); if (flag != nullptr) { // Found a matching entry. // Don't report develop flags in product builds. if (flag->is_constant_in_binary()) { return (return_flag ? flag : nullptr); } // Report locked flags only if allowed. if (!(flag->is_unlocked() || flag->is_unlocker())) { if (!allow_locked) { // disable use of locked flags, e.g. diagnostic, experimental, // etc. until they are explicitly unlocked return nullptr; } } return flag; } // JVMFlag name is not in the flag table return nullptr; } JVMFlag* JVMFlag::fuzzy_match(const char* name, size_t length, bool allow_locked) { double VMOptionsFuzzyMatchSimilarity = 0.7; JVMFlag* match = nullptr; double score; double max_score = -1; for (JVMFlag* current = &flagTable[0]; current->_name != nullptr; current++) { score = StringUtils::similarity(current->_name, strlen(current->_name), name, length); if (score > max_score) { max_score = score; match = current; } } if (match == nullptr) { return nullptr; } if (!(match->is_unlocked() || match->is_unlocker())) { if (!allow_locked) { return nullptr; } } if (max_score < VMOptionsFuzzyMatchSimilarity) { return nullptr; } return match; } bool JVMFlag::is_default(JVMFlagsEnum flag) { return flag_from_enum(flag)->is_default(); } bool JVMFlag::is_ergo(JVMFlagsEnum flag) { return flag_from_enum(flag)->is_ergonomic(); } bool JVMFlag::is_cmdline(JVMFlagsEnum flag) { return flag_from_enum(flag)->is_command_line(); } bool JVMFlag::is_jimage_resource(JVMFlagsEnum flag) { return flag_from_enum(flag)->is_jimage_resource(); } void JVMFlag::setOnCmdLine(JVMFlagsEnum flag) { flag_from_enum(flag)->set_command_line(); } extern "C" { static int compare_flags(const void* void_a, const void* void_b) { return strcmp((*((JVMFlag**) void_a))->name(), (*((JVMFlag**) void_b))->name()); } } void JVMFlag::printSetFlags(outputStream* out) { // Print which flags were set on the command line // note: this method is called before the thread structure is in place // which means resource allocation cannot be used. // The last entry is the null entry. const size_t length = JVMFlag::numFlags - 1; // Sort JVMFlag** array = NEW_C_HEAP_ARRAY(JVMFlag*, length, mtArguments); for (size_t i = 0; i < length; i++) { array[i] = &flagTable[i]; } qsort(array, length, sizeof(JVMFlag*), compare_flags); // Print for (size_t i = 0; i < length; i++) { if (array[i]->get_origin() != JVMFlagOrigin::DEFAULT) { array[i]->print_as_flag(out); out->print(" "); } } out->cr(); FREE_C_HEAP_ARRAY(JVMFlag*, array); } #ifndef PRODUCT void JVMFlag::verify() { assert(Arguments::check_vm_args_consistency(), "Some flag settings conflict"); } #endif // PRODUCT #ifdef ASSERT void JVMFlag::assert_valid_flag_enum(JVMFlagsEnum i) { assert(0 <= int(i) && int(i) < NUM_JVMFlagsEnum, "must be"); } void JVMFlag::check_all_flag_declarations() { for (JVMFlag* current = &flagTable[0]; current->_name != nullptr; current++) { int flags = static_cast(current->_flags); // Backwards compatibility. This will be relaxed/removed in JDK-7123237. int mask = JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL; if ((flags & mask) != 0) { assert((flags & mask) == JVMFlag::KIND_DIAGNOSTIC || (flags & mask) == JVMFlag::KIND_MANAGEABLE || (flags & mask) == JVMFlag::KIND_EXPERIMENTAL, "%s can be declared with at most one of " "DIAGNOSTIC, MANAGEABLE or EXPERIMENTAL", current->_name); assert((flags & KIND_DEVELOP) == 0, "%s has an optional DIAGNOSTIC, MANAGEABLE or EXPERIMENTAL " "attribute; it must be declared as a product flag", current->_name); } } } #endif // ASSERT void JVMFlag::printFlags(outputStream* out, bool withComments, bool printRanges, bool skipDefaults) { // Print the flags sorted by name // Note: This method may be called before the thread structure is in place // which means resource allocation cannot be used. Also, it may be // called as part of error reporting, so handle native OOMs gracefully. // The last entry is the null entry. constexpr size_t length = (sizeof(flagTable) / sizeof(JVMFlag)) - 1; // Print if (!printRanges) { out->print_cr("[Global flags]"); } else { out->print_cr("[Global flags ranges]"); } BitMap::bm_word_t iteratorArray[BitMap::calc_size_in_words(length)]; BitMapView iteratorMarkers(iteratorArray, length); iteratorMarkers.clear_range(0, length); // Print the flag with best sort value, then mark it. for (size_t j = 0; j < length; j++) { JVMFlag* bestFlag = nullptr; size_t bestFlagIndex = 0; for (size_t i = 0; i < length; i++) { const bool skip = (skipDefaults && flagTable[i].is_default()); const bool visited = iteratorMarkers.at(i); if (!visited && flagTable[i].is_unlocked() && !skip) { if ((bestFlag == nullptr) || (strcmp(bestFlag->name(), flagTable[i].name()) > 0)) { bestFlag = &flagTable[i]; bestFlagIndex = i; } } } if (bestFlag != nullptr) { bestFlag->print_on(out, withComments, printRanges); iteratorMarkers.at_put(bestFlagIndex, true); } } } void JVMFlag::printError(bool verbose, const char* msg, ...) { if (verbose) { va_list listPointer; va_start(listPointer, msg); jio_vfprintf(defaultStream::error_stream(), msg, listPointer); va_end(listPointer); } }