truffle: src/share/vm/runtime/arguments.cpp comparison

comparison src/share/vm/runtime/arguments.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	9ee881900cf5 4b41145051ab
children	12e94cba3696

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 * questions.
 *
 */
 #include "precompiled.hpp"
+#include "classfile/classLoader.hpp"
 #include "classfile/javaAssertions.hpp"
 #include "classfile/symbolTable.hpp"
 #include "compiler/compilerOracle.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/cardTableRS.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 "services/management.hpp"
 #include "services/memTracker.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/macros.hpp"
+#include "utilities/stringUtils.hpp"
 #include "utilities/taskqueue.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 # include "os_linux.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_solaris
 #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.sun.com/bugreport/crash.jsp"
+#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)                    \
 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;
 { "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) },
+{ "AutoShutdownNMT",               JDK_Version::jdk(9), JDK_Version::jdk(10) },
+{ "CompilationRepeat",             JDK_Version::jdk(8), JDK_Version::jdk(9) },
 #ifdef PRODUCT
 { "DesiredMethodLimit",
 JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },
 #endif // PRODUCT
 { NULL, JDK_Version(0), JDK_Version(0) }
 #if defined(COMPILER2) || defined(GRAAL) || defined(_LP64) || !INCLUDE_CDS
 // Conflict: required to use shared spaces (-Xshare:on), but
 // incompatible command line options were chosen.
-static void no_shared_spaces() {
+static void no_shared_spaces(const char* message) {
 if (RequireSharedSpaces) {
 jio_fprintf(defaultStream::error_stream(),
 "Class data sharing is inconsistent with other specified options.\n");
-vm_exit_during_initialization("Unable to use shared archive.", NULL);
+vm_exit_during_initialization("Unable to use shared archive.", message);
 } else {
 FLAG_SET_DEFAULT(UseSharedSpaces, false);
 }
 }
 #endif
 }
 if (!UseInterpreter) { // -Xcomp
 Tier3InvokeNotifyFreqLog = 0;
 Tier4InvocationThreshold = 0;
 }
+}
+/**
+* Returns the minimum number of compiler threads needed to run the JVM. The following
+* configurations are possible.
+*
+* 1) The JVM is build using an interpreter only. As a result, the minimum number of
+*    compiler threads is 0.
+* 2) The JVM is build using the compiler(s) and tiered compilation is disabled. As
+*    a result, either C1 or C2 is used, so the minimum number of compiler threads is 1.
+* 3) The JVM is build using the compiler(s) and tiered compilation is enabled. However,
+*    the option "TieredStopAtLevel < CompLevel_full_optimization". As a result, only
+*    C1 can be used, so the minimum number of compiler threads is 1.
+* 4) The JVM is build using the compilers and tiered compilation is enabled. The option
+*    'TieredStopAtLevel = CompLevel_full_optimization' (the default value). As a result,
+*    the minimum number of compiler threads is 2.
+*/
+int Arguments::get_min_number_of_compiler_threads() {
+#if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK) && !defined(COMPILERGRAAL)
+return 0;   // case 1
+#else
+if (!TieredCompilation || (TieredStopAtLevel < CompLevel_full_optimization)) {
+return 1; // case 2 or case 3
+}
+return 2;   // case 4 (tiered)
+#endif
 }
 #if INCLUDE_ALL_GCS
 static void disable_adaptive_size_policy(const char* collector_name) {
 if (UseAdaptiveSizePolicy) {
 jio_fprintf(defaultStream::error_stream(),
 "error: ObjectAlignmentInBytes=%d must be less than page size %d\n",
 (int)ObjectAlignmentInBytes, os::vm_page_size());
 return false;
 }
+if(SurvivorAlignmentInBytes == 0) {
+SurvivorAlignmentInBytes = ObjectAlignmentInBytes;
+} else {
+if (!is_power_of_2(SurvivorAlignmentInBytes)) {
+jio_fprintf(defaultStream::error_stream(),
+"error: SurvivorAlignmentInBytes=%d must be power of 2\n",
+(int)SurvivorAlignmentInBytes);
+return false;
+}
+if (SurvivorAlignmentInBytes < ObjectAlignmentInBytes) {
+jio_fprintf(defaultStream::error_stream(),
+"error: SurvivorAlignmentInBytes=%d must be greater than ObjectAlignmentInBytes=%d \n",
+(int)SurvivorAlignmentInBytes, (int)ObjectAlignmentInBytes);
+return false;
+}
+}
 return true;
 }
