/*

 * Copyright (c) 1997, 2014, 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 "compiler/compilerOracle.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/cardTableRS.hpp"

#include "memory/genCollectedHeap.hpp"

#include "memory/referenceProcessor.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/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"

#include "utilities/taskqueue.hpp"

#if INCLUDE_ALL_GCS

#include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"

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

#include "gc_implementation/parallelScavenge/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"

// Disable options not supported in this release, with a warning if they

// were explicitly requested on the command-line

#define UNSUPPORTED_OPTION(opt, description)                    \

do {                                                            \

  if (opt) {                                                    \

    if (FLAG_IS_CMDLINE(opt)) {                                 \

      warning(description " is disabled in this release.");     \

    }                                                           \

    FLAG_SET_DEFAULT(opt, false);                               \

  }                                                             \

} while(0)

#define UNSUPPORTED_GC_OPTION(gc)                                     \

do {                                                                  \

  if (gc) {                                                           \

    if (FLAG_IS_CMDLINE(gc)) {                                        \

      warning(#gc " is not supported in this VM.  Using Serial GC."); \

    }                                                                 \

    FLAG_SET_DEFAULT(gc, false);                                      \

  }                                                                   \

} while(0)

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;

uintx  Arguments::_min_heap_size                = 0;

uintx  Arguments::_min_heap_free_ratio          = 0;

uintx  Arguments::_max_heap_free_ratio          = 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(JavaVMInitArgs*)

bool   Arguments::_AlwaysCompileLoopMethods     = AlwaysCompileLoopMethods;

bool   Arguments::_UseOnStackReplacement        = UseOnStackReplacement;

bool   Arguments::_BackgroundCompilation        = BackgroundCompilation;

bool   Arguments::_ClipInlining                 = ClipInlining;

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::_java_ext_dirs = NULL;

SystemProperty *Arguments::_java_endorsed_dirs = 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::_sun_boot_class_path = NULL;

char* Arguments::_meta_index_path = NULL;

char* Arguments::_meta_index_dir = NULL;

// Check if head of 'option' matches 'name', and sets 'tail' remaining part of option string

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

                         const char** tail) {

  int len = (int)strlen(name);

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

    *tail = option->optionString + len;

    return true;

  } else {

    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() {

  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));

  // 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().

  _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL,  true);

  _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL,  true);

  _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);

  _sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL,  true);

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

  // Add to System Property list.

  PropertyList_add(&_system_properties, _java_ext_dirs);

  PropertyList_add(&_system_properties, _java_endorsed_dirs);

  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, _sun_boot_class_path);

  // 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 = "Sun Microsystems Inc.";

  uint32_t spec_version = 0;

  spec_vendor = "Oracle Corporation";

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

  jio_snprintf(buffer, bufsz, "1." 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));

}

/**

 * Provide a slightly more user-friendly way of eliminating -XX flags.

 * When a flag is eliminated, it can be added to this list in order to

 * continue accepting this flag on the command-line, while issuing a warning

 * and ignoring the value.  Once the JDK version reaches the 'accept_until'

 * limit, we flatly refuse to admit the existence of the flag.  This allows

 * a flag to die correctly over JDK releases using HSX.

 */

typedef struct {

  const char* name;

  JDK_Version obsoleted_in; // when the flag went away

  JDK_Version accept_until; // which version to start denying the existence

} ObsoleteFlag;

