jdk-sandbox: comparison hotspot/src/share/vm/runtime/arguments.cpp

equal deleted inserted replaced

-:feba5d4126b8
+:82c7497fbad4
 #include "classfile/javaAssertions.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"
 #ifdef TARGET_OS_FAMILY_bsd
 # include "os_bsd.inline.hpp"
 #endif
 #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.sun.com/bugreport/crash.jsp"
 #define DEFAULT_JAVA_LAUNCHER  "generic"
 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;
 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;
 default:
 ShouldNotReachHere();
 }
 }
-static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) {
+static bool set_bool_flag(char* name, bool value, Flag::Flags origin) {
 return CommandLineFlags::boolAtPut(name, &value, origin);
 }
-static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) {
+static bool set_fp_numeric_flag(char* name, char* value, Flag::Flags origin) {
 double v;
 if (sscanf(value, "%lf", &v) != 1) {
 return false;
 }
 return true;
 }
 return false;
 }
-static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) {
+static bool set_numeric_flag(char* name, char* value, Flag::Flags origin) {
 julong v;
 intx intx_v;
 bool is_neg = false;
 // Check the sign first since atomull() parses only unsigned values.
 if (*value == '-') {
 return true;
 }
 return false;
 }
-static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) {
+static bool set_string_flag(char* name, const char* value, Flag::Flags origin) {
 if (!CommandLineFlags::ccstrAtPut(name, &value, origin))  return false;
 // Contract:  CommandLineFlags always returns a pointer that needs freeing.
 FREE_C_HEAP_ARRAY(char, value, mtInternal);
 return true;
 }
-static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) {
+static bool append_to_string_flag(char* name, const char* new_value, Flag::Flags origin) {
 const char* old_value = "";
 if (!CommandLineFlags::ccstrAt(name, &old_value))  return false;
 size_t old_len = old_value != NULL ? strlen(old_value) : 0;
 size_t new_len = strlen(new_value);
 const char* value;
 FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal);
 }
 return true;
 }
-bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) {
+bool Arguments::parse_argument(const char* arg, Flag::Flags origin) {
 // range of acceptable characters spelled out for portability reasons
 #define NAME_RANGE  "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
 #define BUFLEN 255
 char name[BUFLEN+1];
 st->print_cr("");
 }
 }
 bool Arguments::process_argument(const char* arg,
-jboolean ignore_unrecognized, FlagValueOrigin origin) {
+jboolean ignore_unrecognized, Flag::Flags origin) {
 JDK_Version since = JDK_Version();
 if (parse_argument(arg, origin) || ignore_unrecognized) {
 return true;
 Flag* fuzzy_matched = Flag::fuzzy_match((const char*)argname, arg_len, true);
 if (fuzzy_matched != NULL) {
 jio_fprintf(defaultStream::error_stream(),
 "Did you mean '%s%s%s'?\n",
 (fuzzy_matched->is_bool()) ? "(+/-)" : "",
-fuzzy_matched->name,
+fuzzy_matched->_name,
 (fuzzy_matched->is_bool()) ? "" : "=<value>");
 }
 }
 // allow for commandline "commenting out" options like -XX:#+Verbose
 if (c == '\n' || (!in_quote && isspace(c))) {
 // token ends at newline, or at unquoted whitespace
 // this allows a way to include spaces in string-valued options
 token[pos] = '\0';
 logOption(token);
-result &= process_argument(token, ignore_unrecognized, CONFIG_FILE);
+result &= process_argument(token, ignore_unrecognized, Flag::CONFIG_FILE);
 build_jvm_flags(token);
 pos = 0;
 in_white_space = true;
 in_quote = false;
 } else if (!in_quote && (c == '\'' || c == '"')) {
 }
 c = getc(stream);
 }
 if (pos > 0) {
 token[pos] = '\0';
-result &= process_argument(token, ignore_unrecognized, CONFIG_FILE);
+result &= process_argument(token, ignore_unrecognized, Flag::CONFIG_FILE);
 build_jvm_flags(token);
 }
 fclose(stream);
 return result;
 }
 }
 break;
 }
 }