-uintx Arguments::max_heap_for_compressed_oops() {
+size_t Arguments::max_heap_for_compressed_oops() {
 // Avoid sign flip.
 assert(OopEncodingHeapMax > (uint64_t)os::vm_page_size(), "Unusual page size");
 // We need to fit both the NULL page and the heap into the memory budget, while
 // keeping alignment constraints of the heap. To guarantee the latter, as the
 // NULL page is located before the heap, we pad the NULL page to the conservative
 heap_alignment = ParallelScavengeHeap::conservative_max_heap_alignment();
 } else if (UseG1GC) {
 heap_alignment = G1CollectedHeap::conservative_max_heap_alignment();
 }
 #endif // INCLUDE_ALL_GCS
-_conservative_max_heap_alignment = MAX3(heap_alignment, os::max_page_size(),
+_conservative_max_heap_alignment = MAX4(heap_alignment,
-CollectorPolicy::compute_heap_alignment());
+(size_t)os::vm_allocation_granularity(),
+os::max_page_size(),
+CollectorPolicy::compute_heap_alignment());
+}
+void Arguments::select_gc_ergonomically() {
+if (os::is_server_class_machine()) {
+if (should_auto_select_low_pause_collector()) {
+FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
+} else {
+FLAG_SET_ERGO(bool, UseParallelGC, true);
+}
+}
+}
+void Arguments::select_gc() {
+if (!gc_selected()) {
+ArgumentsExt::select_gc_ergonomically();
+}
 }
 void Arguments::set_ergonomics_flags() {
+select_gc();
-if (os::is_server_class_machine()) {
-// If no other collector is requested explicitly,
-// let the VM select the collector based on
-// machine class and automatic selection policy.
-if (!UseSerialGC &&
-!UseConcMarkSweepGC &&
-!UseG1GC &&
-!UseParNewGC &&
-FLAG_IS_DEFAULT(UseParallelGC)) {
-if (should_auto_select_low_pause_collector()) {
-FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
-} else {
-FLAG_SET_ERGO(bool, UseParallelGC, true);
-}
-}
-}
 #if defined(COMPILER2) || defined(GRAAL)
 // Shared spaces work fine with other GCs but causes bytecode rewriting
 // to be disabled, which hurts interpreter performance and decreases
 // server performance.  When -server is specified, keep the default off
 // unless it is asked for.  Future work: either add bytecode rewriting
 // at link time, or rewrite bytecodes in non-shared methods.
 if (!DumpSharedSpaces && !RequireSharedSpaces &&
 (FLAG_IS_DEFAULT(UseSharedSpaces) || !UseSharedSpaces)) {
-no_shared_spaces();
+no_shared_spaces("COMPILER2 default: -Xshare:auto | off, have to manually setup to on.");
 }
 #endif
 set_conservative_max_heap_alignment();
 if (UseAdaptiveSizePolicy) {
 // We don't want to limit adaptive heap sizing's freedom to adjust the heap
 // unless the user actually sets these flags.
 if (FLAG_IS_DEFAULT(MinHeapFreeRatio)) {
 FLAG_SET_DEFAULT(MinHeapFreeRatio, 0);
+_min_heap_free_ratio = MinHeapFreeRatio;
 }
 if (FLAG_IS_DEFAULT(MaxHeapFreeRatio)) {
 FLAG_SET_DEFAULT(MaxHeapFreeRatio, 100);
+_max_heap_free_ratio = MaxHeapFreeRatio;
 }
 }
 // If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the
 // SurvivorRatio has been set, reset their default values to SurvivorRatio +
 if (ParallelGCThreads == 0) {
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 }
+#if INCLUDE_ALL_GCS
+if (G1ConcRefinementThreads == 0) {
+FLAG_SET_DEFAULT(G1ConcRefinementThreads, ParallelGCThreads);
+}
+#endif
 // MarkStackSize will be set (if it hasn't been set by the user)
 // when concurrent marking is initialized.
 // Its value will be based upon the number of parallel marking threads.
 // But we do set the maximum mark stack size here.
 if (FLAG_IS_DEFAULT(MarkStackSizeMax)) {
 if (PrintGCDetails && Verbose) {
 tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
 (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
 tty->print_cr("ConcGCThreads: %u", (uint) ConcGCThreads);
 }
+}
+#if !INCLUDE_ALL_GCS
+#ifdef ASSERT
+static bool verify_serial_gc_flags() {
+return (UseSerialGC &&
+!(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC ||
+UseParallelGC || UseParallelOldGC));
+}
+#endif // ASSERT
+#endif // INCLUDE_ALL_GCS
+void Arguments::set_gc_specific_flags() {
+#if INCLUDE_ALL_GCS
+// Set per-collector flags
+if (UseParallelGC || UseParallelOldGC) {
+set_parallel_gc_flags();
+} else if (UseConcMarkSweepGC) { // Should be done before ParNew check below
+set_cms_and_parnew_gc_flags();
+} else if (UseParNewGC) {  // Skipped if CMS is set above
+set_parnew_gc_flags();
+} else if (UseG1GC) {
+set_g1_gc_flags();
+}
+check_deprecated_gcs();
+check_deprecated_gc_flags();
+if (AssumeMP && !UseSerialGC) {
+if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
+warning("If the number of processors is expected to increase from one, then"
+" you should configure the number of parallel GC threads appropriately"
+" using -XX:ParallelGCThreads=N");
+}
+}
+if (MinHeapFreeRatio == 100) {
+// Keeping the heap 100% free is hard ;-) so limit it to 99%.
+FLAG_SET_ERGO(uintx, MinHeapFreeRatio, 99);
+}
+#else // INCLUDE_ALL_GCS
+assert(verify_serial_gc_flags(), "SerialGC unset");
+#endif // INCLUDE_ALL_GCS
 }
 julong Arguments::limit_by_allocatable_memory(julong limit) {
 julong max_allocatable;
 julong result = limit;
 jio_fprintf(defaultStream::error_stream(),
 "%s of " UINTX_FORMAT " is invalid; must be between 0 and 100\n",
 name, value);
 return false;
 }
-#if !INCLUDE_ALL_GCS
-#ifdef ASSERT
-static bool verify_serial_gc_flags() {
-return (UseSerialGC &&
-!(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC ||
-UseParallelGC || UseParallelOldGC));
-}
-#endif // ASSERT
-#endif // INCLUDE_ALL_GCS
 // check if do gclog rotation
 // +UseGCLogFileRotation is a must,
 // no gc log rotation when log file not supplied or
 // NumberOfGCLogFiles is 0
 err_msg.print("MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
 "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")", min_heap_free_ratio,
 MaxHeapFreeRatio);
 return false;
 }
