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

comparison src/share/vm/runtime/arguments.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	30162e74f11f 1d7922586cf6
children	c5afcc2ebd3d

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 #include "prims/jvmtiExport.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/globals_extension.hpp"
 #include "runtime/java.hpp"
 #include "services/management.hpp"
+#include "services/memTracker.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/taskqueue.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 # include "os_linux.inline.hpp"
 #endif
 }
 inline void SysClassPath::reset_item_at(int index) {
 assert(index < _scp_nitems && index != _scp_base, "just checking");
 if (_items[index] != NULL) {
-FREE_C_HEAP_ARRAY(char, _items[index]);
+FREE_C_HEAP_ARRAY(char, _items[index], mtInternal);
 _items[index] = NULL;
 }
 }
 inline void SysClassPath::reset_path(const char* base) {
 const char* tmp_end = strchr(path, separator);
 if (tmp_end == NULL) {
 expanded_path = add_jars_to_path(expanded_path, path);
 path = end;
 } else {
-char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1);
+char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal);
 memcpy(dirpath, path, tmp_end - path);
 dirpath[tmp_end - path] = '\0';
 expanded_path = add_jars_to_path(expanded_path, dirpath);
-FREE_C_HEAP_ARRAY(char, dirpath);
+FREE_C_HEAP_ARRAY(char, dirpath, mtInternal);
 path = tmp_end + 1;
 }
 }
 _items[_scp_endorsed] = expanded_path;
 DEBUG_ONLY(_expansion_done = true;)
 }
 }
 assert(total_len > 0, "empty sysclasspath not allowed");
 // Copy the _items to a single string.
-char* cp = NEW_C_HEAP_ARRAY(char, total_len);
+char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal);
 char* cp_tmp = cp;
 for (i = 0; i < _scp_nitems; ++i) {
 if (_items[i] != NULL) {
 memcpy(cp_tmp, _items[i], lengths[i]);
 cp_tmp += lengths[i];
 char *cp;
 assert(str != NULL, "just checking");
 if (path == NULL) {
 size_t len = strlen(str) + 1;
-cp = NEW_C_HEAP_ARRAY(char, len);
+cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
 memcpy(cp, str, len);                       // copy the trailing null
 } else {
 const char separator = *os::path_separator();
 size_t old_len = strlen(path);
 size_t str_len = strlen(str);
 size_t len = old_len + str_len + 2;
 if (prepend) {
-cp = NEW_C_HEAP_ARRAY(char, len);
+cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
 char* cp_tmp = cp;
 memcpy(cp_tmp, str, str_len);
 cp_tmp += str_len;
 *cp_tmp = separator;
 memcpy(++cp_tmp, path, old_len + 1);      // copy the trailing null
-FREE_C_HEAP_ARRAY(char, path);
+FREE_C_HEAP_ARRAY(char, path, mtInternal);
 } else {
-cp = REALLOC_C_HEAP_ARRAY(char, path, len);
+cp = REALLOC_C_HEAP_ARRAY(char, path, len, mtInternal);
 char* cp_tmp = cp + old_len;
 *cp_tmp = separator;
 memcpy(++cp_tmp, str, str_len + 1);       // copy the trailing null
 }
 }
 const char fileSep = *os::file_separator();
 if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep;
 /* Scan the directory for jars/zips, appending them to path. */
 struct dirent *entry;
-char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory));
+char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory), mtInternal);
 while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {
 const char* name = entry->d_name;
 const char* ext = name + strlen(name) - 4;
 bool isJarOrZip = ext > name &&
 (os::file_name_strcmp(ext, ".jar") == 0 ||
 os::file_name_strcmp(ext, ".zip") == 0);
 if (isJarOrZip) {
-char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name));
+char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name), mtInternal);
 sprintf(jarpath, "%s%s%s", directory, dir_sep, name);
 path = add_to_path(path, jarpath, false);
-FREE_C_HEAP_ARRAY(char, jarpath);
+FREE_C_HEAP_ARRAY(char, jarpath, mtInternal);
 }
 }