+#if defined(COMPILER2) || defined(_LP64) || !INCLUDE_CDS
 // Conflict: required to use shared spaces (-Xshare:on), but
 // incompatible command line options were chosen.
 static void no_shared_spaces() {
 if (RequireSharedSpaces) {
 vm_exit_during_initialization("Unable to use shared archive.", NULL);
 } else {
 FLAG_SET_DEFAULT(UseSharedSpaces, false);
 }
 }
+#endif
 void Arguments::set_tiered_flags() {
 // With tiered, set default policy to AdvancedThresholdPolicy, which is 3.
 if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) {
 FLAG_SET_DEFAULT(CompilationPolicyChoice, 3);
 FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 5);
 }
 if (!UseInterpreter) { // -Xcomp
 Tier3InvokeNotifyFreqLog = 0;
 Tier4InvocationThreshold = 0;
+}
+if (FLAG_IS_DEFAULT(NmethodSweepFraction)) {
+FLAG_SET_DEFAULT(NmethodSweepFraction, 1 + ReservedCodeCacheSize / (16 * M));
 }
 }
 #if INCLUDE_ALL_GCS
 static void disable_adaptive_size_policy(const char* collector_name) {
 return false;
 }
 return true;
 }
-inline uintx max_heap_for_compressed_oops() {
+uintx Arguments::max_heap_for_compressed_oops() {
 // Avoid sign flip.
 assert(OopEncodingHeapMax > (uint64_t)os::vm_page_size(), "Unusual page size");
-LP64_ONLY(return OopEncodingHeapMax - os::vm_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
+// maximum alignment that the GC may ever impose upon the heap.
+size_t displacement_due_to_null_page = align_size_up_(os::vm_page_size(),
+Arguments::conservative_max_heap_alignment());
+LP64_ONLY(return OopEncodingHeapMax - displacement_due_to_null_page);
 NOT_LP64(ShouldNotReachHere(); return 0);
 }
 bool Arguments::should_auto_select_low_pause_collector() {
 if (UseAutoGCSelectPolicy &&
 #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);
+FLAG_SET_DEFAULT(UseCompressedClassPointers, false);
 }
 }
 #endif // _LP64
 #endif // ZERO
 }
 // NOTE: set_use_compressed_klass_ptrs() must be called after calling
 // set_use_compressed_oops().
 void Arguments::set_use_compressed_klass_ptrs() {
 #ifndef ZERO
 #ifdef _LP64
-// UseCompressedOops must be on for UseCompressedKlassPointers to be on.
+// UseCompressedOops must be on for UseCompressedClassPointers to be on.
 if (!UseCompressedOops) {
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
-warning("UseCompressedKlassPointers requires UseCompressedOops");
+warning("UseCompressedClassPointers requires UseCompressedOops");
 }
-FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
+FLAG_SET_DEFAULT(UseCompressedClassPointers, false);
 } else {
-// Turn on UseCompressedKlassPointers too
+// Turn on UseCompressedClassPointers too
-if (FLAG_IS_DEFAULT(UseCompressedKlassPointers)) {
+if (FLAG_IS_DEFAULT(UseCompressedClassPointers)) {
-FLAG_SET_ERGO(bool, UseCompressedKlassPointers, true);
+FLAG_SET_ERGO(bool, UseCompressedClassPointers, true);
 }
-// Check the ClassMetaspaceSize to make sure we use compressed klass ptrs.
+// Check the CompressedClassSpaceSize to make sure we use compressed klass ptrs.
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
-if (ClassMetaspaceSize > KlassEncodingMetaspaceMax) {
+if (CompressedClassSpaceSize > KlassEncodingMetaspaceMax) {
-warning("Class metaspace size is too large for UseCompressedKlassPointers");
+warning("CompressedClassSpaceSize is too large for UseCompressedClassPointers");
-FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
+FLAG_SET_DEFAULT(UseCompressedClassPointers, false);
 }
 }
 }
 #endif // _LP64
 #endif // !ZERO
+}
+void Arguments::set_conservative_max_heap_alignment() {
+// The conservative maximum required alignment for the heap is the maximum of
+// the alignments imposed by several sources: any requirements from the heap
+// itself, the collector policy and the maximum page size we may run the VM
+// with.
+size_t heap_alignment = GenCollectedHeap::conservative_max_heap_alignment();
+#if INCLUDE_ALL_GCS
+if (UseParallelGC) {
+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(),
+CollectorPolicy::compute_max_alignment());
 }
 void Arguments::set_ergonomics_flags() {
 if (os::is_server_class_machine()) {
 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
+#ifdef COMPILER2
-// server performance.   On server class machines, keep the default
+// Shared spaces work fine with other GCs but causes bytecode rewriting
-// off unless it is asked for.  Future work: either add bytecode rewriting
+// to be disabled, which hurts interpreter performance and decreases
-// at link time, or rewrite bytecodes in non-shared methods.
+// server performance.  When -server is specified, keep the default off
-if (!DumpSharedSpaces && !RequireSharedSpaces &&
+// unless it is asked for.  Future work: either add bytecode rewriting
-(FLAG_IS_DEFAULT(UseSharedSpaces) || !UseSharedSpaces)) {
+// at link time, or rewrite bytecodes in non-shared methods.
-no_shared_spaces();
+if (!DumpSharedSpaces && !RequireSharedSpaces &&
-}
+(FLAG_IS_DEFAULT(UseSharedSpaces) || !UseSharedSpaces)) {
-}
+no_shared_spaces();
+}
+#endif
+set_conservative_max_heap_alignment();
 #ifndef ZERO
 #ifdef _LP64
 set_use_compressed_oops();
 result = MIN2(result, max_allocatable / MaxVirtMemFraction);
 }
 return result;
 }
