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

comparison src/share/vm/runtime/arguments.cpp @ 7066:7d815d842ee0

Merge.

author	Christian Haeubl <haeubl@ssw.jku.at>
date	Fri, 23 Nov 2012 11:50:27 +0100
parents	8c5333c80cfd 49f0841607b7
children	1baf7f1e3f23

comparison

equal deleted inserted replaced

-:cfacf5d5bade
+:7d815d842ee0
 *
 */
 #include "precompiled.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"
 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) },
 #ifdef PRODUCT
 { "DesiredMethodLimit",
 JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },
 #endif // PRODUCT
 { NULL, JDK_Version(0), JDK_Version(0) }
 }
 if (num_jvm_args() > 0) {
 st->print("jvm_args: "); print_jvm_args_on(st);
 }
 st->print_cr("java_command: %s", java_command() ? java_command() : "<unknown>");
+if (_java_class_path != NULL) {
+char* path = _java_class_path->value();
+st->print_cr("java_class_path (initial): %s", strlen(path) == 0 ? "<not set>" : path );
+}
 st->print_cr("Launcher Type: %s", _sun_java_launcher);
 }
 void Arguments::print_jvm_flags_on(outputStream* st) {
 if (_num_jvm_flags > 0) {
 bool in_quote       = false;
 char quote_c        = 0;
 bool result         = true;
 int c = getc(stream);
-while(c != EOF) {
+while(c != EOF && pos < (int)(sizeof(token)-1)) {
 if (in_white_space) {
 if (in_comment) {
 if (c == '\n') in_comment = false;
 } else {
 if (c == '#') in_comment = true;
 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
 FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 2);
 }
 }
-#ifndef KERNEL
+#if INCLUDE_ALTERNATE_GCS
 static void disable_adaptive_size_policy(const char* collector_name) {
 if (UseAdaptiveSizePolicy) {
 if (FLAG_IS_CMDLINE(UseAdaptiveSizePolicy)) {
 warning("disabling UseAdaptiveSizePolicy; it is incompatible with %s.",
 collector_name);
 FLAG_SET_DEFAULT(UseParNewGC, false);
 FLAG_SET_DEFAULT(ParallelGCThreads, 0);
 }
 }
 if (UseParNewGC) {
-// CDS doesn't work with ParNew yet
-no_shared_spaces();
 // By default YoungPLABSize and OldPLABSize are set to 4096 and 1024 respectively,
 // these settings are default for Parallel Scavenger. For ParNew+Tenured configuration
 // we set them to 1024 and 1024.
 // See CR 6362902.
 if (FLAG_IS_DEFAULT(YoungPLABSize)) {
 }
 // AlwaysTenure flag should make ParNew promote all at first collection.
 // See CR 6362902.
 if (AlwaysTenure) {
-FLAG_SET_CMDLINE(intx, MaxTenuringThreshold, 0);
+FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0);
 }
 // When using compressed oops, we use local overflow stacks,
 // rather than using a global overflow list chained through
 // the klass word of the object's pre-image.
 if (UseCompressedOops && !ParGCUseLocalOverflow) {
 // unless explicitly forbidden.
 if (FLAG_IS_DEFAULT(UseParNewGC)) {
 FLAG_SET_ERGO(bool, UseParNewGC, true);
 }
-// Turn off AdaptiveSizePolicy for CMS until it is complete.
+// Turn off AdaptiveSizePolicy by default for cms until it is complete.
 disable_adaptive_size_policy("UseConcMarkSweepGC");
 // In either case, adjust ParallelGCThreads and/or UseParNewGC
 // as needed.
 if (UseParNewGC) {
 }
 // Unless explicitly requested otherwise, definitely
 // promote all objects surviving "tenuring_default" scavenges.
 if (FLAG_IS_DEFAULT(MaxTenuringThreshold) &&
 FLAG_IS_DEFAULT(SurvivorRatio)) {
-FLAG_SET_ERGO(intx, MaxTenuringThreshold, tenuring_default);
+FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default);
 }
 // If we decided above (or user explicitly requested)
 // `promote all' (via MaxTenuringThreshold := 0),
 // prefer minuscule survivor spaces so as not to waste
 // space for (non-existent) survivors
 tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
 MarkStackSize / K, MarkStackSizeMax / K);
 tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
 }
 }
-#endif // KERNEL
+#endif // INCLUDE_ALTERNATE_GCS
 void set_object_alignment() {
 // Object alignment.
 assert(is_power_of_2(ObjectAlignmentInBytes), "ObjectAlignmentInBytes must be power of 2");
 MinObjAlignmentInBytes     = ObjectAlignmentInBytes;
 LogMinObjAlignment         = LogMinObjAlignmentInBytes - LogHeapWordSize;
 // Oop encoding heap max
 OopEncodingHeapMax = (uint64_t(max_juint) + 1) << LogMinObjAlignmentInBytes;
-#ifndef KERNEL
+#if INCLUDE_ALTERNATE_GCS
 // Set CMS global values
 CompactibleFreeListSpace::set_cms_values();
-#endif // KERNEL
+#endif // INCLUDE_ALTERNATE_GCS
 }
 bool verify_object_alignment() {
 // Object alignment.
 if (!is_power_of_2(ObjectAlignmentInBytes)) {
 return true;
 }
 inline uintx max_heap_for_compressed_oops() {
 // Avoid sign flip.
-if (OopEncodingHeapMax < MaxPermSize + os::vm_page_size()) {
+if (OopEncodingHeapMax < ClassMetaspaceSize + os::vm_page_size()) {
 return 0;
 }
-LP64_ONLY(return OopEncodingHeapMax - MaxPermSize - os::vm_page_size());
+LP64_ONLY(return OopEncodingHeapMax - ClassMetaspaceSize - os::vm_page_size());
 NOT_LP64(ShouldNotReachHere(); return 0);
 }
 bool Arguments::should_auto_select_low_pause_collector() {
 if (UseAutoGCSelectPolicy &&
 }
 return false;
 }
 void Arguments::set_ergonomics_flags() {
-// Parallel GC is not compatible with sharing. If one specifies
-// that they want sharing explicitly, do not set ergonomics flags.
-if (DumpSharedSpaces || RequireSharedSpaces) {
-return;
-}
 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 &&
-!DumpSharedSpaces &&
 FLAG_IS_DEFAULT(UseParallelGC)) {
 if (should_auto_select_low_pause_collector()) {
 FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
 } else {
 FLAG_SET_ERGO(bool, UseParallelGC, true);
 }
+}
+// Shared spaces work fine with other GCs but causes bytecode rewriting
+// to be disabled, which hurts interpreter performance and decreases
+// server performance.   On server class machines, 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) {
 no_shared_spaces();
 }
 }
 #ifndef ZERO
 #endif //  _WIN64
 } else {
 if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) {
 warning("Max heap size too large for Compressed Oops");
 FLAG_SET_DEFAULT(UseCompressedOops, false);
+FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
+}
+}
+// UseCompressedOops must be on for UseCompressedKlassPointers to be on.
+if (!UseCompressedOops) {
+if (UseCompressedKlassPointers) {
+warning("UseCompressedKlassPointers requires UseCompressedOops");
+}
+FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
+} else {
+// Turn on UseCompressedKlassPointers too
+if (FLAG_IS_DEFAULT(UseCompressedKlassPointers)) {
+FLAG_SET_ERGO(bool, UseCompressedKlassPointers, true);
+}
+// Set the ClassMetaspaceSize to something that will not need to be
+// expanded, since it cannot be expanded.
+if (UseCompressedKlassPointers && FLAG_IS_DEFAULT(ClassMetaspaceSize)) {
+// 100,000 classes seems like a good size, so 100M assumes around 1K
+// per klass.   The vtable and oopMap is embedded so we don't have a fixed
+// size per klass.   Eventually, this will be parameterized because it
+// would also be useful to determine the optimal size of the
+// systemDictionary.
+FLAG_SET_ERGO(uintx, ClassMetaspaceSize, 100*M);
 }
 }
 // Also checks that certain machines are slower with compressed oops
 // in vm_version initialization code.
 #endif // _LP64
 // Par compact uses lower default values since they are treated as
 // minimums.  These are different defaults because of the different
 // interpretation and are not ergonomically set.
 if (FLAG_IS_DEFAULT(MarkSweepDeadRatio)) {
 FLAG_SET_DEFAULT(MarkSweepDeadRatio, 1);
-}
-if (FLAG_IS_DEFAULT(PermMarkSweepDeadRatio)) {
-FLAG_SET_DEFAULT(PermMarkSweepDeadRatio, 5);
 }
 }
 }
 if (UseNUMA) {
 if (FLAG_IS_DEFAULT(MinHeapDeltaBytes)) {
 Abstract_VM_Version::parallel_worker_threads());
 if (ParallelGCThreads == 0) {
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 }
-no_shared_spaces();
 if (FLAG_IS_DEFAULT(MarkStackSize)) {
 FLAG_SET_DEFAULT(MarkStackSize, 128 * TASKQUEUE_SIZE);
 }
 if (PrintGCDetails && Verbose) {
 status = false;
 }
 status = status && verify_percentage(AdaptiveSizePolicyWeight,
 "AdaptiveSizePolicyWeight");
-status = status && verify_percentage(AdaptivePermSizeWeight, "AdaptivePermSizeWeight");
 status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance");
 status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio");
 status = status && verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio");
+// Divide by bucket size to prevent a large size from causing rollover when
+// calculating amount of memory needed to be allocated for the String table.
+status = status && verify_interval(StringTableSize, defaultStringTableSize,
+(max_uintx / StringTable::bucket_size()), "StringTable size");
 if (MinHeapFreeRatio > MaxHeapFreeRatio) {
 jio_fprintf(defaultStream::error_stream(),
 "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
 "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
 status = status && verify_interval(TLABWasteTargetPercent,
 1, 100, "TLABWasteTargetPercent");
 status = status && verify_object_alignment();
+status = status && verify_min_value(ClassMetaspaceSize, 1*M,
+"ClassMetaspaceSize");
+#ifdef SPARC
+if (UseConcMarkSweepGC || UseG1GC) {
+// Issue a stern warning if the user has explicitly set
+// UseMemSetInBOT (it is known to cause issues), but allow
+// use for experimentation and debugging.
+if (VM_Version::is_sun4v() && UseMemSetInBOT) {
+assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error");
+warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability"
+" on sun4v; please understand that you are using at your own risk!");
+}
+}
+#endif // SPARC
+if (PrintNMTStatistics) {
+#if INCLUDE_NMT
+if (MemTracker::tracking_level() == MemTracker::NMT_off) {
+#endif // INCLUDE_NMT
+warning("PrintNMTStatistics is disabled, because native memory tracking is not enabled");
+PrintNMTStatistics = false;
+#if INCLUDE_NMT
+}
+#endif
+}
 #ifdef GRAAL
 if (UseCompressedOops) {
 jio_fprintf(defaultStream::error_stream(),
 "CompressedOops are not supported in Graal at the moment\n");
 status = false;
 }
+if (UseCompressedKlassPointers) {
+jio_fprintf(defaultStream::error_stream(),
+"UseCompressedKlassPointers are not supported in Graal at the moment\n");
+status = false;
+}
 if (UseG1GC) {
 jio_fprintf(defaultStream::error_stream(),
 "G1 is not supported in Graal at the moment\n");
 status = false;
 }
+if (!ScavengeRootsInCode) {
+warning("forcing ScavengeRootsInCode non-zero because Graal is enabled");
+ScavengeRootsInCode = 1;
+}
 #endif
 return status;
 }
 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
 const char* option_type) {
 char *options = NULL;
 if(pos != NULL) {
 size_t len2 = strlen(pos+1) + 1; // options start after ':'.  Final zero must be copied.
 options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2);
 }