-FREE_C_HEAP_ARRAY(char, dbuf);
+FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);
 os::closedir(dir);
 return path;
 }
 // Parses a memory size specification string.
 }
 static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) {
 if (!CommandLineFlags::ccstrAtPut(name, &value, origin))  return false;
 // Contract:  CommandLineFlags always returns a pointer that needs freeing.
-FREE_C_HEAP_ARRAY(char, value);
+FREE_C_HEAP_ARRAY(char, value, mtInternal);
 return true;
 }
 static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) {
 const char* old_value = "";
 if (old_len == 0) {
 value = new_value;
 } else if (new_len == 0) {
 value = old_value;
 } else {
-char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1);
+char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1, mtInternal);
 // each new setting adds another LINE to the switch:
 sprintf(buf, "%s\n%s", old_value, new_value);
 value = buf;
 free_this_too = buf;
 }
 (void) CommandLineFlags::ccstrAtPut(name, &value, origin);
 // CommandLineFlags always returns a pointer that needs freeing.
-FREE_C_HEAP_ARRAY(char, value);
+FREE_C_HEAP_ARRAY(char, value, mtInternal);
 if (free_this_too != NULL) {
 // CommandLineFlags made its own copy, so I must delete my own temp. buffer.
-FREE_C_HEAP_ARRAY(char, free_this_too);
+FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal);
 }
 return true;
 }
 bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) {
 int index = *count;
 // expand the array and add arg to the last element
 (*count)++;
 if (*bldarray == NULL) {
-*bldarray = NEW_C_HEAP_ARRAY(char*, *count);
+*bldarray = NEW_C_HEAP_ARRAY(char*, *count, mtInternal);
 } else {
-*bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count);
+*bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count, mtInternal);
 }
 (*bldarray)[index] = strdup(arg);
 }
 void Arguments::build_jvm_args(const char* arg) {
 since.to_string(version, sizeof(version));
 warning("ignoring option %s; support was removed in %s", argname, version);
 return true;
 }
-jio_fprintf(defaultStream::error_stream(),
+// For locked flags, report a custom error message if available.
-"Unrecognized VM option '%s'\n", argname);
+// Otherwise, report the standard unrecognized VM option.
+Flag* locked_flag = Flag::find_flag((char*)argname, strlen(argname), true);
+if (locked_flag != NULL) {
+char locked_message_buf[BUFLEN];
+locked_flag->get_locked_message(locked_message_buf, BUFLEN);
+if (strlen(locked_message_buf) == 0) {
+jio_fprintf(defaultStream::error_stream(),
+"Unrecognized VM option '%s'\n", argname);
+} else {
+jio_fprintf(defaultStream::error_stream(), "%s", locked_message_buf);
+}
+} else {
+jio_fprintf(defaultStream::error_stream(),
+"Unrecognized VM option '%s'\n", argname);
+}
 // allow for commandline "commenting out" options like -XX:#+Verbose
 return arg[0] == '#';
 }
 bool Arguments::process_settings_file(const char* file_name, bool should_exist, jboolean ignore_unrecognized) {
 // ns must be static--its address may be stored in a SystemProperty object.
 const static char ns[1] = {0};
 char* value = (char *)ns;
 size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop);