-void Arguments::set_heap_base_min_address() {
-if (FLAG_IS_DEFAULT(HeapBaseMinAddress) && UseG1GC && HeapBaseMinAddress < 1*G) {
-// By default HeapBaseMinAddress is 2G on all platforms except Solaris x86.
-// G1 currently needs a lot of C-heap, so on Solaris we have to give G1
-// some extra space for the C-heap compared to other collectors.
-// Use FLAG_SET_DEFAULT here rather than FLAG_SET_ERGO to make sure that
-// code that checks for default values work correctly.
-FLAG_SET_DEFAULT(HeapBaseMinAddress, 1*G);
-}
-}
 void Arguments::set_heap_size() {
 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
 // Deprecated flag
 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
 }
 if (UseGCLogFileRotation) {
 if ((Arguments::gc_log_filename() == NULL) ||
 (NumberOfGCLogFiles == 0)  ||
 (GCLogFileSize == 0)) {
 jio_fprintf(defaultStream::output_stream(),
-"To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>\n"
+"To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>[k|K|m|M|g|G]\n"
 "where num_of_file > 0 and num_of_size > 0\n"
 "GC log rotation is turned off\n");
 UseGCLogFileRotation = false;
 }
 }
 if (UseGCLogFileRotation && GCLogFileSize < 8*K) {
 FLAG_SET_CMDLINE(uintx, GCLogFileSize, 8*K);
 jio_fprintf(defaultStream::output_stream(),
 "GCLogFileSize changed to minimum 8K\n");
 }