-#ifdef JVMTI_KERNEL
+#if !INCLUDE_JVMTI
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
-warning("profiling and debugging agents are not supported with Kernel VM");
+warning("profiling and debugging agents are not supported in this VM");
 } else
-#endif // JVMTI_KERNEL
+#endif // !INCLUDE_JVMTI
 add_init_library(name, options);
 }
 // -agentlib and -agentpath
 } else if (match_option(option, "-agentlib:", &tail) ||
 (is_absolute_path = match_option(option, "-agentpath:", &tail))) {
 if(tail != NULL) {
 char *options = NULL;
 if(pos != NULL) {
 options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1);
 }
-#ifdef JVMTI_KERNEL
+#if !INCLUDE_JVMTI
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
-warning("profiling and debugging agents are not supported with Kernel VM");
+warning("profiling and debugging agents are not supported in this VM");
 } else
-#endif // JVMTI_KERNEL
+#endif // !INCLUDE_JVMTI
 add_init_agent(name, options, is_absolute_path);
 }
 // -javaagent
 } else if (match_option(option, "-javaagent:", &tail)) {
+#if !INCLUDE_JVMTI
+warning("Instrumentation agents are not supported in this VM");
+#else
 if(tail != NULL) {
 char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail);
 add_init_agent("instrument", options, false);
 }
