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

comparison src/share/vm/runtime/arguments.cpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	ba37b9335e1e 2db84614f61d
children	06f017f7daa7

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1997-2010 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1997, 2010, 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.
 *
 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 #include "incls/_precompiled.incl"
 #include "incls/_arguments.cpp.incl"
 // 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;
-intx   Arguments::_Tier2CompileThreshold        = Tier2CompileThreshold;
 char*  Arguments::SharedArchivePath             = NULL;
 AgentLibraryList Arguments::_libraryList;
 AgentLibraryList Arguments::_agentList;
 void Arguments::init_system_properties() {
 PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.version", "1.0", false));
 PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name",
 "Java Virtual Machine Specification",  false));
-PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.vendor",
-"Sun Microsystems Inc.",  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.vendor", VM_Version::vm_vendor(),  false));
 PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(),  true));
 // following are JVMTI agent writeable properties.
 // Properties values are set to NULL and they are
 // os specific they are initialized in os::init_system_properties_values().
 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() {
+PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.vendor",
+JDK_Version::is_gte_jdk17x_version() ? "Oracle Corporation" : "Sun Microsystems Inc.", 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
 { "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) },
 { 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'
 // use the saved values
 ClipInlining               = Arguments::_ClipInlining;
 AlwaysCompileLoopMethods   = Arguments::_AlwaysCompileLoopMethods;
 UseOnStackReplacement      = Arguments::_UseOnStackReplacement;
 BackgroundCompilation      = Arguments::_BackgroundCompilation;
-Tier2CompileThreshold      = Arguments::_Tier2CompileThreshold;
 // Change from defaults based on mode
 switch (mode) {
 default:
 ShouldNotReachHere();
 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);
 } else {
 FLAG_SET_DEFAULT(UseSharedSpaces, false);
+}
+}
+void Arguments::check_compressed_oops_compat() {
+#ifdef _LP64
+assert(UseCompressedOops, "Precondition");
+#  if defined(COMPILER1) && !defined(TIERED)
+// Until c1 supports compressed oops turn them off.
+FLAG_SET_DEFAULT(UseCompressedOops, false);
+#  else
+// Is it on by default or set on ergonomically
+bool is_on_by_default = FLAG_IS_DEFAULT(UseCompressedOops) || FLAG_IS_ERGO(UseCompressedOops);
+// Tiered currently doesn't work with compressed oops
+if (TieredCompilation) {
+if (is_on_by_default) {
+FLAG_SET_DEFAULT(UseCompressedOops, false);
+return;
+} else {
+vm_exit_during_initialization(
+"Tiered compilation is not supported with compressed oops yet", NULL);
+}
+}
+// If dumping an archive or forcing its use, disable compressed oops if possible
+if (DumpSharedSpaces || RequireSharedSpaces) {
+if (is_on_by_default) {
+FLAG_SET_DEFAULT(UseCompressedOops, false);
+return;
+} else {
+vm_exit_during_initialization(
+"Class Data Sharing is not supported with compressed oops yet", NULL);
+}
+} else if (UseSharedSpaces) {
+// UseSharedSpaces is on by default. With compressed oops, we turn it off.
+FLAG_SET_DEFAULT(UseSharedSpaces, false);
+}
+#  endif // defined(COMPILER1) && !defined(TIERED)
+#endif // _LP64
+}
+void Arguments::set_tiered_flags() {
+if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) {
+FLAG_SET_DEFAULT(CompilationPolicyChoice, 2);
+}
+if (CompilationPolicyChoice < 2) {
+vm_exit_during_initialization(
+"Incompatible compilation policy selected", NULL);
+}
+// Increase the code cache size - tiered compiles a lot more.
+if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
+FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 2);
 }
 }
 #ifndef KERNEL
 // If the user has chosen ParallelGCThreads > 0, we set UseParNewGC
 tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
 }
 }
 #endif // KERNEL