+}
+// This function is called for -Xloggc:<filename>, it can be used
+// to check if a given file name(or string) conforms to the following
+// specification:
+// A valid string only contains "[A-Z][a-z][0-9].-_%[p|t]"
+// %p and %t only allowed once. We only limit usage of filename not path
+bool is_filename_valid(const char *file_name) {
+const char* p = file_name;
+char file_sep = os::file_separator()[0];
+const char* cp;
+// skip prefix path
+for (cp = file_name; *cp != '\0'; cp++) {
+if (*cp == '/' || *cp == file_sep) {
+p = cp + 1;
+}
+}
+int count_p = 0;
+int count_t = 0;
+while (*p != '\0') {
+if ((*p >= '0' && *p <= '9') ||
+(*p >= 'A' && *p <= 'Z') ||
+(*p >= 'a' && *p <= 'z') ||
+*p == '-'               ||
+*p == '_'               ||
+*p == '.') {
+p++;
+continue;
+}
+if (*p == '%') {
+if(*(p + 1) == 'p') {
+p += 2;
+count_p ++;
+continue;
+}
+if (*(p + 1) == 't') {
+p += 2;
+count_t ++;
+continue;
+}
+}
+return false;
+}
+return count_p < 2 && count_t < 2;
 }
 // Check consistency of GC selection
 bool Arguments::check_gc_consistency() {
 check_gclog_consistency();
 jio_fprintf(defaultStream::error_stream(),
 "Conflicting collector combinations in option list; "
 "please refer to the release notes for the combinations "
 "allowed\n");
 status = false;
-} else if (ReservedCodeCacheSize > 2*G) {
-// Code cache size larger than MAXINT is not supported.
-jio_fprintf(defaultStream::error_stream(),
-"Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
-(2*G)/M);
-status = false;
 }
 return status;
 }
 void Arguments::check_deprecated_gcs() {
 "and will likely be removed in future release");
 }
 if (FLAG_IS_CMDLINE(DefaultMaxRAMFraction)) {
 warning("DefaultMaxRAMFraction is deprecated and will likely be removed in a future release. "
 "Use MaxRAMFraction instead.");
+}
+if (FLAG_IS_CMDLINE(UseCMSCompactAtFullCollection)) {
+warning("UseCMSCompactAtFullCollection is deprecated and will likely be removed in a future release.");
+}
+if (FLAG_IS_CMDLINE(CMSFullGCsBeforeCompaction)) {
+warning("CMSFullGCsBeforeCompaction is deprecated and will likely be removed in a future release.");
+}
+if (FLAG_IS_CMDLINE(UseCMSCollectionPassing)) {
+warning("UseCMSCollectionPassing is deprecated and will likely be removed in a future release.");
 }
 }
 // Check stack pages settings
 bool Arguments::check_stack_pages()
 // 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, minimumStringTableSize,
 (max_uintx / StringTable::bucket_size()), "StringTable size");
+status = status && verify_interval(SymbolTableSize, minimumSymbolTableSize,
+(max_uintx / SymbolTable::bucket_size()), "SymbolTable 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_interval(ClassMetaspaceSize, 1*M, 3*G,
+status = status && verify_interval(CompressedClassSpaceSize, 1*M, 3*G,
-"ClassMetaspaceSize");
+"CompressedClassSpaceSize");
 status = status && verify_interval(MarkStackSizeMax,
 1, (max_jint - 1), "MarkStackSizeMax");
 status = status && verify_interval(NUMAChunkResizeWeight, 0, 100, "NUMAChunkResizeWeight");
 // 8K is well beyond the reasonable HW cache line size, even with the
 // aggressive prefetching, while still leaving the room for segregating
 // among the distinct pages.
 if (ContendedPaddingWidth < 0 || ContendedPaddingWidth > 8192) {
 jio_fprintf(defaultStream::error_stream(),
-"ContendedPaddingWidth=" INTX_FORMAT " must be the between %d and %d\n",
+"ContendedPaddingWidth=" INTX_FORMAT " must be in between %d and %d\n",
 ContendedPaddingWidth, 0, 8192);
 status = false;
 }
 // Need to enforce the padding not to break the existing field alignments.
 // It is sufficient to check against the largest type size.
 if ((ContendedPaddingWidth % BytesPerLong) != 0) {
 jio_fprintf(defaultStream::error_stream(),
-"ContendedPaddingWidth=" INTX_FORMAT " must be the multiple of %d\n",
+"ContendedPaddingWidth=" INTX_FORMAT " must be a multiple of %d\n",
 ContendedPaddingWidth, BytesPerLong);
 status = false;
 }
 // Check lower bounds of the code cache
 jio_fprintf(defaultStream::error_stream(),
 "Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
 (2*G)/M);
 status = false;
 }
+status &= verify_interval(NmethodSweepFraction, 1, ReservedCodeCacheSize/K, "NmethodSweepFraction");
+status &= verify_interval(NmethodSweepActivity, 0, 2000, "NmethodSweepActivity");
 return status;
 }
 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
 const char* option_type) {
 if (result != JNI_OK) {
 return result;
 }
 // Parse JavaVMInitArgs structure passed in
-result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, COMMAND_LINE);
+result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, Flag::COMMAND_LINE);
 if (result != JNI_OK) {
 return result;
-}
-if (AggressiveOpts) {
-// Insert alt-rt.jar between user-specified bootclasspath
-// prefix and the default bootclasspath.  os::set_boot_path()
-// uses meta_index_dir as the default bootclasspath directory.
-const char* altclasses_jar = "alt-rt.jar";
-size_t altclasses_path_len = strlen(get_meta_index_dir()) + 1 +
-strlen(altclasses_jar);
-char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len, mtInternal);
-strcpy(altclasses_path, get_meta_index_dir());
-strcat(altclasses_path, altclasses_jar);
-scp.add_suffix_to_prefix(altclasses_path);
-scp_assembly_required = true;
-FREE_C_HEAP_ARRAY(char, altclasses_path, mtInternal);
 }
 // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM)
 result = parse_java_options_environment_variable(&scp, &scp_assembly_required);
 if (result != JNI_OK) {
 }
 jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args,
 SysClassPath* scp_p,
 bool* scp_assembly_required_p,