+#endif // !INCLUDE_JVMTI
 // -Xnoclassgc
 } else if (match_option(option, "-Xnoclassgc", &tail)) {
 FLAG_SET_CMDLINE(bool, ClassUnloading, false);
 // -Xincgc: i-CMS
 } else if (match_option(option, "-Xincgc", &tail)) {
 // -Xoptimize
 } else if (match_option(option, "-Xoptimize", &tail)) {
 // EVM option, ignore silently for compatibility
 // -Xprof
 } else if (match_option(option, "-Xprof", &tail)) {
-#ifndef FPROF_KERNEL
+#if INCLUDE_FPROF
 _has_profile = true;
-#else // FPROF_KERNEL
+#else // INCLUDE_FPROF
 // do we have to exit?
-warning("Kernel VM does not support flat profiling.");
+warning("Flat profiling is not supported in this VM.");
-#endif // FPROF_KERNEL
+#endif // INCLUDE_FPROF
 // -Xaprof
 } else if (match_option(option, "-Xaprof", &tail)) {
 _has_alloc_profile = true;
 // -Xconcurrentio
 } else if (match_option(option, "-Xconcurrentio", &tail)) {
 // for testing the compiler; turn off all flags that inhibit compilation
 set_mode_flags(_comp);
 // -Xshare:dump
 } else if (match_option(option, "-Xshare:dump", &tail)) {
-#ifdef TIERED
+#if defined(KERNEL)
-FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true);
-set_mode_flags(_int);     // Prevent compilation, which creates objects
-#elif defined(COMPILER2)
-vm_exit_during_initialization(
-"Dumping a shared archive is not supported on the Server JVM.", NULL);
-#elif defined(KERNEL)
 vm_exit_during_initialization(
 "Dumping a shared archive is not supported on the Kernel JVM.", NULL);
