/*

 * Copyright (c) 1997, 2016, 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 "precompiled.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/javaAssertions.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/symbolTable.hpp"

#include "code/codeCacheExtensions.hpp"

#include "gc/shared/cardTableRS.hpp"

#include "gc/shared/genCollectedHeap.hpp"

#include "gc/shared/referenceProcessor.hpp"

#include "gc/shared/taskqueue.hpp"

#include "logging/log.hpp"

#include "logging/logTag.hpp"

#include "logging/logConfiguration.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/universe.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/arguments.hpp"

#include "runtime/arguments_ext.hpp"

#include "runtime/commandLineFlagConstraintList.hpp"

#include "runtime/commandLineFlagWriteableList.hpp"

#include "runtime/commandLineFlagRangeList.hpp"

#include "runtime/globals.hpp"

#include "runtime/globals_extension.hpp"

#include "runtime/java.hpp"

#include "runtime/os.hpp"

#include "runtime/vm_version.hpp"

#include "services/management.hpp"

#include "services/memTracker.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/macros.hpp"

#include "utilities/stringUtils.hpp"

#if INCLUDE_JVMCI

#include "jvmci/jvmciRuntime.hpp"

#endif

#if INCLUDE_ALL_GCS

#include "gc/cms/compactibleFreeListSpace.hpp"

#include "gc/g1/g1CollectedHeap.inline.hpp"

#include "gc/parallel/parallelScavengeHeap.hpp"

#endif // INCLUDE_ALL_GCS

// Note: This is a special bug reporting site for the JVM

#define DEFAULT_VENDOR_URL_BUG "http://bugreport.java.com/bugreport/crash.jsp"

#define DEFAULT_JAVA_LAUNCHER  "generic"

char*  Arguments::_jvm_flags_file               = NULL;

char** Arguments::_jvm_flags_array              = NULL;

int    Arguments::_num_jvm_flags                = 0;

char** Arguments::_jvm_args_array               = NULL;

int    Arguments::_num_jvm_args                 = 0;

char*  Arguments::_java_command                 = NULL;

SystemProperty* Arguments::_system_properties   = NULL;

const char*  Arguments::_gc_log_filename        = NULL;

bool   Arguments::_has_profile                  = false;

size_t Arguments::_conservative_max_heap_alignment = 0;

size_t Arguments::_min_heap_size                = 0;

Arguments::Mode Arguments::_mode                = _mixed;

bool   Arguments::_java_compiler                = false;

bool   Arguments::_xdebug_mode                  = false;

const char*  Arguments::_java_vendor_url_bug    = DEFAULT_VENDOR_URL_BUG;

const char*  Arguments::_sun_java_launcher      = DEFAULT_JAVA_LAUNCHER;

int    Arguments::_sun_java_launcher_pid        = -1;

bool   Arguments::_sun_java_launcher_is_altjvm  = false;

// These parameters are reset in method parse_vm_init_args()

bool   Arguments::_AlwaysCompileLoopMethods     = AlwaysCompileLoopMethods;

bool   Arguments::_UseOnStackReplacement        = UseOnStackReplacement;

bool   Arguments::_BackgroundCompilation        = BackgroundCompilation;

bool   Arguments::_ClipInlining                 = ClipInlining;

intx   Arguments::_Tier3InvokeNotifyFreqLog     = Tier3InvokeNotifyFreqLog;

intx   Arguments::_Tier4InvocationThreshold     = Tier4InvocationThreshold;

char*  Arguments::SharedArchivePath             = NULL;

AgentLibraryList Arguments::_libraryList;

AgentLibraryList Arguments::_agentList;

abort_hook_t     Arguments::_abort_hook         = NULL;

exit_hook_t      Arguments::_exit_hook          = NULL;

vfprintf_hook_t  Arguments::_vfprintf_hook      = NULL;

SystemProperty *Arguments::_sun_boot_library_path = NULL;

SystemProperty *Arguments::_java_library_path = NULL;

SystemProperty *Arguments::_java_home = NULL;

SystemProperty *Arguments::_java_class_path = NULL;

SystemProperty *Arguments::_jdk_boot_class_path_append = NULL;

GrowableArray<ModuleXPatchPath*> *Arguments::_xpatchprefix = NULL;

PathString *Arguments::_system_boot_class_path = NULL;

bool Arguments::_has_jimage = false;

char* Arguments::_ext_dirs = NULL;

// Check if head of 'option' matches 'name', and sets 'tail' to the remaining

// part of the option string.

static bool match_option(const JavaVMOption *option, const char* name,

                         const char** tail) {

  size_t len = strlen(name);

  if (strncmp(option->optionString, name, len) == 0) {

    *tail = option->optionString + len;

    return true;

  } else {

    return false;

  }

}

// Check if 'option' matches 'name'. No "tail" is allowed.

static bool match_option(const JavaVMOption *option, const char* name) {

  const char* tail = NULL;

  bool result = match_option(option, name, &tail);

  if (tail != NULL && *tail == '\0') {

    return result;

  } else {

    return false;

  }

}

// Return true if any of the strings in null-terminated array 'names' matches.

// If tail_allowed is true, then the tail must begin with a colon; otherwise,

// the option must match exactly.

static bool match_option(const JavaVMOption* option, const char** names, const char** tail,

  bool tail_allowed) {

  for (/* empty */; *names != NULL; ++names) {

    if (match_option(option, *names, tail)) {

      if (**tail == '\0' || tail_allowed && **tail == ':') {

        return true;

      }

    }

  }

  return false;

}