static ObsoleteFlag obsolete_jvm_flags[] = {

  { "UseTrainGC",                    JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "UseSpecialLargeObjectHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "UseOversizedCarHandling",       JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "TraceCarAllocation",            JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "PrintTrainGCProcessingStats",   JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "LogOfCarSpaceSize",             JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "OversizedCarThreshold",         JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "MinTickInterval",               JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "DefaultTickInterval",           JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "MaxTickInterval",               JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "DelayTickAdjustment",           JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "ProcessingToTenuringRatio",     JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "MinTrainLength",                JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "AppendRatio",         JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) },

  { "DefaultMaxRAM",       JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },

  { "DefaultInitialRAMFraction",

                           JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },

  { "UseDepthFirstScavengeOrder",

                           JDK_Version::jdk_update(6,22), JDK_Version::jdk(7) },

  { "HandlePromotionFailure",

                           JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },

  { "MaxLiveObjectEvacuationRatio",

                           JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },

  { "ForceSharedSpaces",   JDK_Version::jdk_update(6,25), JDK_Version::jdk(8) },

  { "UseParallelOldGCCompacting",

                           JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },

  { "UseParallelDensePrefixUpdate",

                           JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },

  { "UseParallelOldGCDensePrefix",

                           JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },

  { "AllowTransitionalJSR292",       JDK_Version::jdk(7), JDK_Version::jdk(8) },

  { "UseCompressedStrings",          JDK_Version::jdk(7), JDK_Version::jdk(8) },

  { "CMSPermGenPrecleaningEnabled", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "CMSTriggerPermRatio", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "CMSInitiatingPermOccupancyFraction", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "AdaptivePermSizeWeight", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "PermGenPadding", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "PermMarkSweepDeadRatio", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "PermSize", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "MaxPermSize", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "MinPermHeapExpansion", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "MaxPermHeapExpansion", JDK_Version::jdk(8),  JDK_Version::jdk(9) },

  { "CMSRevisitStackSize",           JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "PrintRevisitStats",             JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "UseVectoredExceptions",         JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "UseSplitVerifier",              JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "UseISM",                        JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "UsePermISM",                    JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "UseMPSS",                       JDK_Version::jdk(8), JDK_Version::jdk(9) },

  { "UseStringCache",                JDK_Version::jdk(8), JDK_Version::jdk(9) },

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

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

#ifdef PRODUCT

  { "DesiredMethodLimit",

                           JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },

#endif // PRODUCT

  { "UseVMInterruptibleIO",          JDK_Version::jdk(8), JDK_Version::jdk(9) },

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

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

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

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

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

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

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

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

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

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

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

#ifndef ZERO

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

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

#endif // ZERO

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

};

// Returns true if the flag is obsolete and fits into the range specified

// for being ignored.  In the case that the flag is ignored, the 'version'

// value is filled in with the version number when the flag became

// obsolete so that that value can be displayed to the user.

bool Arguments::is_newly_obsolete(const char *s, JDK_Version* version) {

  int i = 0;

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

  while (obsolete_jvm_flags[i].name != NULL) {

    const ObsoleteFlag& flag_status = obsolete_jvm_flags[i];

    // <flag>=xxx form

    // [-|+]<flag> form

        ((s[0] == '+' || s[0] == '-') &&

      if (JDK_Version::current().compare(flag_status.accept_until) == -1) {

          *version = flag_status.obsoleted_in;

          return true;

      }

    }

    i++;

  }

  return false;

}

// Constructs the system class path (aka boot class path) from the following

// components, in order:

//

//     prefix           // from -Xbootclasspath/p:...

//     endorsed         // the expansion of -Djava.endorsed.dirs=...

//     base             // from os::get_system_properties() or -Xbootclasspath=

//     suffix           // from -Xbootclasspath/a:...

//

// java.endorsed.dirs is a list of directories; any jar or zip files in the

// directories are added to the sysclasspath just before the base.

//

// This could be AllStatic, but it isn't needed after argument processing is

// complete.

class SysClassPath: public StackObj {

public:

  SysClassPath(const char* base);

  ~SysClassPath();

  inline void set_base(const char* base);

  inline void add_prefix(const char* prefix);

  inline void add_suffix_to_prefix(const char* suffix);

  inline void add_suffix(const char* suffix);

  inline void reset_path(const char* base);

  // Expand the jar/zip files in each directory listed by the java.endorsed.dirs

  // property.  Must be called after all command-line arguments have been

  // processed (in particular, -Djava.endorsed.dirs=...) and before calling

  // combined_path().

  void expand_endorsed();

  inline const char* get_base()     const { return _items[_scp_base]; }

  inline const char* get_prefix()   const { return _items[_scp_prefix]; }

  inline const char* get_suffix()   const { return _items[_scp_suffix]; }

  inline const char* get_endorsed() const { return _items[_scp_endorsed]; }

  // Combine all the components into a single c-heap-allocated string; caller

  // must free the string if/when no longer needed.

  char* combined_path();

private:

  // Utility routines.

  static char* add_to_path(const char* path, const char* str, bool prepend);

  static char* add_jars_to_path(char* path, const char* directory);

  inline void reset_item_at(int index);

  // Array indices for the items that make up the sysclasspath.  All except the

  // base are allocated in the C heap and freed by this class.

  enum {

    _scp_prefix,        // from -Xbootclasspath/p:...

    _scp_endorsed,      // the expansion of -Djava.endorsed.dirs=...

    _scp_base,          // the default sysclasspath

    _scp_suffix,        // from -Xbootclasspath/a:...

    _scp_nitems         // the number of items, must be last.

  };

  const char* _items[_scp_nitems];

  DEBUG_ONLY(bool _expansion_done;)

};

SysClassPath::SysClassPath(const char* base) {

  memset(_items, 0, sizeof(_items));

  _items[_scp_base] = base;

  DEBUG_ONLY(_expansion_done = false;)

}

SysClassPath::~SysClassPath() {

  // Free everything except the base.

  for (int i = 0; i < _scp_nitems; ++i) {

    if (i != _scp_base) reset_item_at(i);

  }

  DEBUG_ONLY(_expansion_done = false;)

}

inline void SysClassPath::set_base(const char* base) {

  _items[_scp_base] = base;

}

inline void SysClassPath::add_prefix(const char* prefix) {

  _items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true);

}