+// This does not set the flag itself, but stores the value in a safe place for later usage.
+_min_heap_free_ratio = min_heap_free_ratio;
 return true;
 }
 bool Arguments::verify_MaxHeapFreeRatio(FormatBuffer<80>& err_msg, uintx max_heap_free_ratio) {
 if (!is_percentage(max_heap_free_ratio)) {
 err_msg.print("MaxHeapFreeRatio (" UINTX_FORMAT ") must be greater than or "
 "equal to MinHeapFreeRatio (" UINTX_FORMAT ")", max_heap_free_ratio,
 MinHeapFreeRatio);
 return false;
 }
+// This does not set the flag itself, but stores the value in a safe place for later usage.
+_max_heap_free_ratio = max_heap_free_ratio;
 return true;
 }
 // Check consistency of GC selection
-bool Arguments::check_gc_consistency() {
+bool Arguments::check_gc_consistency_user() {
 check_gclog_consistency();
 bool status = true;
 // Ensure that the user has not selected conflicting sets
 // of collectors. [Note: this check is merely a user convenience;
 // collectors over-ride each other so that only a non-conflicting
 if (GCTimeLimit == 100) {
 // Turn off gc-overhead-limit-exceeded checks
 FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
 }
-status = status && check_gc_consistency();
+status = status && check_gc_consistency_user();
 status = status && check_stack_pages();
 if (CMSIncrementalMode) {
 if (!UseConcMarkSweepGC) {
 jio_fprintf(defaultStream::error_stream(),
 status = status && verify_interval(InitialTenuringThreshold, 0, MaxTenuringThreshold, "MaxTenuringThreshold");
 status = status && verify_percentage(TargetSurvivorRatio, "TargetSurvivorRatio");
 status = status && verify_percentage(MarkSweepDeadRatio, "MarkSweepDeadRatio");
 status = status && verify_min_value(MarkSweepAlwaysCompactCount, 1, "MarkSweepAlwaysCompactCount");
+#ifdef COMPILER1
+status = status && verify_min_value(ValueMapInitialSize, 1, "ValueMapInitialSize");
+#endif
 if (PrintNMTStatistics) {
 #if INCLUDE_NMT
-if (MemTracker::tracking_level() == MemTracker::NMT_off) {
+if (MemTracker::tracking_level() == NMT_off) {
 #endif // INCLUDE_NMT
 warning("PrintNMTStatistics is disabled, because native memory tracking is not enabled");
 PrintNMTStatistics = false;
 #if INCLUDE_NMT
 }
 }
 #ifdef COMPILER1
 status &= verify_interval(SafepointPollOffset, 0, os::vm_page_size() - BytesPerWord, "SafepointPollOffset");
 #endif
+int min_number_of_compiler_threads = get_min_number_of_compiler_threads();
+// The default CICompilerCount's value is CI_COMPILER_COUNT.
+assert(min_number_of_compiler_threads <= CI_COMPILER_COUNT, "minimum should be less or equal default number");
+// Check the minimum number of compiler threads
+status &=verify_min_value(CICompilerCount, min_number_of_compiler_threads, "CICompilerCount");
 return status;
 }
 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
 CommandLineFlags::printFlags(tty, false);
 vm_exit(0);
 #endif
 // -D
 } else if (match_option(option, "-D", &tail)) {
+if (CheckEndorsedAndExtDirs) {
+if (match_option(option, "-Djava.endorsed.dirs=", &tail)) {
+// abort if -Djava.endorsed.dirs is set
+jio_fprintf(defaultStream::output_stream(),
+"-Djava.endorsed.dirs will not be supported in a future release.\n"
+"Refer to JEP 220 for details (http://openjdk.java.net/jeps/220).\n");
+return JNI_EINVAL;
+}
+if (match_option(option, "-Djava.ext.dirs=", &tail)) {
+// abort if -Djava.ext.dirs is set
+jio_fprintf(defaultStream::output_stream(),
+"-Djava.ext.dirs will not be supported in a future release.\n"
+"Refer to JEP 220 for details (http://openjdk.java.net/jeps/220).\n");
+return JNI_EINVAL;
+}
+}
 if (!add_property(tail)) {
 return JNI_ENOMEM;
 }
 // Out of the box management support
 if (match_option(option, "-Dcom.sun.management", &tail)) {
 else if (is_bad_option(option, args->ignoreUnrecognized)) {
 return JNI_ERR;
 }
 }
+// PrintSharedArchiveAndExit will turn on
+//   -Xshare:on
+//   -XX:+TraceClassPaths
+if (PrintSharedArchiveAndExit) {
+FLAG_SET_CMDLINE(bool, UseSharedSpaces, true);
+FLAG_SET_CMDLINE(bool, RequireSharedSpaces, true);
+FLAG_SET_CMDLINE(bool, TraceClassPaths, true);
+}
 // Change the default value for flags  which have different default values
 // when working with older JDKs.
 #ifdef LINUX
 if (JDK_Version::current().compare_major(6) <= 0 &&
 FLAG_IS_DEFAULT(UseLinuxPosixThreadCPUClocks)) {
 FLAG_SET_DEFAULT(UseLinuxPosixThreadCPUClocks, false);
 }
 #endif // LINUX
+fix_appclasspath();
 return JNI_OK;
+}
+// Remove all empty paths from the app classpath (if IgnoreEmptyClassPaths is enabled)
+//
+// This is necessary because some apps like to specify classpath like -cp foo.jar:${XYZ}:bar.jar
+// in their start-up scripts. If XYZ is empty, the classpath will look like "-cp foo.jar::bar.jar".
+// Java treats such empty paths as if the user specified "-cp foo.jar:.:bar.jar". I.e., an empty
+// path is treated as the current directory.
+//
+// This causes problems with CDS, which requires that all directories specified in the classpath
+// must be empty. In most cases, applications do NOT want to load classes from the current
+// directory anyway. Adding -XX:+IgnoreEmptyClassPaths will make these applications' start-up
+// scripts compatible with CDS.
+void Arguments::fix_appclasspath() {
+if (IgnoreEmptyClassPaths) {
+const char separator = *os::path_separator();
+const char* src = _java_class_path->value();
+// skip over all the leading empty paths
+while (*src == separator) {
+src ++;
+}
+char* copy = AllocateHeap(strlen(src) + 1, mtInternal);
+strncpy(copy, src, strlen(src) + 1);
+// trim all trailing empty paths
+for (char* tail = copy + strlen(copy) - 1; tail >= copy && *tail == separator; tail--) {
+*tail = '\0';
+}
+char from[3] = {separator, separator, '\0'};
+char to  [2] = {separator, '\0'};
+while (StringUtils::replace_no_expand(copy, from, to) > 0) {
+// Keep replacing "::" -> ":" until we have no more "::" (non-windows)
+// Keep replacing ";;" -> ";" until we have no more ";;" (windows)
+}
+_java_class_path->set_value(copy);
+FreeHeap(copy); // a copy was made by set_value, so don't need this anymore
+}
+if (!PrintSharedArchiveAndExit) {
+ClassLoader::trace_class_path("[classpath: ", _java_class_path->value());
+}
+}
+static bool has_jar_files(const char* directory) {
+DIR* dir = os::opendir(directory);
+if (dir == NULL) return false;
+struct dirent *entry;
+char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory), mtInternal);
+bool hasJarFile = false;
+while (!hasJarFile && (entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {
+const char* name = entry->d_name;
+const char* ext = name + strlen(name) - 4;
+hasJarFile = ext > name && (os::file_name_strcmp(ext, ".jar") == 0);
+}
+FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);
+os::closedir(dir);
+return hasJarFile ;
+}
+// returns the number of directories in the given path containing JAR files
+// If the skip argument is not NULL, it will skip that directory
+static int check_non_empty_dirs(const char* path, const char* type, const char* skip) {
+const char separator = *os::path_separator();
+const char* const end = path + strlen(path);
+int nonEmptyDirs = 0;
+while (path < end) {
+const char* tmp_end = strchr(path, separator);
+if (tmp_end == NULL) {
+if ((skip == NULL || strcmp(path, skip) != 0) && has_jar_files(path)) {
+nonEmptyDirs++;
+jio_fprintf(defaultStream::output_stream(),
+"Non-empty %s directory: %s\n", type, 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';
+if ((skip == NULL || strcmp(dirpath, skip) != 0) && has_jar_files(dirpath)) {
+nonEmptyDirs++;
+jio_fprintf(defaultStream::output_stream(),
+"Non-empty %s directory: %s\n", type, dirpath);
+}
+FREE_C_HEAP_ARRAY(char, dirpath, mtInternal);
+path = tmp_end + 1;
+}
+}
+return nonEmptyDirs;
+}
+// Returns true if endorsed standards override mechanism and extension mechanism
+// are not used.
+static bool check_endorsed_and_ext_dirs() {
+if (!CheckEndorsedAndExtDirs)
+return true;
+char endorsedDir[JVM_MAXPATHLEN];
+char extDir[JVM_MAXPATHLEN];
+const char* fileSep = os::file_separator();
+jio_snprintf(endorsedDir, sizeof(endorsedDir), "%s%slib%sendorsed",
+Arguments::get_java_home(), fileSep, fileSep);
+jio_snprintf(extDir, sizeof(extDir), "%s%slib%sext",
+Arguments::get_java_home(), fileSep, fileSep);
+// check endorsed directory
+int nonEmptyDirs = check_non_empty_dirs(Arguments::get_endorsed_dir(), "endorsed", NULL);
+// check the extension directories but skip the default lib/ext directory
+nonEmptyDirs += check_non_empty_dirs(Arguments::get_ext_dirs(), "extension", extDir);
+// List of JAR files installed in the default lib/ext directory.
+// -XX:+CheckEndorsedAndExtDirs checks if any non-JDK file installed
+static const char* jdk_ext_jars[] = {
+"access-bridge-32.jar",
+"access-bridge-64.jar",
+"access-bridge.jar",
+"cldrdata.jar",
+"dnsns.jar",
+"jaccess.jar",
+"jfxrt.jar",
+"localedata.jar",
+"nashorn.jar",
+"sunec.jar",
+"sunjce_provider.jar",
+"sunmscapi.jar",
+"sunpkcs11.jar",
+"ucrypto.jar",
+"zipfs.jar",
+NULL
+};
+// check if the default lib/ext directory has any non-JDK jar files; if so, error
+DIR* dir = os::opendir(extDir);
+if (dir != NULL) {
+int num_ext_jars = 0;
+struct dirent *entry;
+char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(extDir), mtInternal);
+while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {
+const char* name = entry->d_name;
+const char* ext = name + strlen(name) - 4;
+if (ext > name && (os::file_name_strcmp(ext, ".jar") == 0)) {
+bool is_jdk_jar = false;
+const char* jarfile = NULL;
+for (int i=0; (jarfile = jdk_ext_jars[i]) != NULL; i++) {
+if (os::file_name_strcmp(name, jarfile) == 0) {
+is_jdk_jar = true;
+break;
+}
+}
+if (!is_jdk_jar) {
+jio_fprintf(defaultStream::output_stream(),
+"%s installed in <JAVA_HOME>/lib/ext\n", name);
+num_ext_jars++;
+}
+}
+}
+FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);
+os::closedir(dir);
+if (num_ext_jars > 0) {
+nonEmptyDirs += 1;
+}
+}
+// check if the default lib/endorsed directory exists; if so, error
+dir = os::opendir(endorsedDir);
+if (dir != NULL) {
+jio_fprintf(defaultStream::output_stream(), "<JAVA_HOME>/lib/endorsed exists\n");
+os::closedir(dir);
+nonEmptyDirs += 1;
+}
+if (nonEmptyDirs > 0) {
+jio_fprintf(defaultStream::output_stream(),
+"Endorsed standards override mechanism and extension mechanism "
+"will not be supported in a future release.\n"
+"Refer to JEP 220 for details (http://openjdk.java.net/jeps/220).\n");
+return false;
+}
+return true;
 }
 jint Arguments::finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required) {
 // This must be done after all -D arguments have been processed.
 scp_p->expand_endorsed();
 #endif
 if (scp_assembly_required || scp_p->get_endorsed() != NULL) {
 // Assemble the bootclasspath elements into the final path.
 Arguments::set_sysclasspath(scp_p->combined_path());
+}
+if (!check_endorsed_and_ext_dirs()) {
+return JNI_ERR;
 }
 // This must be done after all arguments have been processed.
 // java_compiler() true means set to "NONE" or empty.
 if (java_compiler() && !xdebug_mode()) {
 if (!UseCompressedOops || !UseCompressedClassPointers) {
 vm_exit_during_initialization(
 "Cannot dump shared archive when UseCompressedOops or UseCompressedClassPointers is off.", NULL);
 }
 } else {
-// UseCompressedOops and UseCompressedClassPointers must be on for UseSharedSpaces.
 if (!UseCompressedOops || !UseCompressedClassPointers) {
-no_shared_spaces();
+no_shared_spaces("UseCompressedOops and UseCompressedClassPointers must be on for UseSharedSpaces.");
 }
 #endif
 }
 }
 // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed.
 const char* hotspotrc = ".hotspotrc";
 bool settings_file_specified = false;
 bool needs_hotspotrc_warning = false;
+ArgumentsExt::process_options(args);
 const char* flags_file;
 int index;
 for (index = 0; index < args->nOptions; index++) {
 const JavaVMOption *option = args->options + index;
 if (match_option(option, "-XX:Flags=", &tail)) {
 }
 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) {
 CommandLineFlags::printFlags(tty, false);
 vm_exit(0);
 }
+#if INCLUDE_NMT
 if (match_option(option, "-XX:NativeMemoryTracking", &tail)) {
-#if INCLUDE_NMT
+// The launcher did not setup nmt environment variable properly.
-MemTracker::init_tracking_options(tail);
+if (!MemTracker::check_launcher_nmt_support(tail)) {
-#else
+warning("Native Memory Tracking did not setup properly, using wrong launcher?");
-jio_fprintf(defaultStream::error_stream(),
+}
-"Native Memory Tracking is not supported in this VM\n");
-return JNI_ERR;
+// Verify if nmt option is valid.
+if (MemTracker::verify_nmt_option()) {
+// Late initialization, still in single-threaded mode.
+if (MemTracker::tracking_level() >= NMT_summary) {
+MemTracker::init();
+}
+} else {
+vm_exit_during_initialization("Syntax error, expecting -XX:NativeMemoryTracking=[off|summary|detail]", NULL);
+}
+}
 #endif
-}
 #ifndef PRODUCT
 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) {
 CommandLineFlags::printFlags(tty, true);
 if ((UseSharedSpaces && FLAG_IS_CMDLINE(UseSharedSpaces)) || PrintSharedSpaces) {
 warning("Shared spaces are not supported in this VM");
 FLAG_SET_DEFAULT(UseSharedSpaces, false);
 FLAG_SET_DEFAULT(PrintSharedSpaces, false);
 }
-no_shared_spaces();
+no_shared_spaces("CDS Disabled");
 #endif // INCLUDE_CDS
 return JNI_OK;
 }
 set_ergonomics_flags();
 set_shared_spaces_flags();
 // Check the GC selections again.