-key = AllocateHeap(key_len + 1, "add_property");
+key = AllocateHeap(key_len + 1, mtInternal);
 strncpy(key, prop, key_len);
 key[key_len] = '\0';
 if (eq != NULL) {
 size_t value_len = strlen(prop) - key_len - 1;
-value = AllocateHeap(value_len + 1, "add_property");
+value = AllocateHeap(value_len + 1, mtInternal);
 strncpy(value, &prop[key_len + 1], value_len + 1);
 }
 if (strcmp(key, "java.compiler") == 0) {
 process_java_compiler_argument(value);
 // 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);
+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);
+FREE_C_HEAP_ARRAY(char, altclasses_path, mtInternal);
+}
+if (WhiteBoxAPI) {
+// Append wb.jar to bootclasspath if enabled
+const char* wb_jar = "wb.jar";
+size_t wb_path_len = strlen(get_meta_index_dir()) + 1 +
+strlen(wb_jar);
+char* wb_path = NEW_C_HEAP_ARRAY(char, wb_path_len, mtInternal);
+strcpy(wb_path, get_meta_index_dir());
+strcat(wb_path, wb_jar);
+scp.add_suffix(wb_path);
+scp_assembly_required = true;
+FREE_C_HEAP_ARRAY(char, wb_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) {
 // -Xrun
 } else if (match_option(option, "-Xrun", &tail)) {
 if (tail != NULL) {
 const char* pos = strchr(tail, ':');
 size_t len = (pos == NULL) ? strlen(tail) : pos - tail;
-char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len);
+char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len);
 name[len] = '\0';
 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), pos+1, len2);
+options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2);
 }
 #ifdef JVMTI_KERNEL
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
 warning("profiling and debugging agents are not supported with Kernel VM");
 } else
 } else if (match_option(option, "-agentlib:", &tail) ||
 (is_absolute_path = match_option(option, "-agentpath:", &tail))) {
 if(tail != NULL) {
 const char* pos = strchr(tail, '=');
 size_t len = (pos == NULL) ? strlen(tail) : pos - tail;
-char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len);
+char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len);
 name[len] = '\0';
 char *options = NULL;
 if(pos != NULL) {
-options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1), pos + 1);
+options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1);
 }
 #ifdef JVMTI_KERNEL
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
 warning("profiling and debugging agents are not supported with Kernel VM");
 } else
 }
 // -javaagent
 } else if (match_option(option, "-javaagent:", &tail)) {
 if(tail != NULL) {
-char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1), tail);
+char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail);
 add_init_agent("instrument", options, false);
 }
 // -Xnoclassgc
 } else if (match_option(option, "-Xnoclassgc", &tail)) {
 FLAG_SET_CMDLINE(bool, ClassUnloading, false);
 // original allocation order after promotion, which improves mutator
 // locality.  A minor effect may be that larger PLABs reduce the
 // number of PLAB allocation events during gc.  The value of 8kw
 // was arrived at by experimenting with specjbb.
 FLAG_SET_CMDLINE(uintx, OldPLABSize, 8*K);  // Note: this is in words
-// CompilationPolicyChoice=0 causes the server compiler to adopt
-// a more conservative which-method-do-I-compile policy when one
-// of the counters maintained by the interpreter trips.  The
-// result is reduced startup time and improved specjbb and
-// alacrity performance.  Zero is the default, but we set it
-// explicitly here in case the default changes.
-// See runtime/compilationPolicy.*.
-FLAG_SET_CMDLINE(intx, CompilationPolicyChoice, 0);
 // Enable parallel GC and adaptive generation sizing
 FLAG_SET_CMDLINE(bool, UseParallelGC, true);
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 jio_fprintf(defaultStream::error_stream(),
 "Invalid concurrent threads: %s\n", option->optionString);
 return JNI_EINVAL;
 }
 FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads);