-FlagValueOrigin origin) {
+Flag::Flags origin) {
 // Remaining part of option string
 const char* tail;
 // iterate over arguments
 for (int index = 0; index < args->nOptions; index++) {
 // -Xbatch
 } else if (match_option(option, "-Xbatch", &tail)) {
 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
 // -Xmn for compatibility with other JVM vendors
 } else if (match_option(option, "-Xmn", &tail)) {
-julong long_initial_eden_size = 0;
+julong long_initial_young_size = 0;
-ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1);
+ArgsRange errcode = parse_memory_size(tail, &long_initial_young_size, 1);
 if (errcode != arg_in_range) {
 jio_fprintf(defaultStream::error_stream(),
-"Invalid initial eden size: %s\n", option->optionString);
+"Invalid initial young generation size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size);
+FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_young_size);
-FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size);
+FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_young_size);
 // -Xms
 } else if (match_option(option, "-Xms", &tail)) {
 julong long_initial_heap_size = 0;
 // an initial heap size of 0 means automatically determine
 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 0);
 return JNI_EINVAL;
 }
 FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size);
 // Xmaxf
 } else if (match_option(option, "-Xmaxf", &tail)) {
-int maxf = (int)(atof(tail) * 100);
+char* err;
-if (maxf < 0 || maxf > 100) {
+int maxf = (int)(strtod(tail, &err) * 100);
+if (*err != '\0' || maxf < 0 || maxf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 "Bad max heap free percentage size: %s\n",
 option->optionString);
 return JNI_EINVAL;
 } else {
 FLAG_SET_CMDLINE(uintx, MaxHeapFreeRatio, maxf);
 }
 // Xminf
 } else if (match_option(option, "-Xminf", &tail)) {
-int minf = (int)(atof(tail) * 100);
+char* err;
-if (minf < 0 || minf > 100) {
+int minf = (int)(strtod(tail, &err) * 100);
+if (*err != '\0' || minf < 0 || minf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 "Bad min heap free percentage size: %s\n",
 option->optionString);
 return JNI_EINVAL;
 } else {
 } else if (match_option(option, "-Xloggc:", &tail)) {
 // Redirect GC output to the file. -Xloggc:<filename>
 // ostream_init_log(), when called will use this filename
 // to initialize a fileStream.
 _gc_log_filename = strdup(tail);
+if (!is_filename_valid(_gc_log_filename)) {
+jio_fprintf(defaultStream::output_stream(),
+"Invalid file name for use with -Xloggc: Filename can only contain the "
+"characters [A-Z][a-z][0-9]-_.%%[p|t] but it has been %s\n"
+"Note %%p or %%t can only be used once\n", _gc_log_filename);
+return JNI_EINVAL;
+}
 FLAG_SET_CMDLINE(bool, PrintGC, true);
 FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true);
 // JNI hooks
 } else if (match_option(option, "-Xcheck", &tail)) {
 logOption(tail);
 }
 }
 }
-return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR));
+return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, Flag::ENVIRON_VAR));
 }
 return JNI_OK;
 }
 void Arguments::set_shared_spaces_flags() {
 if (RequireSharedSpaces) {
 warning("cannot dump shared archive while using shared archive");
 }
 UseSharedSpaces = false;
 #ifdef _LP64
-if (!UseCompressedOops || !UseCompressedKlassPointers) {
+if (!UseCompressedOops || !UseCompressedClassPointers) {
 vm_exit_during_initialization(
-"Cannot dump shared archive when UseCompressedOops or UseCompressedKlassPointers is off.", NULL);
+"Cannot dump shared archive when UseCompressedOops or UseCompressedClassPointers is off.", NULL);
 }
 } else {
-// UseCompressedOops and UseCompressedKlassPointers must be on for UseSharedSpaces.
+// UseCompressedOops and UseCompressedClassPointers must be on for UseSharedSpaces.
-if (!UseCompressedOops || !UseCompressedKlassPointers) {
+if (!UseCompressedOops || !UseCompressedClassPointers) {
 no_shared_spaces();
 }
 #endif
 }
 }
 }
 }
 return shared_archive_path;
 }