inline void SysClassPath::add_suffix_to_prefix(const char* suffix) {

  _items[_scp_prefix] = add_to_path(_items[_scp_prefix], suffix, false);

}

inline void SysClassPath::add_suffix(const char* suffix) {

  _items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false);

}

inline void SysClassPath::reset_item_at(int index) {

  assert(index < _scp_nitems && index != _scp_base, "just checking");

  if (_items[index] != NULL) {

    FREE_C_HEAP_ARRAY(char, _items[index], mtInternal);

    _items[index] = NULL;

  }

}

inline void SysClassPath::reset_path(const char* base) {

  // Clear the prefix and suffix.

  reset_item_at(_scp_prefix);

  reset_item_at(_scp_suffix);

  set_base(base);

}

//------------------------------------------------------------------------------

void SysClassPath::expand_endorsed() {

  assert(_items[_scp_endorsed] == NULL, "can only be called once.");

  const char* path = Arguments::get_property("java.endorsed.dirs");

  if (path == NULL) {

    path = Arguments::get_endorsed_dir();

    assert(path != NULL, "no default for java.endorsed.dirs");

  }

  char* expanded_path = NULL;

  const char separator = *os::path_separator();

  const char* const end = path + strlen(path);

  while (path < end) {

    const char* tmp_end = strchr(path, separator);

    if (tmp_end == NULL) {

      expanded_path = add_jars_to_path(expanded_path, path);

      path = end;

    } else {

      char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal);

      memcpy(dirpath, path, tmp_end - path);

      dirpath[tmp_end - path] = '\0';

      expanded_path = add_jars_to_path(expanded_path, dirpath);

      FREE_C_HEAP_ARRAY(char, dirpath, mtInternal);

      path = tmp_end + 1;

    }

  }

  _items[_scp_endorsed] = expanded_path;

  DEBUG_ONLY(_expansion_done = true;)

}

// Combine the bootclasspath elements, some of which may be null, into a single

// c-heap-allocated string.

char* SysClassPath::combined_path() {

  assert(_items[_scp_base] != NULL, "empty default sysclasspath");

  assert(_expansion_done, "must call expand_endorsed() first.");

  size_t lengths[_scp_nitems];

  size_t total_len = 0;

  const char separator = *os::path_separator();

  // Get the lengths.

  int i;

  for (i = 0; i < _scp_nitems; ++i) {

    if (_items[i] != NULL) {

      lengths[i] = strlen(_items[i]);

      // Include space for the separator char (or a NULL for the last item).

      total_len += lengths[i] + 1;

    }

  }

  assert(total_len > 0, "empty sysclasspath not allowed");

  // Copy the _items to a single string.

  char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal);

  char* cp_tmp = cp;

  for (i = 0; i < _scp_nitems; ++i) {