+void set_object_alignment() {
+// Object alignment.
+assert(is_power_of_2(ObjectAlignmentInBytes), "ObjectAlignmentInBytes must be power of 2");
+MinObjAlignmentInBytes     = ObjectAlignmentInBytes;
+assert(MinObjAlignmentInBytes >= HeapWordsPerLong * HeapWordSize, "ObjectAlignmentInBytes value is too small");
+MinObjAlignment            = MinObjAlignmentInBytes / HeapWordSize;
+assert(MinObjAlignmentInBytes == MinObjAlignment * HeapWordSize, "ObjectAlignmentInBytes value is incorrect");
+MinObjAlignmentInBytesMask = MinObjAlignmentInBytes - 1;
+LogMinObjAlignmentInBytes  = exact_log2(ObjectAlignmentInBytes);
+LogMinObjAlignment         = LogMinObjAlignmentInBytes - LogHeapWordSize;
+// Oop encoding heap max
+OopEncodingHeapMax = (uint64_t(max_juint) + 1) << LogMinObjAlignmentInBytes;
+#ifndef KERNEL
+// Set CMS global values
+CompactibleFreeListSpace::set_cms_values();
+#endif // KERNEL
+}
+bool verify_object_alignment() {
+// Object alignment.
+if (!is_power_of_2(ObjectAlignmentInBytes)) {
+jio_fprintf(defaultStream::error_stream(),
+"error: ObjectAlignmentInBytes=%d must be power of 2\n",
+(int)ObjectAlignmentInBytes);
+return false;
+}
+if ((int)ObjectAlignmentInBytes < BytesPerLong) {
+jio_fprintf(defaultStream::error_stream(),
+"error: ObjectAlignmentInBytes=%d must be greater or equal %d\n",
+(int)ObjectAlignmentInBytes, BytesPerLong);
+return false;
+}
+// It does not make sense to have big object alignment
+// since a space lost due to alignment will be greater
+// then a saved space from compressed oops.
+if ((int)ObjectAlignmentInBytes > 256) {
+jio_fprintf(defaultStream::error_stream(),
+"error: ObjectAlignmentInBytes=%d must not be greater then 256\n",
+(int)ObjectAlignmentInBytes);
+return false;
+}
+// In case page size is very small.
+if ((int)ObjectAlignmentInBytes >= os::vm_page_size()) {
+jio_fprintf(defaultStream::error_stream(),
+"error: ObjectAlignmentInBytes=%d must be less then page size %d\n",
+(int)ObjectAlignmentInBytes, os::vm_page_size());
+return false;
+}
+return true;
+}
 inline uintx max_heap_for_compressed_oops() {
-LP64_ONLY(return oopDesc::OopEncodingHeapMax - MaxPermSize - os::vm_page_size());
+// Heap should be above HeapBaseMinAddress to get zero based compressed oops.
+LP64_ONLY(return OopEncodingHeapMax - MaxPermSize - os::vm_page_size() - HeapBaseMinAddress);
 NOT_LP64(ShouldNotReachHere(); return 0);
 }
 bool Arguments::should_auto_select_low_pause_collector() {
 if (UseAutoGCSelectPolicy &&
 #ifndef ZERO
 #ifdef _LP64
 // Check that UseCompressedOops can be set with the max heap size allocated
 // by ergonomics.
 if (MaxHeapSize <= max_heap_for_compressed_oops()) {
-#ifndef COMPILER1
+#if !defined(COMPILER1) || defined(TIERED)
 if (FLAG_IS_DEFAULT(UseCompressedOops) && !UseG1GC) {
 FLAG_SET_ERGO(bool, UseCompressedOops, true);
 }
 #endif
 #ifdef _WIN64
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 }
 no_shared_spaces();
-// Set the maximum pause time goal to be a reasonable default.
-if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
-FLAG_SET_DEFAULT(MaxGCPauseMillis, 200);
-}
 if (FLAG_IS_DEFAULT(MarkStackSize)) {
 FLAG_SET_DEFAULT(MarkStackSize, 128 * TASKQUEUE_SIZE);
 }
 if (PrintGCDetails && Verbose) {
 tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
 FLAG_SET_DEFAULT(DoEscapeAnalysis, true);
 }
 if (AggressiveOpts && FLAG_IS_DEFAULT(BiasedLockingStartupDelay)) {
 FLAG_SET_DEFAULT(BiasedLockingStartupDelay, 500);
 }
+if (AggressiveOpts && FLAG_IS_DEFAULT(OptimizeStringConcat)) {
+FLAG_SET_DEFAULT(OptimizeStringConcat, true);
+}
+if (AggressiveOpts && FLAG_IS_DEFAULT(OptimizeFill)) {
+FLAG_SET_DEFAULT(OptimizeFill, true);
+}
 #endif
 if (AggressiveOpts) {
 // Sample flag setting code
 //    if (FLAG_IS_DEFAULT(EliminateZeroing)) {
 }
 jio_fprintf(defaultStream::error_stream(),
 "%s of " UINTX_FORMAT " is invalid; must be between " UINTX_FORMAT
 " and " UINTX_FORMAT "\n",
 name, val, min, max);
+return false;
+}
+bool Arguments::verify_min_value(intx val, intx min, const char* name) {
+// Returns true if given value is greater than specified min threshold
+// false, otherwise.
+if (val >= min ) {
+return true;
+}
+jio_fprintf(defaultStream::error_stream(),
+"%s of " INTX_FORMAT " is invalid; must be greater than " INTX_FORMAT "\n",
+name, val, min);
 return false;
 }
 bool Arguments::verify_percentage(uintx value, const char* name) {
 if (value <= 100) {
 }
 return status;
 }