static void logOption(const char* opt) {

  if (PrintVMOptions) {

    jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt);

  }

}

// Process java launcher properties.

void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {

  // See if sun.java.launcher, sun.java.launcher.is_altjvm or

  // sun.java.launcher.pid is defined.

  // Must do this before setting up other system properties,

  // as some of them may depend on launcher type.

  for (int index = 0; index < args->nOptions; index++) {

    const JavaVMOption* option = args->options + index;

    const char* tail;

    if (match_option(option, "-Dsun.java.launcher=", &tail)) {

      process_java_launcher_argument(tail, option->extraInfo);

      continue;

    }

    if (match_option(option, "-Dsun.java.launcher.is_altjvm=", &tail)) {

      if (strcmp(tail, "true") == 0) {

        _sun_java_launcher_is_altjvm = true;

      }

      continue;

    }

    if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {

      _sun_java_launcher_pid = atoi(tail);

      continue;

    }

  }

}

// Initialize system properties key and value.

void Arguments::init_system_properties() {

  // Set up _system_boot_class_path which is not a property but

  // relies heavily on argument processing and the jdk.boot.class.path.append

  // property. It is used to store the underlying system boot class path.

  _system_boot_class_path = new PathString(NULL);

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name",

                                                                 "Java Virtual Machine Specification",  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(),  true));

  PropertyList_add(&_system_properties, new SystemProperty("jdk.debug", VM_Version::jdk_debug_level(),  false));

  // Following are JVMTI agent writable properties.

  // Properties values are set to NULL and they are

  // os specific they are initialized in os::init_system_properties_values().

  _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL,  true);

  _java_library_path = new SystemProperty("java.library.path", NULL,  true);

  _java_home =  new SystemProperty("java.home", NULL,  true);

  _java_class_path = new SystemProperty("java.class.path", "",  true);

  // jdk.boot.class.path.append is a non-writeable, internal property.

  // It can only be set by either:

  //    - -Xbootclasspath/a:

  //    - AddToBootstrapClassLoaderSearch during JVMTI OnLoad phase

  _jdk_boot_class_path_append = new SystemProperty("jdk.boot.class.path.append", "", false, true);

  // Add to System Property list.

  PropertyList_add(&_system_properties, _sun_boot_library_path);

  PropertyList_add(&_system_properties, _java_library_path);

  PropertyList_add(&_system_properties, _java_home);

  PropertyList_add(&_system_properties, _java_class_path);

  PropertyList_add(&_system_properties, _jdk_boot_class_path_append);

  // Set OS specific system properties values

  os::init_system_properties_values();

}

// Update/Initialize System properties after JDK version number is known

void Arguments::init_version_specific_system_properties() {

  enum { bufsz = 16 };

  char buffer[bufsz];

  const char* spec_vendor = "Oracle Corporation";

  uint32_t spec_version = JDK_Version::current().major_version();

  jio_snprintf(buffer, bufsz, UINT32_FORMAT, spec_version);

  PropertyList_add(&_system_properties,

      new SystemProperty("java.vm.specification.vendor",  spec_vendor, false));

  PropertyList_add(&_system_properties,

      new SystemProperty("java.vm.specification.version", buffer, false));

  PropertyList_add(&_system_properties,

      new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(),  false));

}