+} else if (match_option(option, "-XX:MaxDirectMemorySize=", &tail)) {
+julong max_direct_memory_size = 0;
+ArgsRange errcode = parse_memory_size(tail, &max_direct_memory_size, 0);
+if (errcode != arg_in_range) {
+jio_fprintf(defaultStream::error_stream(),
+"Invalid maximum direct memory size: %s\n",
+option->optionString);
+describe_range_error(errcode);
+return JNI_EINVAL;
+}
+FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size);
 } 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;
 char jvm_path[JVM_MAXPATHLEN];
 os::jvm_path(jvm_path, sizeof(jvm_path));
 char *end = strrchr(jvm_path, *os::file_separator());
 if (end != NULL) *end = '\0';
 char *shared_archive_path = NEW_C_HEAP_ARRAY(char, strlen(jvm_path) +
-strlen(os::file_separator()) + 20);
+strlen(os::file_separator()) + 20, mtInternal);
 if (shared_archive_path == NULL) return JNI_ENOMEM;
 strcpy(shared_archive_path, jvm_path);
 strcat(shared_archive_path, os::file_separator());
 strcat(shared_archive_path, "classes");
 DEBUG_ONLY(strcat(shared_archive_path, "_g");)
 // Remaining part of option string
 const char* tail;
 // 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;
 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 (match_option(option, "-XX:NativeMemoryTracking", &tail)) {
+MemTracker::init_tracking_options(tail);
+}
 #ifndef PRODUCT
 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) {
 CommandLineFlags::printFlags(tty, true);
 vm_exit(0);
 // Parse specified settings file
 if (settings_file_specified) {
 if (!process_settings_file(flags_file, true, args->ignoreUnrecognized)) {
 return JNI_EINVAL;
 }
-}
+} else {
+#ifdef ASSERT
 // Parse default .hotspotrc settings file
-if (!settings_file_specified) {
 if (!process_settings_file(".hotspotrc", false, args->ignoreUnrecognized)) {
 return JNI_EINVAL;
 }
+#else
+struct stat buf;
+if (os::stat(hotspotrc, &buf) == 0) {
+needs_hotspotrc_warning = true;
+}
+#endif
 }
 if (PrintVMOptions) {
 for (index = 0; index < args->nOptions; index++) {
 const JavaVMOption *option = args->options + index;
 jint result = parse_vm_init_args(args);
 if (result != JNI_OK) {
 return result;
 }
-#ifdef JAVASE_EMBEDDED
+// Delay warning until here so that we've had a chance to process
+// the -XX:-PrintWarnings flag
+if (needs_hotspotrc_warning) {
+warning("%s file is present but has been ignored.  "
+"Run with -XX:Flags=%s to load the file.",
+hotspotrc, hotspotrc);
+}
+#if (defined JAVASE_EMBEDDED || defined ARM)
 UNSUPPORTED_OPTION(UseG1GC, "G1 GC");
 #endif
 #ifndef PRODUCT
 if (TraceBytecodesAt != 0) {
 warning("UseCounterDecay disabled because CountCalls is set");
 UseCounterDecay = false;
 }
 }
 #endif // PRODUCT
-// Transitional
-if (EnableMethodHandles || AnonymousClasses) {
-if (!EnableInvokeDynamic && !FLAG_IS_DEFAULT(EnableInvokeDynamic)) {
-warning("EnableMethodHandles and AnonymousClasses are obsolete.  Keeping EnableInvokeDynamic disabled.");
-} else {
-EnableInvokeDynamic = true;
-}
-}
 // JSR 292 is not supported before 1.7
 if (!JDK_Version::is_gte_jdk17x_version()) {
 if (EnableInvokeDynamic) {
 if (!FLAG_IS_DEFAULT(EnableInvokeDynamic)) {
 }
 if (PrintGCDetails) {
 // Turn on -verbose:gc options as well
 PrintGC = true;
+}
+if (!JDK_Version::is_gte_jdk18x_version()) {
+// To avoid changing the log format for 7 updates this flag is only
+// true by default in JDK8 and above.
+if (FLAG_IS_DEFAULT(PrintGCCause)) {
+FLAG_SET_DEFAULT(PrintGCCause, false);
+}
 }
 // Set object alignment values.
 set_object_alignment();
 if (strncmp(prop->key(), "kernel.", 7 ) == 0) {
 length += (strlen(prop->key()) + strlen(prop->value()) + 5);  // "-D ="
 }
 }
 // Add one for null terminator.
-char *props = AllocateHeap(length + 1, "get_kernel_properties");
+char *props = AllocateHeap(length + 1, mtInternal);
 if (length != 0) {
 int pos = 0;
 for (prop = _system_properties; prop != NULL; prop = prop->next()) {
 if (strncmp(prop->key(), "kernel.", 7 ) == 0) {
 jio_snprintf(&props[pos], length-pos,

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 6275:957c266d8bc5