+// Check stack pages settings
+bool Arguments::check_stack_pages()
+{
+bool status = true;
+status = status && verify_min_value(StackYellowPages, 1, "StackYellowPages");
+status = status && verify_min_value(StackRedPages, 1, "StackRedPages");
+// greater stack shadow pages can't generate instruction to bang stack
+status = status && verify_interval(StackShadowPages, 1, 50, "StackShadowPages");
+return status;
+}
 // Check the consistency of vm_init_args
 bool Arguments::check_vm_args_consistency() {
 // Method for adding checks for flag consistency.
 // The intent is to warn the user of all possible conflicts,
 // before returning an error.
 "not " SIZE_FORMAT "\n",
 TLABRefillWasteFraction);
 status = false;
 }
-status = status && verify_percentage(MaxLiveObjectEvacuationRatio,
-"MaxLiveObjectEvacuationRatio");
 status = status && verify_percentage(AdaptiveSizePolicyWeight,
 "AdaptiveSizePolicyWeight");
 status = status && verify_percentage(AdaptivePermSizeWeight, "AdaptivePermSizeWeight");
 status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance");
 status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio");
 FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
 }
 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
-// Check user specified sharing option conflict with Parallel GC
+// Check whether user-specified sharing option conflicts with GC or page size.
-bool cannot_share = ((UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC || UseParNewGC ||
+// Both sharing and large pages are enabled by default on some platforms;
-UseParallelGC || UseParallelOldGC ||
+// large pages override sharing only if explicitly set on the command line.
-SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages));
+const bool cannot_share = UseConcMarkSweepGC || CMSIncrementalMode ||
+UseG1GC || UseParNewGC || UseParallelGC || UseParallelOldGC ||
+UseLargePages && FLAG_IS_CMDLINE(UseLargePages);
 if (cannot_share) {
 // Either force sharing on by forcing the other options off, or
 // force sharing off.
 if (DumpSharedSpaces || ForceSharedSpaces) {
 jio_fprintf(defaultStream::error_stream(),
-"Reverting to Serial GC because of %s\n",
+"Using Serial GC and default page size because of %s\n",
-ForceSharedSpaces ? " -Xshare:on" : "-Xshare:dump");
+ForceSharedSpaces ? "-Xshare:on" : "-Xshare:dump");
 force_serial_gc();
-FLAG_SET_DEFAULT(SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages), false);
+FLAG_SET_DEFAULT(UseLargePages, false);
 } else {
 if (UseSharedSpaces && Verbose) {
 jio_fprintf(defaultStream::error_stream(),
 "Turning off use of shared archive because of "
 "choice of garbage collector or large pages\n");
 }
 no_shared_spaces();
 }
+} else if (UseLargePages && (UseSharedSpaces || DumpSharedSpaces)) {
+FLAG_SET_DEFAULT(UseLargePages, false);
 }
 status = status && check_gc_consistency();
+status = status && check_stack_pages();
 if (_has_alloc_profile) {
 if (UseParallelGC || UseParallelOldGC) {
 jio_fprintf(defaultStream::error_stream(),
 "error:  invalid argument combination.\n"
 // Limit the lower bound of this flag to 1 as it is used in a division
 // expression.
 status = status && verify_interval(TLABWasteTargetPercent,
 1, 100, "TLABWasteTargetPercent");
+status = status && verify_object_alignment();
 return status;
 }
 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
 const char* option_type) {
 // Save default settings for some mode flags
 Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
 Arguments::_UseOnStackReplacement    = UseOnStackReplacement;
 Arguments::_ClipInlining             = ClipInlining;
 Arguments::_BackgroundCompilation    = BackgroundCompilation;
-Arguments::_Tier2CompileThreshold    = Tier2CompileThreshold;
 // Parse JAVA_TOOL_OPTIONS environment variable (if present)
 jint result = parse_java_tool_options_environment_variable(&scp, &scp_assembly_required);
 if (result != JNI_OK) {
 return result;
 // 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);
+}
+#endif // LINUX
 return JNI_OK;
 }
 jint Arguments::finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required) {
 // This must be done after all -D arguments have been processed.
 set_mode_flags(_int);
 }
 if (CompileThreshold == 0) {
 set_mode_flags(_int);
 }
-#ifdef TIERED
-// If we are using tiered compilation in the tiered vm then c1 will
-// do the profiling and we don't want to waste that time in the
-// interpreter.
-if (TieredCompilation) {
-ProfileInterpreter = false;
-} else {
-// Since we are running vanilla server we must adjust the compile threshold
-// unless the user has already adjusted it because the default threshold assumes
-// we will run tiered.
-if (FLAG_IS_DEFAULT(CompileThreshold)) {
-CompileThreshold = Tier2CompileThreshold;
-}
-}
-#endif // TIERED
 #ifndef COMPILER2
 // Don't degrade server performance for footprint
 if (FLAG_IS_DEFAULT(UseLargePages) &&
 MaxHeapSize < LargePageHeapSizeThreshold) {
 SOLARIS_ONLY(FLAG_SET_DEFAULT(UseISM, false));
 }
 // Tiered compilation is undefined with C1.
 TieredCompilation = false;
 #else
 if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) {
 FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1);
 }
 // Temporary disable bulk zeroing reduction with G1. See CR 6627983.
 if (UseG1GC) {
 FLAG_SET_DEFAULT(ReduceBulkZeroing, false);
 }
 #endif