+#elif !INCLUDE_CDS
+vm_exit_during_initialization(
+"Dumping a shared archive is not supported in this VM.", NULL);
 #else
 FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true);
 set_mode_flags(_int);     // Prevent compilation, which creates objects
 #endif
 // -Xshare:on
 FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true);
 // JNI hooks
 } else if (match_option(option, "-Xcheck", &tail)) {
 if (!strcmp(tail, ":jni")) {
+#if !INCLUDE_JNI_CHECK
+warning("JNI CHECKING is not supported in this VM");
+#else
 CheckJNICalls = true;
+#endif // INCLUDE_JNI_CHECK
 } else if (is_bad_option(option, args->ignoreUnrecognized,
 "check")) {
 return JNI_EINVAL;
 }
 } else if (match_option(option, "vfprintf", &tail)) {
 // Make sure that if we have a lot of memory we cap the 32 bit
 // process space.  The 64bit VM version of this function is a nop.
 initHeapSize = os::allocatable_physical_memory(initHeapSize);
-// The perm gen is separate but contiguous with the
-// object heap (and is reserved with it) so subtract it
-// from the heap size.
-if (initHeapSize > MaxPermSize) {
-initHeapSize = initHeapSize - MaxPermSize;
-} else {
-warning("AggressiveHeap and MaxPermSize values may conflict");
-}
 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
 FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize);
 FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize);
 // Currently the minimum size and the initial heap sizes are the same.
 set_min_heap_size(initHeapSize);
 FLAG_SET_CMDLINE(uintx, NewSize,
 ((julong)MaxHeapSize / (julong)8) * (julong)3);
 FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize);
 }