+#ifndef PRODUCT
+// Determine whether LogVMOutput should be implicitly turned on.
+static bool use_vm_log() {
+if (LogCompilation || !FLAG_IS_DEFAULT(LogFile) ||
+PrintCompilation || PrintInlining || PrintDependencies || PrintNativeNMethods ||
+PrintDebugInfo || PrintRelocations || PrintNMethods || PrintExceptionHandlers ||
+PrintAssembly || TraceDeoptimization || TraceDependencies ||
+(VerifyDependencies && FLAG_IS_CMDLINE(VerifyDependencies))) {
+return true;
+}
+#ifdef COMPILER1
+if (PrintC1Statistics) {
+return true;
+}
+#endif // COMPILER1
+#ifdef COMPILER2
+if (PrintOptoAssembly || PrintOptoStatistics) {
+return true;
+}
+#endif // COMPILER2
+return false;
+}
+#endif // PRODUCT
 // Parse entry point called from JNI_CreateJavaVM
 jint Arguments::parse(const JavaVMInitArgs* args) {
 // Remaining part of option string
 FLAG_SET_DEFAULT(PrintSharedSpaces, false);
 }
 no_shared_spaces();
 #endif // INCLUDE_CDS
+return JNI_OK;
+}
+jint Arguments::apply_ergo() {
 // Set flags based on ergonomics.
 set_ergonomics_flags();
 set_shared_spaces_flags();
 if (CompilationPolicyChoice >= 2) {
 vm_exit_during_initialization(
 "Incompatible compilation policy selected", NULL);
 }
 }
-set_heap_base_min_address();
 // Set heap size based on available physical memory
 set_heap_size();
 #if INCLUDE_ALL_GCS
 }
 }
 #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
 set_bytecode_flags();
 // Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled.
 #ifdef ZERO
 // Clear flags not supported on zero.
 FLAG_SET_DEFAULT(ProfileInterpreter, false);
 FLAG_SET_DEFAULT(UseBiasedLocking, false);
 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false));
-LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedKlassPointers, false));
+LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedClassPointers, false));
 #endif // CC_INTERP
 #ifdef COMPILER2
 if (!UseBiasedLocking || EmitSync != 0) {
 UseOptoBiasInlining = false;
 #endif
 if (IncrementalInline && FLAG_IS_DEFAULT(MaxNodeLimit)) {
 // incremental inlining: bump MaxNodeLimit
 FLAG_SET_DEFAULT(MaxNodeLimit, (intx)75000);
 }
+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);
+}
+#ifndef X86
+// Only on x86 for now
+FLAG_SET_DEFAULT(TypeProfileLevel, 0);
+#endif
 #endif
 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
 DebugNonSafepoints = true;
+}
+if (FLAG_IS_CMDLINE(CompressedClassSpaceSize) && !UseCompressedClassPointers) {
+warning("Setting CompressedClassSpaceSize has no effect when compressed class pointers are not used");
 }
 #ifndef PRODUCT
 if (CompileTheWorld) {
 // Force NmethodSweeper to sweep whole CodeCache each time.
 if (FLAG_IS_DEFAULT(NmethodSweepFraction)) {
 NmethodSweepFraction = 1;
 }
 }
-#endif
+if (!LogVMOutput && FLAG_IS_DEFAULT(LogVMOutput)) {
+if (use_vm_log()) {
+LogVMOutput = true;
+}
+}
+#endif // PRODUCT
 if (PrintCommandLineFlags) {
 CommandLineFlags::printSetFlags(tty);
 }

changeset 22838	82c7497fbad4
parent 22836	e7e511228518
parent 21196	538177a5209a
child 22851	4c4b6a45be43