+// If we are running in a headless jre, force java.awt.headless property
+// to be true unless the property has already been set.
+// Also allow the OS environment variable JAVA_AWT_HEADLESS to set headless state.
+if (os::is_headless_jre()) {
+const char* headless = Arguments::get_property("java.awt.headless");
+if (headless == NULL) {
+char envbuffer[128];
+if (!os::getenv("JAVA_AWT_HEADLESS", envbuffer, sizeof(envbuffer))) {
+if (!add_property("java.awt.headless=true")) {
+return JNI_ENOMEM;
+}
+} else {
+char buffer[256];
+strcpy(buffer, "java.awt.headless=");
+strcat(buffer, envbuffer);
+if (!add_property(buffer)) {
+return JNI_ENOMEM;
+}
+}
+}
+}
 if (!check_vm_args_consistency()) {
 return JNI_ERR;
 }
 return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR));
 }
 return JNI_OK;
 }
 // Parse entry point called from JNI_CreateJavaVM
 jint Arguments::parse(const JavaVMInitArgs* args) {
 // Sharing support
 }
 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) {
 CommandLineFlags::printFlags();
 vm_exit(0);
 }
+#ifndef PRODUCT
+if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) {
+CommandLineFlags::printFlags(true);
+vm_exit(0);
+}
+#endif
 }
 if (IgnoreUnrecognizedVMOptions) {
 // uncast const to modify the flag args->ignoreUnrecognized
 *(jboolean*)(&args->ignoreUnrecognized) = true;
 if (PrintGCDetails) {
 // Turn on -verbose:gc options as well
 PrintGC = true;
 }
-#if defined(_LP64) && defined(COMPILER1)
+// Set object alignment values.
-UseCompressedOops = false;
+set_object_alignment();
-#endif
 #ifdef SERIALGC
 force_serial_gc();
 #endif // SERIALGC
 #ifdef KERNEL
 // Set flags based on ergonomics.
 set_ergonomics_flags();
 #ifdef _LP64
-// XXX JSR 292 currently does not support compressed oops.
+if (UseCompressedOops) {
-if (EnableMethodHandles && UseCompressedOops) {
+check_compressed_oops_compat();
-if (FLAG_IS_DEFAULT(UseCompressedOops) || FLAG_IS_ERGO(UseCompressedOops)) {
+}
-UseCompressedOops = false;
+#endif
-}
-}
-#endif // _LP64
-// MethodHandles code does not support TaggedStackInterpreter.
-if (EnableMethodHandles && TaggedStackInterpreter) {
-warning("TaggedStackInterpreter is not supported by MethodHandles code.  Disabling TaggedStackInterpreter.");
-TaggedStackInterpreter = false;
-}
 // Check the GC selections again.
 if (!check_gc_consistency()) {
 return JNI_EINVAL;
+}
+if (TieredCompilation) {
+set_tiered_flags();
+} else {
+// Check if the policy is valid. Policies 0 and 1 are valid for non-tiered setup.
+if (CompilationPolicyChoice >= 2) {
+vm_exit_during_initialization(
+"Incompatible compilation policy selected", NULL);
+}
 }
 #ifndef KERNEL
 if (UseConcMarkSweepGC) {
 // Set flags for CMS and ParNew.  Check UseConcMarkSweep first
 FLAG_SET_DEFAULT(ProfileInterpreter, false);
 FLAG_SET_DEFAULT(UseBiasedLocking, false);
 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false));
 #endif // CC_INTERP
-#ifdef ZERO
-// Clear flags not supported by Zero
-FLAG_SET_DEFAULT(TaggedStackInterpreter, false);
-#endif // ZERO
 #ifdef COMPILER2
 if (!UseBiasedLocking || EmitSync != 0) {
 UseOptoBiasInlining = false;
 }
 #endif
 if (PrintCommandLineFlags) {
 CommandLineFlags::printSetFlags();
 }
-if (PrintFlagsFinal) {
+// Apply CPU specific policy for the BiasedLocking
-CommandLineFlags::printFlags();
+if (UseBiasedLocking) {
+if (!VM_Version::use_biased_locking() &&
+!(FLAG_IS_CMDLINE(UseBiasedLocking))) {
+UseBiasedLocking = false;
+}
 }
 return JNI_OK;
 }

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 1930:2d26b0046e0d