+#ifndef _ALLBSD_SOURCE  // UseLargePages is not yet supported on BSD.
 FLAG_SET_DEFAULT(UseLargePages, true);
+#endif
 // Increase some data structure sizes for efficiency
 FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize);
 FLAG_SET_CMDLINE(bool, ResizeTLAB, false);
 FLAG_SET_CMDLINE(uintx, TLABSize, 256*K);
 option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
 FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size);
+} else if (match_option(option, "-XX:+UseVMInterruptibleIO", &tail)) {
+// NOTE! In JDK 9, the UseVMInterruptibleIO flag will completely go
+//       away and will cause VM initialization failures!
+warning("-XX:+UseVMInterruptibleIO is obsolete and will be removed in a future release.");
+FLAG_SET_CMDLINE(bool, UseVMInterruptibleIO, true);
 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx
 // Skip -XX:Flags= since that case has already been handled
 if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) {
 if (!process_argument(tail, args->ignoreUnrecognized, origin)) {
 return JNI_EINVAL;
 }
 }
 // Change the default value for flags  which have different default values
 // when working with older JDKs.
-if (JDK_Version::current().compare_major(6) <= 0 &&
-FLAG_IS_DEFAULT(UseVMInterruptibleIO)) {
-FLAG_SET_DEFAULT(UseVMInterruptibleIO, true);
-}
 #ifdef LINUX
 if (JDK_Version::current().compare_major(6) <= 0 &&
 FLAG_IS_DEFAULT(UseLinuxPosixThreadCPUClocks)) {
 FLAG_SET_DEFAULT(UseLinuxPosixThreadCPUClocks, false);
 }
 void Arguments::set_shared_spaces_flags() {
 const bool must_share = DumpSharedSpaces || RequireSharedSpaces;
 const bool might_share = must_share || UseSharedSpaces;
-// The string table is part of the shared archive so the size must match.
+// CompressedOops cannot be used with CDS.  The offsets of oopmaps and
-if (!FLAG_IS_DEFAULT(StringTableSize)) {
+// static fields are incorrect in the archive.  With some more clever
-// Disable sharing.
+// initialization, this restriction can probably be lifted.
-if (must_share) {
+// ??? UseLargePages might be okay now
-warning("disabling shared archive %s because of non-default "
+const bool cannot_share = UseCompressedOops ||
-"StringTableSize", DumpSharedSpaces ? "creation" : "use");
+(UseLargePages && FLAG_IS_CMDLINE(UseLargePages));
-}
-if (might_share) {
-FLAG_SET_DEFAULT(DumpSharedSpaces, false);
-FLAG_SET_DEFAULT(RequireSharedSpaces, false);
-FLAG_SET_DEFAULT(UseSharedSpaces, false);
-}
-return;
-}
-// Check whether class data sharing settings conflict with GC, compressed oops
-// or page size, and fix them up.  Explicit sharing options override other
-// settings.
-const bool cannot_share = UseConcMarkSweepGC || CMSIncrementalMode ||
-UseG1GC || UseParNewGC || UseParallelGC || UseParallelOldGC ||
-UseCompressedOops || UseLargePages && FLAG_IS_CMDLINE(UseLargePages);
 if (cannot_share) {
 if (must_share) {
-warning("selecting serial gc and disabling large pages %s"
+warning("disabling large pages %s"
 "because of %s", "" LP64_ONLY("and compressed oops "),
 DumpSharedSpaces ? "-Xshare:dump" : "-Xshare:on");
-force_serial_gc();
 FLAG_SET_CMDLINE(bool, UseLargePages, false);
 LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedOops, false));
+LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedKlassPointers, false));
 } else {
+// Prefer compressed oops and large pages to class data sharing
 if (UseSharedSpaces && Verbose) {
-warning("turning off use of shared archive because of "
+warning("turning off use of shared archive because of large pages%s",
-"choice of garbage collector or large pages");
+"" LP64_ONLY(" and/or compressed oops"));
 }
 no_shared_spaces();
 }
 } else if (UseLargePages && might_share) {
 // Disable large pages to allow shared spaces.  This is sub-optimal, since
 // there may not even be a shared archive to use.
 FLAG_SET_DEFAULT(UseLargePages, false);
+}
+// Add 2M to any size for SharedReadOnlySize to get around the JPRT setting
+if (DumpSharedSpaces && !FLAG_IS_DEFAULT(SharedReadOnlySize)) {
+SharedReadOnlySize = 14*M;
+}
+if (DumpSharedSpaces) {
+if (RequireSharedSpaces) {
+warning("cannot dump shared archive while using shared archive");
+}
+UseSharedSpaces = false;
 }
 }
 // Disable options not supported in this release, with a warning if they
 // were explicitly requested on the command-line
 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) {
 CommandLineFlags::printFlags(tty, false);
 vm_exit(0);
 }
 if (match_option(option, "-XX:NativeMemoryTracking", &tail)) {
+#if INCLUDE_NMT
 MemTracker::init_tracking_options(tail);
+#else
+warning("Native Memory Tracking is not supported in this VM");
+#endif
 }
 #ifndef PRODUCT
 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) {
 #if (defined JAVASE_EMBEDDED || defined ARM)
 UNSUPPORTED_OPTION(UseG1GC, "G1 GC");
 #endif
+#ifdef _ALLBSD_SOURCE  // UseLargePages is not yet supported on BSD.
+UNSUPPORTED_OPTION(UseLargePages, "-XX:+UseLargePages");
+#endif
+#if !INCLUDE_ALTERNATE_GCS
+if (UseParallelGC) {
+warning("Parallel GC is not supported in this VM.  Using Serial GC.");
+}
+if (UseParallelOldGC) {
+warning("Parallel Old GC is not supported in this VM.  Using Serial GC.");
+}
+if (UseConcMarkSweepGC) {
+warning("Concurrent Mark Sweep GC is not supported in this VM.  Using Serial GC.");
+}
+if (UseParNewGC) {
+warning("Par New GC is not supported in this VM.  Using Serial GC.");
+}
+#endif // INCLUDE_ALTERNATE_GCS
 #ifndef PRODUCT
 if (TraceBytecodesAt != 0) {
 TraceBytecodes = true;
 }
 if (CountCompiledCalls) {
 if (!FLAG_IS_DEFAULT(ScavengeRootsInCode)) {
 warning("forcing ScavengeRootsInCode non-zero because EnableInvokeDynamic is true");
 }
 ScavengeRootsInCode = 1;
 }
-if (!JavaObjectsInPerm && ScavengeRootsInCode == 0) {
-if (!FLAG_IS_DEFAULT(ScavengeRootsInCode)) {
-warning("forcing ScavengeRootsInCode non-zero because JavaObjectsInPerm is false");
-}
-ScavengeRootsInCode = 1;
-}
 if (PrintGCDetails) {
 // Turn on -verbose:gc options as well
 PrintGC = true;
 }
 set_object_alignment();
 #ifdef SERIALGC
 force_serial_gc();
 #endif // SERIALGC
-#ifdef KERNEL
+#if !INCLUDE_CDS
 no_shared_spaces();
-#endif // KERNEL
+#endif // INCLUDE_CDS
 // Set flags based on ergonomics.
 set_ergonomics_flags();
 set_shared_spaces_flags();
 vm_exit_during_initialization(
 "Incompatible compilation policy selected", NULL);
 }
 }
-#ifndef KERNEL
 // Set heap size based on available physical memory
 set_heap_size();
+#if INCLUDE_ALTERNATE_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();
 }
-#endif // KERNEL
+#endif // INCLUDE_ALTERNATE_GCS
 #ifdef SERIALGC
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // SERIALGC
 #ifdef CC_INTERP
 // Clear flags not supported by the C++ interpreter
 FLAG_SET_DEFAULT(ProfileInterpreter, false);
 FLAG_SET_DEFAULT(UseBiasedLocking, false);
 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false));
+LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedKlassPointers, false));
 #endif // CC_INTERP
 #ifdef COMPILER2
 if (!UseBiasedLocking || EmitSync != 0) {
 UseOptoBiasInlining = false;

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 7066:7d815d842ee0