-if (!check_gc_consistency()) {
+if (!ArgumentsExt::check_gc_consistency_ergo()) {
 return JNI_EINVAL;
 }
 if (TieredCompilation) {
 set_tiered_flags();
 // Set heap size based on available physical memory
 set_heap_size();
-#if INCLUDE_ALL_GCS
+ArgumentsExt::set_gc_specific_flags();
-// Set per-collector flags
-if (UseParallelGC || UseParallelOldGC) {
-set_parallel_gc_flags();
-} else if (UseConcMarkSweepGC) { // Should be done before ParNew check below
-set_cms_and_parnew_gc_flags();
-} else if (UseParNewGC) {  // Skipped if CMS is set above
-set_parnew_gc_flags();
-} else if (UseG1GC) {
-set_g1_gc_flags();
-}
-check_deprecated_gcs();
-check_deprecated_gc_flags();
-if (AssumeMP && !UseSerialGC) {
-if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
-warning("If the number of processors is expected to increase from one, then"
-" you should configure the number of parallel GC threads appropriately"
-" using -XX:ParallelGCThreads=N");
-}
-}
-if (MinHeapFreeRatio == 100) {
-// Keeping the heap 100% free is hard ;-) so limit it to 99%.
-FLAG_SET_ERGO(uintx, MinHeapFreeRatio, 99);
-}
-#else // INCLUDE_ALL_GCS
-assert(verify_serial_gc_flags(), "SerialGC unset");
-#endif // INCLUDE_ALL_GCS
 // Initialize Metaspace flags and alignments.
 Metaspace::ergo_initialize();
 // Set bytecode rewriting flags
 }
 if (!UseTypeSpeculation && FLAG_IS_DEFAULT(TypeProfileLevel)) {
 // nothing to use the profiling, turn if off
 FLAG_SET_DEFAULT(TypeProfileLevel, 0);
 }