/*

 *  -XX argument processing:

 *

 *  -XX arguments are defined in several places, such as:

 *      globals.hpp, globals_<cpu>.hpp, globals_<os>.hpp, <compiler>_globals.hpp, or <gc>_globals.hpp.

 *  -XX arguments are parsed in parse_argument().

 *  -XX argument bounds checking is done in check_vm_args_consistency().

 *

 * Over time -XX arguments may change. There are mechanisms to handle common cases:

 *

 *      ALIASED: An option that is simply another name for another option. This is often

 *               part of the process of deprecating a flag, but not all aliases need

 *               to be deprecated.

 *

 *               Create an alias for an option by adding the old and new option names to the

 *               "aliased_jvm_flags" table. Delete the old variable from globals.hpp (etc).

 *

 *   DEPRECATED: An option that is supported, but a warning is printed to let the user know that

 *               support may be removed in the future. Both regular and aliased options may be

 *               deprecated.

 *

 *               Add a deprecation warning for an option (or alias) by adding an entry in the

 *               "special_jvm_flags" table and setting the "deprecated_in" field.

 *               Often an option "deprecated" in one major release will

 *               be made "obsolete" in the next. In this case the entry should also have it's

 *               "obsolete_in" field set.

 *

 *     OBSOLETE: An option that has been removed (and deleted from globals.hpp), but is still accepted

 *               on the command line. A warning is printed to let the user know that option might not

 *               be accepted in the future.

 *

 *               Add an obsolete warning for an option by adding an entry in the "special_jvm_flags"

 *               table and setting the "obsolete_in" field.

 *

 *      EXPIRED: A deprecated or obsolete option that has an "accept_until" version less than or equal

 *               to the current JDK version. The system will flatly refuse to admit the existence of

 *               the flag. This allows a flag to die automatically over JDK releases.

 *

 *               Note that manual cleanup of expired options should be done at major JDK version upgrades:

 *                  - Newly expired options should be removed from the special_jvm_flags and aliased_jvm_flags tables.

 *                  - Newly obsolete or expired deprecated options should have their global variable

 *                    definitions removed (from globals.hpp, etc) and related implementations removed.

 *

 * Recommended approach for removing options:

 *

 * To remove options commonly used by customers (e.g. product, commercial -XX options), use

 * the 3-step model adding major release numbers to the deprecate, obsolete and expire columns.

 *

 * To remove internal options (e.g. diagnostic, experimental, develop options), use

 * a 2-step model adding major release numbers to the obsolete and expire columns.

 *

 * To change the name of an option, use the alias table as well as a 2-step

 * model adding major release numbers to the deprecate and expire columns.

 * Think twice about aliasing commonly used customer options.

 *

 * There are times when it is appropriate to leave a future release number as undefined.

 *

 * Tests:  Aliases should be tested in VMAliasOptions.java.

 *         Deprecated options should be tested in VMDeprecatedOptions.java.

 */

// Obsolete or deprecated -XX flag.

typedef struct {

  const char* name;

  JDK_Version deprecated_in; // When the deprecation warning started (or "undefined").

  JDK_Version obsolete_in;   // When the obsolete warning started (or "undefined").

  JDK_Version expired_in;    // When the option expires (or "undefined").

} SpecialFlag;

// The special_jvm_flags table declares options that are being deprecated and/or obsoleted. The

// "deprecated_in" or "obsolete_in" fields may be set to "undefined", but not both.

// When the JDK version reaches 'deprecated_in' limit, the JVM will process this flag on

// the command-line as usual, but will issue a warning.

// When the JDK version reaches 'obsolete_in' limit, the JVM will continue accepting this flag on

// the command-line, while issuing a warning and ignoring the flag value.

// Once the JDK version reaches 'expired_in' limit, the JVM will flatly refuse to admit the

// existence of the flag.

//

// MANUAL CLEANUP ON JDK VERSION UPDATES:

// This table ensures that the handling of options will update automatically when the JDK

// version is incremented, but the source code needs to be cleanup up manually:

// - As "deprecated" options age into "obsolete" or "expired" options, the associated "globals"

//   variable should be removed, as well as users of the variable.

// - As "deprecated" options age into "obsolete" options, move the entry into the

//   "Obsolete Flags" section of the table.

// - All expired options should be removed from the table.

static SpecialFlag const special_jvm_flags[] = {

  // -------------- Deprecated Flags --------------

  // --- Non-alias flags - sorted by obsolete_in then expired_in:

  { "MaxGCMinorPauseMillis",        JDK_Version::jdk(8), JDK_Version::undefined(), JDK_Version::undefined() },

  { "UseParNewGC",                  JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(10) },

  { "ConvertSleepToYield",          JDK_Version::jdk(9), JDK_Version::jdk(10),     JDK_Version::jdk(11) },

  { "ConvertYieldToSleep",          JDK_Version::jdk(9), JDK_Version::jdk(10),     JDK_Version::jdk(11) },

  // --- Deprecated alias flags (see also aliased_jvm_flags) - sorted by obsolete_in then expired_in:

  { "DefaultMaxRAMFraction",        JDK_Version::jdk(8), JDK_Version::undefined(), JDK_Version::undefined() },

  { "CreateMinidumpOnCrash",        JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::undefined() },

  { "CMSMarkStackSizeMax",          JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(10) },

  { "CMSMarkStackSize",             JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(10) },

  { "G1MarkStackSize",              JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(10) },

  { "ParallelMarkingThreads",       JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(10) },

  { "ParallelCMSThreads",           JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(10) },

  // -------------- Obsolete Flags - sorted by expired_in --------------

  { "UseOldInlining",                JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "SafepointPollOffset",           JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "UseBoundThreads",               JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "DefaultThreadPriority",         JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "NoYieldsInMicrolock",           JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "BackEdgeThreshold",             JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "UseNewReflection",              JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "ReflectionWrapResolutionErrors",JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "VerifyReflectionBytecodes",     JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "AutoShutdownNMT",               JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "NmethodSweepFraction",          JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "NmethodSweepCheckInterval",     JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "CodeCacheMinimumFreeSpace",     JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

#ifndef ZERO

  { "UseFastAccessorMethods",        JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "UseFastEmptyMethods",           JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

#endif // ZERO

  { "UseCompilerSafepoints",         JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "AdaptiveSizePausePolicy",       JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "ParallelGCRetainPLAB",          JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "ThreadSafetyMargin",            JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "LazyBootClassLoader",           JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "StarvationMonitorInterval",     JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "PreInflateSpin",                JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "JNIDetachReleasesMonitors",     JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "UseAltSigs",                    JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "SegmentedHeapDumpThreshold",    JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

  { "PrintOopAddress",               JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(10) },

#ifdef TEST_VERIFY_SPECIAL_JVM_FLAGS

  { "dep > obs",                    JDK_Version::jdk(9), JDK_Version::jdk(8), JDK_Version::undefined() },

  { "dep > exp ",                   JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::jdk(8) },

  { "obs > exp ",                   JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::jdk(8) },

  { "not deprecated or obsolete",   JDK_Version::undefined(), JDK_Version::undefined(), JDK_Version::jdk(9) },

  { "dup option",                   JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::undefined() },

  { "dup option",                   JDK_Version::jdk(9), JDK_Version::undefined(), JDK_Version::undefined() },

  { "BytecodeVerificationRemote",   JDK_Version::undefined(), JDK_Version::jdk(9), JDK_Version::undefined() },

#endif

  { NULL, JDK_Version(0), JDK_Version(0) }

};

// Flags that are aliases for other flags.

typedef struct {

  const char* alias_name;

  const char* real_name;

} AliasedFlag;

static AliasedFlag const aliased_jvm_flags[] = {

  { "DefaultMaxRAMFraction",    "MaxRAMFraction"    },

  { "CMSMarkStackSizeMax",      "MarkStackSizeMax"  },

  { "CMSMarkStackSize",         "MarkStackSize"     },

  { "G1MarkStackSize",          "MarkStackSize"     },

  { "ParallelMarkingThreads",   "ConcGCThreads"     },

  { "ParallelCMSThreads",       "ConcGCThreads"     },

  { "CreateMinidumpOnCrash",    "CreateCoredumpOnCrash" },

  { NULL, NULL}

};

// NOTE: A compatibility request will be necessary for each alias to be removed.

static AliasedLoggingFlag const aliased_logging_flags[] = {

  { "PrintCompressedOopsMode",   LogLevel::Info,  true,  LOG_TAGS(gc, heap, coops) },

  { "TraceBiasedLocking",        LogLevel::Info,  true,  LOG_TAGS(biasedlocking) },

  { "TraceClassLoading",         LogLevel::Info,  true,  LOG_TAGS(class, load) },

  { "TraceClassLoadingPreorder", LogLevel::Debug, true,  LOG_TAGS(class, preorder) },

  { "TraceClassPaths",           LogLevel::Info,  true,  LOG_TAGS(class, path) },

  { "TraceClassResolution",      LogLevel::Debug, true,  LOG_TAGS(class, resolve) },

  { "TraceClassUnloading",       LogLevel::Info,  true,  LOG_TAGS(class, unload) },

  { "TraceExceptions",           LogLevel::Info,  true,  LOG_TAGS(exceptions) },

  { "TraceLoaderConstraints",    LogLevel::Info,  true,  LOG_TAGS(class, loader, constraints) },

  { "TraceMonitorInflation",     LogLevel::Debug, true,  LOG_TAGS(monitorinflation) },

  { "TraceSafepointCleanupTime", LogLevel::Info,  true,  LOG_TAGS(safepoint, cleanup) },

  { "TraceJVMTIObjectTagging",   LogLevel::Debug, true,  LOG_TAGS(jvmti, objecttagging) },

  { "TraceRedefineClasses",      LogLevel::Info,  false, LOG_TAGS(redefine, class) },

  { NULL,                        LogLevel::Off,   false, LOG_TAGS(_NO_TAG) }

};

#ifndef PRODUCT

// These options are removed in jdk9. Remove this code for jdk10.

static AliasedFlag const removed_develop_logging_flags[] = {

  { "TraceClassInitialization",   "-Xlog:class+init" },

  { "TraceClassLoaderData",       "-Xlog:class+loader+data" },

  { "TraceDefaultMethods",        "-Xlog:defaultmethods=debug" },

  { "TraceItables",               "-Xlog:itables=debug" },

  { "TraceMonitorMismatch",       "-Xlog:monitormismatch=info" },

  { "TraceSafepoint",             "-Xlog:safepoint=debug" },

  { "TraceStartupTime",           "-Xlog:startuptime" },

  { "TraceVMOperation",           "-Xlog:vmoperation=debug" },

  { "PrintVtables",               "-Xlog:vtables=debug" },

  { "VerboseVerification",        "-Xlog:verification" },

  { NULL, NULL }

};

#endif //PRODUCT

// Return true if "v" is less than "other", where "other" may be "undefined".

static bool version_less_than(JDK_Version v, JDK_Version other) {

  assert(!v.is_undefined(), "must be defined");

  if (!other.is_undefined() && v.compare(other) >= 0) {

    return false;

  } else {

    return true;

  }

}

static bool lookup_special_flag(const char *flag_name, SpecialFlag& flag) {

  for (size_t i = 0; special_jvm_flags[i].name != NULL; i++) {

    if ((strcmp(special_jvm_flags[i].name, flag_name) == 0)) {

      flag = special_jvm_flags[i];

      return true;

    }

  }

  return false;

}

bool Arguments::is_obsolete_flag(const char *flag_name, JDK_Version* version) {

  assert(version != NULL, "Must provide a version buffer");

  SpecialFlag flag;

  if (lookup_special_flag(flag_name, flag)) {

    if (!flag.obsolete_in.is_undefined()) {

      if (version_less_than(JDK_Version::current(), flag.expired_in)) {

        *version = flag.obsolete_in;

        return true;

      }

    }

  }

  return false;

}

int Arguments::is_deprecated_flag(const char *flag_name, JDK_Version* version) {

  assert(version != NULL, "Must provide a version buffer");

  SpecialFlag flag;

  if (lookup_special_flag(flag_name, flag)) {

    if (!flag.deprecated_in.is_undefined()) {

      if (version_less_than(JDK_Version::current(), flag.obsolete_in) &&

          version_less_than(JDK_Version::current(), flag.expired_in)) {

        *version = flag.deprecated_in;

        return 1;

      } else {

        return -1;

      }

    }

  }

  return 0;

}