-if (UseTypeSpeculation && FLAG_IS_DEFAULT(ReplaceInParentMaps)) {
-// Doing the replace in parent maps helps speculation
-FLAG_SET_DEFAULT(ReplaceInParentMaps, true);
-}
 #endif
 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
 DebugNonSafepoints = true;
 return JNI_OK;
 }
 jint Arguments::adjust_after_os() {
-#if INCLUDE_ALL_GCS
+if (UseNUMA) {
 if (UseParallelGC || UseParallelOldGC) {
-if (UseNUMA) {
 if (FLAG_IS_DEFAULT(MinHeapDeltaBytes)) {
 FLAG_SET_DEFAULT(MinHeapDeltaBytes, 64*M);
 }
-// For those collectors or operating systems (eg, Windows) that do
+}
-// not support full UseNUMA, we will map to UseNUMAInterleaving for now
+// UseNUMAInterleaving is set to ON for all collectors and
-UseNUMAInterleaving = true;
+// platforms when UseNUMA is set to ON. NUMA-aware collectors
-}
+// such as the parallel collector for Linux and Solaris will
-}
+// interleave old gen and survivor spaces on top of NUMA
-#endif // INCLUDE_ALL_GCS
+// allocation policy for the eden space.
+// Non NUMA-aware collectors such as CMS, G1 and Serial-GC on
+// all platforms and ParallelGC on Windows will interleave all
+// of the heap spaces across NUMA nodes.
+if (FLAG_IS_DEFAULT(UseNUMAInterleaving)) {
+FLAG_SET_ERGO(bool, UseNUMAInterleaving, true);
+}
+}
 return JNI_OK;
 }
 int Arguments::PropertyList_count(SystemProperty* pl) {
 int count = 0;

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 20804:7848fc12602b