Mon, 06 May 2013 17:19:42 +0200
8006088: Incompatible heap size flags accepted by VM
Summary: Make processing of minimum, initial and maximum heap size more intiutive by removing previous limitations on allowed values, and make error reporting consistent. Further, fix errors in ergonomic heap sizing.
Reviewed-by: johnc, jwilhelm, tamao
1 /*
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "precompiled.hpp"
26 #include "classfile/javaAssertions.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "compiler/compilerOracle.hpp"
29 #include "memory/allocation.inline.hpp"
30 #include "memory/cardTableRS.hpp"
31 #include "memory/referenceProcessor.hpp"
32 #include "memory/universe.inline.hpp"
33 #include "oops/oop.inline.hpp"
34 #include "prims/jvmtiExport.hpp"
35 #include "runtime/arguments.hpp"
36 #include "runtime/globals_extension.hpp"
37 #include "runtime/java.hpp"
38 #include "services/management.hpp"
39 #include "services/memTracker.hpp"
40 #include "utilities/defaultStream.hpp"
41 #include "utilities/macros.hpp"
42 #include "utilities/taskqueue.hpp"
43 #ifdef TARGET_OS_FAMILY_linux
44 # include "os_linux.inline.hpp"
45 #endif
46 #ifdef TARGET_OS_FAMILY_solaris
47 # include "os_solaris.inline.hpp"
48 #endif
49 #ifdef TARGET_OS_FAMILY_windows
50 # include "os_windows.inline.hpp"
51 #endif
52 #ifdef TARGET_OS_FAMILY_bsd
53 # include "os_bsd.inline.hpp"
54 #endif
55 #if INCLUDE_ALL_GCS
56 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
57 #endif // INCLUDE_ALL_GCS
59 // Note: This is a special bug reporting site for the JVM
60 #define DEFAULT_VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/crash.jsp"
61 #define DEFAULT_JAVA_LAUNCHER "generic"
63 char** Arguments::_jvm_flags_array = NULL;
64 int Arguments::_num_jvm_flags = 0;
65 char** Arguments::_jvm_args_array = NULL;
66 int Arguments::_num_jvm_args = 0;
67 char* Arguments::_java_command = NULL;
68 SystemProperty* Arguments::_system_properties = NULL;
69 const char* Arguments::_gc_log_filename = NULL;
70 bool Arguments::_has_profile = false;
71 bool Arguments::_has_alloc_profile = false;
72 uintx Arguments::_min_heap_size = 0;
73 Arguments::Mode Arguments::_mode = _mixed;
74 bool Arguments::_java_compiler = false;
75 bool Arguments::_xdebug_mode = false;
76 const char* Arguments::_java_vendor_url_bug = DEFAULT_VENDOR_URL_BUG;
77 const char* Arguments::_sun_java_launcher = DEFAULT_JAVA_LAUNCHER;
78 int Arguments::_sun_java_launcher_pid = -1;
79 bool Arguments::_created_by_gamma_launcher = false;
81 // These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*)
82 bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
83 bool Arguments::_UseOnStackReplacement = UseOnStackReplacement;
84 bool Arguments::_BackgroundCompilation = BackgroundCompilation;
85 bool Arguments::_ClipInlining = ClipInlining;
87 char* Arguments::SharedArchivePath = NULL;
89 AgentLibraryList Arguments::_libraryList;
90 AgentLibraryList Arguments::_agentList;
92 abort_hook_t Arguments::_abort_hook = NULL;
93 exit_hook_t Arguments::_exit_hook = NULL;
94 vfprintf_hook_t Arguments::_vfprintf_hook = NULL;
97 SystemProperty *Arguments::_java_ext_dirs = NULL;
98 SystemProperty *Arguments::_java_endorsed_dirs = NULL;
99 SystemProperty *Arguments::_sun_boot_library_path = NULL;
100 SystemProperty *Arguments::_java_library_path = NULL;
101 SystemProperty *Arguments::_java_home = NULL;
102 SystemProperty *Arguments::_java_class_path = NULL;
103 SystemProperty *Arguments::_sun_boot_class_path = NULL;
105 char* Arguments::_meta_index_path = NULL;
106 char* Arguments::_meta_index_dir = NULL;
108 // Check if head of 'option' matches 'name', and sets 'tail' remaining part of option string
110 static bool match_option(const JavaVMOption *option, const char* name,
111 const char** tail) {
112 int len = (int)strlen(name);
113 if (strncmp(option->optionString, name, len) == 0) {
114 *tail = option->optionString + len;
115 return true;
116 } else {
117 return false;
118 }
119 }
121 static void logOption(const char* opt) {
122 if (PrintVMOptions) {
123 jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt);
124 }
125 }
127 // Process java launcher properties.
128 void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {
129 // See if sun.java.launcher or sun.java.launcher.pid is defined.
130 // Must do this before setting up other system properties,
131 // as some of them may depend on launcher type.
132 for (int index = 0; index < args->nOptions; index++) {
133 const JavaVMOption* option = args->options + index;
134 const char* tail;
136 if (match_option(option, "-Dsun.java.launcher=", &tail)) {
137 process_java_launcher_argument(tail, option->extraInfo);
138 continue;
139 }
140 if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {
141 _sun_java_launcher_pid = atoi(tail);
142 continue;
143 }
144 }
145 }
147 // Initialize system properties key and value.
148 void Arguments::init_system_properties() {
150 PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name",
151 "Java Virtual Machine Specification", false));
152 PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(), false));
153 PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(), false));
154 PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(), true));
156 // following are JVMTI agent writeable properties.
157 // Properties values are set to NULL and they are
158 // os specific they are initialized in os::init_system_properties_values().
159 _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL, true);
160 _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL, true);
161 _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL, true);
162 _java_library_path = new SystemProperty("java.library.path", NULL, true);
163 _java_home = new SystemProperty("java.home", NULL, true);
164 _sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL, true);
166 _java_class_path = new SystemProperty("java.class.path", "", true);
168 // Add to System Property list.
169 PropertyList_add(&_system_properties, _java_ext_dirs);
170 PropertyList_add(&_system_properties, _java_endorsed_dirs);
171 PropertyList_add(&_system_properties, _sun_boot_library_path);
172 PropertyList_add(&_system_properties, _java_library_path);
173 PropertyList_add(&_system_properties, _java_home);
174 PropertyList_add(&_system_properties, _java_class_path);
175 PropertyList_add(&_system_properties, _sun_boot_class_path);
177 // Set OS specific system properties values
178 os::init_system_properties_values();
179 }
182 // Update/Initialize System properties after JDK version number is known
183 void Arguments::init_version_specific_system_properties() {
184 enum { bufsz = 16 };
185 char buffer[bufsz];
186 const char* spec_vendor = "Sun Microsystems Inc.";
187 uint32_t spec_version = 0;
189 if (JDK_Version::is_gte_jdk17x_version()) {
190 spec_vendor = "Oracle Corporation";
191 spec_version = JDK_Version::current().major_version();
192 }
193 jio_snprintf(buffer, bufsz, "1." UINT32_FORMAT, spec_version);
195 PropertyList_add(&_system_properties,
196 new SystemProperty("java.vm.specification.vendor", spec_vendor, false));
197 PropertyList_add(&_system_properties,
198 new SystemProperty("java.vm.specification.version", buffer, false));
199 PropertyList_add(&_system_properties,
200 new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(), false));
201 }
203 /**
204 * Provide a slightly more user-friendly way of eliminating -XX flags.
205 * When a flag is eliminated, it can be added to this list in order to
206 * continue accepting this flag on the command-line, while issuing a warning
207 * and ignoring the value. Once the JDK version reaches the 'accept_until'
208 * limit, we flatly refuse to admit the existence of the flag. This allows
209 * a flag to die correctly over JDK releases using HSX.
210 */
211 typedef struct {
212 const char* name;
213 JDK_Version obsoleted_in; // when the flag went away
214 JDK_Version accept_until; // which version to start denying the existence
215 } ObsoleteFlag;
217 static ObsoleteFlag obsolete_jvm_flags[] = {
218 { "UseTrainGC", JDK_Version::jdk(5), JDK_Version::jdk(7) },
219 { "UseSpecialLargeObjectHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) },
220 { "UseOversizedCarHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) },
221 { "TraceCarAllocation", JDK_Version::jdk(5), JDK_Version::jdk(7) },
222 { "PrintTrainGCProcessingStats", JDK_Version::jdk(5), JDK_Version::jdk(7) },
223 { "LogOfCarSpaceSize", JDK_Version::jdk(5), JDK_Version::jdk(7) },
224 { "OversizedCarThreshold", JDK_Version::jdk(5), JDK_Version::jdk(7) },
225 { "MinTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) },
226 { "DefaultTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) },
227 { "MaxTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) },
228 { "DelayTickAdjustment", JDK_Version::jdk(5), JDK_Version::jdk(7) },
229 { "ProcessingToTenuringRatio", JDK_Version::jdk(5), JDK_Version::jdk(7) },
230 { "MinTrainLength", JDK_Version::jdk(5), JDK_Version::jdk(7) },
231 { "AppendRatio", JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) },
232 { "DefaultMaxRAM", JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },
233 { "DefaultInitialRAMFraction",
234 JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },
235 { "UseDepthFirstScavengeOrder",
236 JDK_Version::jdk_update(6,22), JDK_Version::jdk(7) },
237 { "HandlePromotionFailure",
238 JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },
239 { "MaxLiveObjectEvacuationRatio",
240 JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },
241 { "ForceSharedSpaces", JDK_Version::jdk_update(6,25), JDK_Version::jdk(8) },
242 { "UseParallelOldGCCompacting",
243 JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },
244 { "UseParallelDensePrefixUpdate",
245 JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },
246 { "UseParallelOldGCDensePrefix",
247 JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },
248 { "AllowTransitionalJSR292", JDK_Version::jdk(7), JDK_Version::jdk(8) },
249 { "UseCompressedStrings", JDK_Version::jdk(7), JDK_Version::jdk(8) },
250 { "CMSPermGenPrecleaningEnabled", JDK_Version::jdk(8), JDK_Version::jdk(9) },
251 { "CMSTriggerPermRatio", JDK_Version::jdk(8), JDK_Version::jdk(9) },
252 { "CMSInitiatingPermOccupancyFraction", JDK_Version::jdk(8), JDK_Version::jdk(9) },
253 { "AdaptivePermSizeWeight", JDK_Version::jdk(8), JDK_Version::jdk(9) },
254 { "PermGenPadding", JDK_Version::jdk(8), JDK_Version::jdk(9) },
255 { "PermMarkSweepDeadRatio", JDK_Version::jdk(8), JDK_Version::jdk(9) },
256 { "PermSize", JDK_Version::jdk(8), JDK_Version::jdk(9) },
257 { "MaxPermSize", JDK_Version::jdk(8), JDK_Version::jdk(9) },
258 { "MinPermHeapExpansion", JDK_Version::jdk(8), JDK_Version::jdk(9) },
259 { "MaxPermHeapExpansion", JDK_Version::jdk(8), JDK_Version::jdk(9) },
260 { "CMSRevisitStackSize", JDK_Version::jdk(8), JDK_Version::jdk(9) },
261 { "PrintRevisitStats", JDK_Version::jdk(8), JDK_Version::jdk(9) },
262 { "UseVectoredExceptions", JDK_Version::jdk(8), JDK_Version::jdk(9) },
263 { "UseSplitVerifier", JDK_Version::jdk(8), JDK_Version::jdk(9) },
264 #ifdef PRODUCT
265 { "DesiredMethodLimit",
266 JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },
267 #endif // PRODUCT
268 { NULL, JDK_Version(0), JDK_Version(0) }
269 };
271 // Returns true if the flag is obsolete and fits into the range specified
272 // for being ignored. In the case that the flag is ignored, the 'version'
273 // value is filled in with the version number when the flag became
274 // obsolete so that that value can be displayed to the user.
275 bool Arguments::is_newly_obsolete(const char *s, JDK_Version* version) {
276 int i = 0;
277 assert(version != NULL, "Must provide a version buffer");
278 while (obsolete_jvm_flags[i].name != NULL) {
279 const ObsoleteFlag& flag_status = obsolete_jvm_flags[i];
280 // <flag>=xxx form
281 // [-|+]<flag> form
282 if ((strncmp(flag_status.name, s, strlen(flag_status.name)) == 0) ||
283 ((s[0] == '+' || s[0] == '-') &&
284 (strncmp(flag_status.name, &s[1], strlen(flag_status.name)) == 0))) {
285 if (JDK_Version::current().compare(flag_status.accept_until) == -1) {
286 *version = flag_status.obsoleted_in;
287 return true;
288 }
289 }
290 i++;
291 }
292 return false;
293 }
295 // Constructs the system class path (aka boot class path) from the following
296 // components, in order:
297 //
298 // prefix // from -Xbootclasspath/p:...
299 // endorsed // the expansion of -Djava.endorsed.dirs=...
300 // base // from os::get_system_properties() or -Xbootclasspath=
301 // suffix // from -Xbootclasspath/a:...
302 //
303 // java.endorsed.dirs is a list of directories; any jar or zip files in the
304 // directories are added to the sysclasspath just before the base.
305 //
306 // This could be AllStatic, but it isn't needed after argument processing is
307 // complete.
308 class SysClassPath: public StackObj {
309 public:
310 SysClassPath(const char* base);
311 ~SysClassPath();
313 inline void set_base(const char* base);
314 inline void add_prefix(const char* prefix);
315 inline void add_suffix_to_prefix(const char* suffix);
316 inline void add_suffix(const char* suffix);
317 inline void reset_path(const char* base);
319 // Expand the jar/zip files in each directory listed by the java.endorsed.dirs
320 // property. Must be called after all command-line arguments have been
321 // processed (in particular, -Djava.endorsed.dirs=...) and before calling
322 // combined_path().
323 void expand_endorsed();
325 inline const char* get_base() const { return _items[_scp_base]; }
326 inline const char* get_prefix() const { return _items[_scp_prefix]; }
327 inline const char* get_suffix() const { return _items[_scp_suffix]; }
328 inline const char* get_endorsed() const { return _items[_scp_endorsed]; }
330 // Combine all the components into a single c-heap-allocated string; caller
331 // must free the string if/when no longer needed.
332 char* combined_path();
334 private:
335 // Utility routines.
336 static char* add_to_path(const char* path, const char* str, bool prepend);
337 static char* add_jars_to_path(char* path, const char* directory);
339 inline void reset_item_at(int index);
341 // Array indices for the items that make up the sysclasspath. All except the
342 // base are allocated in the C heap and freed by this class.
343 enum {
344 _scp_prefix, // from -Xbootclasspath/p:...
345 _scp_endorsed, // the expansion of -Djava.endorsed.dirs=...
346 _scp_base, // the default sysclasspath
347 _scp_suffix, // from -Xbootclasspath/a:...
348 _scp_nitems // the number of items, must be last.
349 };
351 const char* _items[_scp_nitems];
352 DEBUG_ONLY(bool _expansion_done;)
353 };
355 SysClassPath::SysClassPath(const char* base) {
356 memset(_items, 0, sizeof(_items));
357 _items[_scp_base] = base;
358 DEBUG_ONLY(_expansion_done = false;)
359 }
361 SysClassPath::~SysClassPath() {
362 // Free everything except the base.
363 for (int i = 0; i < _scp_nitems; ++i) {
364 if (i != _scp_base) reset_item_at(i);
365 }
366 DEBUG_ONLY(_expansion_done = false;)
367 }
369 inline void SysClassPath::set_base(const char* base) {
370 _items[_scp_base] = base;
371 }
373 inline void SysClassPath::add_prefix(const char* prefix) {
374 _items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true);
375 }
377 inline void SysClassPath::add_suffix_to_prefix(const char* suffix) {
378 _items[_scp_prefix] = add_to_path(_items[_scp_prefix], suffix, false);
379 }
381 inline void SysClassPath::add_suffix(const char* suffix) {
382 _items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false);
383 }
385 inline void SysClassPath::reset_item_at(int index) {
386 assert(index < _scp_nitems && index != _scp_base, "just checking");
387 if (_items[index] != NULL) {
388 FREE_C_HEAP_ARRAY(char, _items[index], mtInternal);
389 _items[index] = NULL;
390 }
391 }
393 inline void SysClassPath::reset_path(const char* base) {
394 // Clear the prefix and suffix.
395 reset_item_at(_scp_prefix);
396 reset_item_at(_scp_suffix);
397 set_base(base);
398 }
400 //------------------------------------------------------------------------------
402 void SysClassPath::expand_endorsed() {
403 assert(_items[_scp_endorsed] == NULL, "can only be called once.");
405 const char* path = Arguments::get_property("java.endorsed.dirs");
406 if (path == NULL) {
407 path = Arguments::get_endorsed_dir();
408 assert(path != NULL, "no default for java.endorsed.dirs");
409 }
411 char* expanded_path = NULL;
412 const char separator = *os::path_separator();
413 const char* const end = path + strlen(path);
414 while (path < end) {
415 const char* tmp_end = strchr(path, separator);
416 if (tmp_end == NULL) {
417 expanded_path = add_jars_to_path(expanded_path, path);
418 path = end;
419 } else {
420 char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal);
421 memcpy(dirpath, path, tmp_end - path);
422 dirpath[tmp_end - path] = '\0';
423 expanded_path = add_jars_to_path(expanded_path, dirpath);
424 FREE_C_HEAP_ARRAY(char, dirpath, mtInternal);
425 path = tmp_end + 1;
426 }
427 }
428 _items[_scp_endorsed] = expanded_path;
429 DEBUG_ONLY(_expansion_done = true;)
430 }
432 // Combine the bootclasspath elements, some of which may be null, into a single
433 // c-heap-allocated string.
434 char* SysClassPath::combined_path() {
435 assert(_items[_scp_base] != NULL, "empty default sysclasspath");
436 assert(_expansion_done, "must call expand_endorsed() first.");
438 size_t lengths[_scp_nitems];
439 size_t total_len = 0;
441 const char separator = *os::path_separator();
443 // Get the lengths.
444 int i;
445 for (i = 0; i < _scp_nitems; ++i) {
446 if (_items[i] != NULL) {
447 lengths[i] = strlen(_items[i]);
448 // Include space for the separator char (or a NULL for the last item).
449 total_len += lengths[i] + 1;
450 }
451 }
452 assert(total_len > 0, "empty sysclasspath not allowed");
454 // Copy the _items to a single string.
455 char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal);
456 char* cp_tmp = cp;
457 for (i = 0; i < _scp_nitems; ++i) {
458 if (_items[i] != NULL) {
459 memcpy(cp_tmp, _items[i], lengths[i]);
460 cp_tmp += lengths[i];
461 *cp_tmp++ = separator;
462 }
463 }
464 *--cp_tmp = '\0'; // Replace the extra separator.
465 return cp;
466 }
468 // Note: path must be c-heap-allocated (or NULL); it is freed if non-null.
469 char*
470 SysClassPath::add_to_path(const char* path, const char* str, bool prepend) {
471 char *cp;
473 assert(str != NULL, "just checking");
474 if (path == NULL) {
475 size_t len = strlen(str) + 1;
476 cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
477 memcpy(cp, str, len); // copy the trailing null
478 } else {
479 const char separator = *os::path_separator();
480 size_t old_len = strlen(path);
481 size_t str_len = strlen(str);
482 size_t len = old_len + str_len + 2;
484 if (prepend) {
485 cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
486 char* cp_tmp = cp;
487 memcpy(cp_tmp, str, str_len);
488 cp_tmp += str_len;
489 *cp_tmp = separator;
490 memcpy(++cp_tmp, path, old_len + 1); // copy the trailing null
491 FREE_C_HEAP_ARRAY(char, path, mtInternal);
492 } else {
493 cp = REALLOC_C_HEAP_ARRAY(char, path, len, mtInternal);
494 char* cp_tmp = cp + old_len;
495 *cp_tmp = separator;
496 memcpy(++cp_tmp, str, str_len + 1); // copy the trailing null
497 }
498 }
499 return cp;
500 }
502 // Scan the directory and append any jar or zip files found to path.
503 // Note: path must be c-heap-allocated (or NULL); it is freed if non-null.
504 char* SysClassPath::add_jars_to_path(char* path, const char* directory) {
505 DIR* dir = os::opendir(directory);
506 if (dir == NULL) return path;
508 char dir_sep[2] = { '\0', '\0' };
509 size_t directory_len = strlen(directory);
510 const char fileSep = *os::file_separator();
511 if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep;
513 /* Scan the directory for jars/zips, appending them to path. */
514 struct dirent *entry;
515 char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory), mtInternal);
516 while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {
517 const char* name = entry->d_name;
518 const char* ext = name + strlen(name) - 4;
519 bool isJarOrZip = ext > name &&
520 (os::file_name_strcmp(ext, ".jar") == 0 ||
521 os::file_name_strcmp(ext, ".zip") == 0);
522 if (isJarOrZip) {
523 char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name), mtInternal);
524 sprintf(jarpath, "%s%s%s", directory, dir_sep, name);
525 path = add_to_path(path, jarpath, false);
526 FREE_C_HEAP_ARRAY(char, jarpath, mtInternal);
527 }
528 }
529 FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);
530 os::closedir(dir);
531 return path;
532 }
534 // Parses a memory size specification string.
535 static bool atomull(const char *s, julong* result) {
536 julong n = 0;
537 int args_read = sscanf(s, JULONG_FORMAT, &n);
538 if (args_read != 1) {
539 return false;
540 }
541 while (*s != '\0' && isdigit(*s)) {
542 s++;
543 }
544 // 4705540: illegal if more characters are found after the first non-digit
545 if (strlen(s) > 1) {
546 return false;
547 }
548 switch (*s) {
549 case 'T': case 't':
550 *result = n * G * K;
551 // Check for overflow.
552 if (*result/((julong)G * K) != n) return false;
553 return true;
554 case 'G': case 'g':
555 *result = n * G;
556 if (*result/G != n) return false;
557 return true;
558 case 'M': case 'm':
559 *result = n * M;
560 if (*result/M != n) return false;
561 return true;
562 case 'K': case 'k':
563 *result = n * K;
564 if (*result/K != n) return false;
565 return true;
566 case '\0':
567 *result = n;
568 return true;
569 default:
570 return false;
571 }
572 }
574 Arguments::ArgsRange Arguments::check_memory_size(julong size, julong min_size) {
575 if (size < min_size) return arg_too_small;
576 // Check that size will fit in a size_t (only relevant on 32-bit)
577 if (size > max_uintx) return arg_too_big;
578 return arg_in_range;
579 }
581 // Describe an argument out of range error
582 void Arguments::describe_range_error(ArgsRange errcode) {
583 switch(errcode) {
584 case arg_too_big:
585 jio_fprintf(defaultStream::error_stream(),
586 "The specified size exceeds the maximum "
587 "representable size.\n");
588 break;
589 case arg_too_small:
590 case arg_unreadable:
591 case arg_in_range:
592 // do nothing for now
593 break;
594 default:
595 ShouldNotReachHere();
596 }
597 }
599 static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) {
600 return CommandLineFlags::boolAtPut(name, &value, origin);
601 }
603 static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) {
604 double v;
605 if (sscanf(value, "%lf", &v) != 1) {
606 return false;
607 }
609 if (CommandLineFlags::doubleAtPut(name, &v, origin)) {
610 return true;
611 }
612 return false;
613 }
615 static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) {
616 julong v;
617 intx intx_v;
618 bool is_neg = false;
619 // Check the sign first since atomull() parses only unsigned values.
620 if (*value == '-') {
621 if (!CommandLineFlags::intxAt(name, &intx_v)) {
622 return false;
623 }
624 value++;
625 is_neg = true;
626 }
627 if (!atomull(value, &v)) {
628 return false;
629 }
630 intx_v = (intx) v;
631 if (is_neg) {
632 intx_v = -intx_v;
633 }
634 if (CommandLineFlags::intxAtPut(name, &intx_v, origin)) {
635 return true;
636 }
637 uintx uintx_v = (uintx) v;
638 if (!is_neg && CommandLineFlags::uintxAtPut(name, &uintx_v, origin)) {
639 return true;
640 }
641 uint64_t uint64_t_v = (uint64_t) v;
642 if (!is_neg && CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin)) {
643 return true;
644 }
645 return false;
646 }
648 static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) {
649 if (!CommandLineFlags::ccstrAtPut(name, &value, origin)) return false;
650 // Contract: CommandLineFlags always returns a pointer that needs freeing.
651 FREE_C_HEAP_ARRAY(char, value, mtInternal);
652 return true;
653 }
655 static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) {
656 const char* old_value = "";
657 if (!CommandLineFlags::ccstrAt(name, &old_value)) return false;
658 size_t old_len = old_value != NULL ? strlen(old_value) : 0;
659 size_t new_len = strlen(new_value);
660 const char* value;
661 char* free_this_too = NULL;
662 if (old_len == 0) {
663 value = new_value;
664 } else if (new_len == 0) {
665 value = old_value;
666 } else {
667 char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1, mtInternal);
668 // each new setting adds another LINE to the switch:
669 sprintf(buf, "%s\n%s", old_value, new_value);
670 value = buf;
671 free_this_too = buf;
672 }
673 (void) CommandLineFlags::ccstrAtPut(name, &value, origin);
674 // CommandLineFlags always returns a pointer that needs freeing.
675 FREE_C_HEAP_ARRAY(char, value, mtInternal);
676 if (free_this_too != NULL) {
677 // CommandLineFlags made its own copy, so I must delete my own temp. buffer.
678 FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal);
679 }
680 return true;
681 }
683 bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) {
685 // range of acceptable characters spelled out for portability reasons
686 #define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
687 #define BUFLEN 255
688 char name[BUFLEN+1];
689 char dummy;
691 if (sscanf(arg, "-%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) {
692 return set_bool_flag(name, false, origin);
693 }
694 if (sscanf(arg, "+%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) {
695 return set_bool_flag(name, true, origin);
696 }
698 char punct;
699 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "%c", name, &punct) == 2 && punct == '=') {
700 const char* value = strchr(arg, '=') + 1;
701 Flag* flag = Flag::find_flag(name, strlen(name));
702 if (flag != NULL && flag->is_ccstr()) {
703 if (flag->ccstr_accumulates()) {
704 return append_to_string_flag(name, value, origin);
705 } else {
706 if (value[0] == '\0') {
707 value = NULL;
708 }
709 return set_string_flag(name, value, origin);
710 }
711 }
712 }
714 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE ":%c", name, &punct) == 2 && punct == '=') {
715 const char* value = strchr(arg, '=') + 1;
716 // -XX:Foo:=xxx will reset the string flag to the given value.
717 if (value[0] == '\0') {
718 value = NULL;
719 }
720 return set_string_flag(name, value, origin);
721 }
723 #define SIGNED_FP_NUMBER_RANGE "[-0123456789.]"
724 #define SIGNED_NUMBER_RANGE "[-0123456789]"
725 #define NUMBER_RANGE "[0123456789]"
726 char value[BUFLEN + 1];
727 char value2[BUFLEN + 1];
728 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_NUMBER_RANGE "." "%" XSTR(BUFLEN) NUMBER_RANGE "%c", name, value, value2, &dummy) == 3) {
729 // Looks like a floating-point number -- try again with more lenient format string
730 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_FP_NUMBER_RANGE "%c", name, value, &dummy) == 2) {
731 return set_fp_numeric_flag(name, value, origin);
732 }
733 }
735 #define VALUE_RANGE "[-kmgtKMGT0123456789]"
736 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) VALUE_RANGE "%c", name, value, &dummy) == 2) {
737 return set_numeric_flag(name, value, origin);
738 }
740 return false;
741 }
743 void Arguments::add_string(char*** bldarray, int* count, const char* arg) {
744 assert(bldarray != NULL, "illegal argument");
746 if (arg == NULL) {
747 return;
748 }
750 int new_count = *count + 1;
752 // expand the array and add arg to the last element
753 if (*bldarray == NULL) {
754 *bldarray = NEW_C_HEAP_ARRAY(char*, new_count, mtInternal);
755 } else {
756 *bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, new_count, mtInternal);
757 }
758 (*bldarray)[*count] = strdup(arg);
759 *count = new_count;
760 }
762 void Arguments::build_jvm_args(const char* arg) {
763 add_string(&_jvm_args_array, &_num_jvm_args, arg);
764 }
766 void Arguments::build_jvm_flags(const char* arg) {
767 add_string(&_jvm_flags_array, &_num_jvm_flags, arg);
768 }
770 // utility function to return a string that concatenates all
771 // strings in a given char** array
772 const char* Arguments::build_resource_string(char** args, int count) {
773 if (args == NULL || count == 0) {
774 return NULL;
775 }
776 size_t length = strlen(args[0]) + 1; // add 1 for the null terminator
777 for (int i = 1; i < count; i++) {
778 length += strlen(args[i]) + 1; // add 1 for a space
779 }
780 char* s = NEW_RESOURCE_ARRAY(char, length);
781 strcpy(s, args[0]);
782 for (int j = 1; j < count; j++) {
783 strcat(s, " ");
784 strcat(s, args[j]);
785 }
786 return (const char*) s;
787 }
789 void Arguments::print_on(outputStream* st) {
790 st->print_cr("VM Arguments:");
791 if (num_jvm_flags() > 0) {
792 st->print("jvm_flags: "); print_jvm_flags_on(st);
793 }
794 if (num_jvm_args() > 0) {
795 st->print("jvm_args: "); print_jvm_args_on(st);
796 }
797 st->print_cr("java_command: %s", java_command() ? java_command() : "<unknown>");
798 if (_java_class_path != NULL) {
799 char* path = _java_class_path->value();
800 st->print_cr("java_class_path (initial): %s", strlen(path) == 0 ? "<not set>" : path );
801 }
802 st->print_cr("Launcher Type: %s", _sun_java_launcher);
803 }
805 void Arguments::print_jvm_flags_on(outputStream* st) {
806 if (_num_jvm_flags > 0) {
807 for (int i=0; i < _num_jvm_flags; i++) {
808 st->print("%s ", _jvm_flags_array[i]);
809 }
810 st->print_cr("");
811 }
812 }
814 void Arguments::print_jvm_args_on(outputStream* st) {
815 if (_num_jvm_args > 0) {
816 for (int i=0; i < _num_jvm_args; i++) {
817 st->print("%s ", _jvm_args_array[i]);
818 }
819 st->print_cr("");
820 }
821 }
823 bool Arguments::process_argument(const char* arg,
824 jboolean ignore_unrecognized, FlagValueOrigin origin) {
826 JDK_Version since = JDK_Version();
828 if (parse_argument(arg, origin) || ignore_unrecognized) {
829 return true;
830 }
832 bool has_plus_minus = (*arg == '+' || *arg == '-');
833 const char* const argname = has_plus_minus ? arg + 1 : arg;
834 if (is_newly_obsolete(arg, &since)) {
835 char version[256];
836 since.to_string(version, sizeof(version));
837 warning("ignoring option %s; support was removed in %s", argname, version);
838 return true;
839 }
841 // For locked flags, report a custom error message if available.
842 // Otherwise, report the standard unrecognized VM option.
844 size_t arg_len;
845 const char* equal_sign = strchr(argname, '=');
846 if (equal_sign == NULL) {
847 arg_len = strlen(argname);
848 } else {
849 arg_len = equal_sign - argname;
850 }
852 Flag* found_flag = Flag::find_flag((char*)argname, arg_len, true);
853 if (found_flag != NULL) {
854 char locked_message_buf[BUFLEN];
855 found_flag->get_locked_message(locked_message_buf, BUFLEN);
856 if (strlen(locked_message_buf) == 0) {
857 if (found_flag->is_bool() && !has_plus_minus) {
858 jio_fprintf(defaultStream::error_stream(),
859 "Missing +/- setting for VM option '%s'\n", argname);
860 } else if (!found_flag->is_bool() && has_plus_minus) {
861 jio_fprintf(defaultStream::error_stream(),
862 "Unexpected +/- setting in VM option '%s'\n", argname);
863 } else {
864 jio_fprintf(defaultStream::error_stream(),
865 "Improperly specified VM option '%s'\n", argname);
866 }
867 } else {
868 jio_fprintf(defaultStream::error_stream(), "%s", locked_message_buf);
869 }
870 } else {
871 jio_fprintf(defaultStream::error_stream(),
872 "Unrecognized VM option '%s'\n", argname);
873 }
875 // allow for commandline "commenting out" options like -XX:#+Verbose
876 return arg[0] == '#';
877 }
879 bool Arguments::process_settings_file(const char* file_name, bool should_exist, jboolean ignore_unrecognized) {
880 FILE* stream = fopen(file_name, "rb");
881 if (stream == NULL) {
882 if (should_exist) {
883 jio_fprintf(defaultStream::error_stream(),
884 "Could not open settings file %s\n", file_name);
885 return false;
886 } else {
887 return true;
888 }
889 }
891 char token[1024];
892 int pos = 0;
894 bool in_white_space = true;
895 bool in_comment = false;
896 bool in_quote = false;
897 char quote_c = 0;
898 bool result = true;
900 int c = getc(stream);
901 while(c != EOF && pos < (int)(sizeof(token)-1)) {
902 if (in_white_space) {
903 if (in_comment) {
904 if (c == '\n') in_comment = false;
905 } else {
906 if (c == '#') in_comment = true;
907 else if (!isspace(c)) {
908 in_white_space = false;
909 token[pos++] = c;
910 }
911 }
912 } else {
913 if (c == '\n' || (!in_quote && isspace(c))) {
914 // token ends at newline, or at unquoted whitespace
915 // this allows a way to include spaces in string-valued options
916 token[pos] = '\0';
917 logOption(token);
918 result &= process_argument(token, ignore_unrecognized, CONFIG_FILE);
919 build_jvm_flags(token);
920 pos = 0;
921 in_white_space = true;
922 in_quote = false;
923 } else if (!in_quote && (c == '\'' || c == '"')) {
924 in_quote = true;
925 quote_c = c;
926 } else if (in_quote && (c == quote_c)) {
927 in_quote = false;
928 } else {
929 token[pos++] = c;
930 }
931 }
932 c = getc(stream);
933 }
934 if (pos > 0) {
935 token[pos] = '\0';
936 result &= process_argument(token, ignore_unrecognized, CONFIG_FILE);
937 build_jvm_flags(token);
938 }
939 fclose(stream);
940 return result;
941 }
943 //=============================================================================================================
944 // Parsing of properties (-D)
946 const char* Arguments::get_property(const char* key) {
947 return PropertyList_get_value(system_properties(), key);
948 }
950 bool Arguments::add_property(const char* prop) {
951 const char* eq = strchr(prop, '=');
952 char* key;
953 // ns must be static--its address may be stored in a SystemProperty object.
954 const static char ns[1] = {0};
955 char* value = (char *)ns;
957 size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop);
958 key = AllocateHeap(key_len + 1, mtInternal);
959 strncpy(key, prop, key_len);
960 key[key_len] = '\0';
962 if (eq != NULL) {
963 size_t value_len = strlen(prop) - key_len - 1;
964 value = AllocateHeap(value_len + 1, mtInternal);
965 strncpy(value, &prop[key_len + 1], value_len + 1);
966 }
968 if (strcmp(key, "java.compiler") == 0) {
969 process_java_compiler_argument(value);
970 FreeHeap(key);
971 if (eq != NULL) {
972 FreeHeap(value);
973 }
974 return true;
975 } else if (strcmp(key, "sun.java.command") == 0) {
976 _java_command = value;
978 // Record value in Arguments, but let it get passed to Java.
979 } else if (strcmp(key, "sun.java.launcher.pid") == 0) {
980 // launcher.pid property is private and is processed
981 // in process_sun_java_launcher_properties();
982 // the sun.java.launcher property is passed on to the java application
983 FreeHeap(key);
984 if (eq != NULL) {
985 FreeHeap(value);
986 }
987 return true;
988 } else if (strcmp(key, "java.vendor.url.bug") == 0) {
989 // save it in _java_vendor_url_bug, so JVM fatal error handler can access
990 // its value without going through the property list or making a Java call.
991 _java_vendor_url_bug = value;
992 } else if (strcmp(key, "sun.boot.library.path") == 0) {
993 PropertyList_unique_add(&_system_properties, key, value, true);
994 return true;
995 }
996 // Create new property and add at the end of the list
997 PropertyList_unique_add(&_system_properties, key, value);
998 return true;
999 }
1001 //===========================================================================================================
1002 // Setting int/mixed/comp mode flags
1004 void Arguments::set_mode_flags(Mode mode) {
1005 // Set up default values for all flags.
1006 // If you add a flag to any of the branches below,
1007 // add a default value for it here.
1008 set_java_compiler(false);
1009 _mode = mode;
1011 // Ensure Agent_OnLoad has the correct initial values.
1012 // This may not be the final mode; mode may change later in onload phase.
1013 PropertyList_unique_add(&_system_properties, "java.vm.info",
1014 (char*)VM_Version::vm_info_string(), false);
1016 UseInterpreter = true;
1017 UseCompiler = true;
1018 UseLoopCounter = true;
1020 #ifndef ZERO
1021 // Turn these off for mixed and comp. Leave them on for Zero.
1022 if (FLAG_IS_DEFAULT(UseFastAccessorMethods)) {
1023 UseFastAccessorMethods = (mode == _int);
1024 }
1025 if (FLAG_IS_DEFAULT(UseFastEmptyMethods)) {
1026 UseFastEmptyMethods = (mode == _int);
1027 }
1028 #endif
1030 // Default values may be platform/compiler dependent -
1031 // use the saved values
1032 ClipInlining = Arguments::_ClipInlining;
1033 AlwaysCompileLoopMethods = Arguments::_AlwaysCompileLoopMethods;
1034 UseOnStackReplacement = Arguments::_UseOnStackReplacement;
1035 BackgroundCompilation = Arguments::_BackgroundCompilation;
1037 // Change from defaults based on mode
1038 switch (mode) {
1039 default:
1040 ShouldNotReachHere();
1041 break;
1042 case _int:
1043 UseCompiler = false;
1044 UseLoopCounter = false;
1045 AlwaysCompileLoopMethods = false;
1046 UseOnStackReplacement = false;
1047 break;
1048 case _mixed:
1049 // same as default
1050 break;
1051 case _comp:
1052 UseInterpreter = false;
1053 BackgroundCompilation = false;
1054 ClipInlining = false;
1055 // Be much more aggressive in tiered mode with -Xcomp and exercise C2 more.
1056 // We will first compile a level 3 version (C1 with full profiling), then do one invocation of it and
1057 // compile a level 4 (C2) and then continue executing it.
1058 if (TieredCompilation) {
1059 Tier3InvokeNotifyFreqLog = 0;
1060 Tier4InvocationThreshold = 0;
1061 }
1062 break;
1063 }
1064 }
1066 // Conflict: required to use shared spaces (-Xshare:on), but
1067 // incompatible command line options were chosen.
1069 static void no_shared_spaces() {
1070 if (RequireSharedSpaces) {
1071 jio_fprintf(defaultStream::error_stream(),
1072 "Class data sharing is inconsistent with other specified options.\n");
1073 vm_exit_during_initialization("Unable to use shared archive.", NULL);
1074 } else {
1075 FLAG_SET_DEFAULT(UseSharedSpaces, false);
1076 }
1077 }
1079 void Arguments::set_tiered_flags() {
1080 // With tiered, set default policy to AdvancedThresholdPolicy, which is 3.
1081 if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) {
1082 FLAG_SET_DEFAULT(CompilationPolicyChoice, 3);
1083 }
1084 if (CompilationPolicyChoice < 2) {
1085 vm_exit_during_initialization(
1086 "Incompatible compilation policy selected", NULL);
1087 }
1088 // Increase the code cache size - tiered compiles a lot more.
1089 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
1090 FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 5);
1091 }
1092 }
1094 #if INCLUDE_ALL_GCS
1095 static void disable_adaptive_size_policy(const char* collector_name) {
1096 if (UseAdaptiveSizePolicy) {
1097 if (FLAG_IS_CMDLINE(UseAdaptiveSizePolicy)) {
1098 warning("disabling UseAdaptiveSizePolicy; it is incompatible with %s.",
1099 collector_name);
1100 }
1101 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
1102 }
1103 }
1105 void Arguments::set_parnew_gc_flags() {
1106 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC,
1107 "control point invariant");
1108 assert(UseParNewGC, "Error");
1110 // Turn off AdaptiveSizePolicy for parnew until it is complete.
1111 disable_adaptive_size_policy("UseParNewGC");
1113 if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
1114 FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
1115 assert(ParallelGCThreads > 0, "We should always have at least one thread by default");
1116 } else if (ParallelGCThreads == 0) {
1117 jio_fprintf(defaultStream::error_stream(),
1118 "The ParNew GC can not be combined with -XX:ParallelGCThreads=0\n");
1119 vm_exit(1);
1120 }
1122 // By default YoungPLABSize and OldPLABSize are set to 4096 and 1024 respectively,
1123 // these settings are default for Parallel Scavenger. For ParNew+Tenured configuration
1124 // we set them to 1024 and 1024.
1125 // See CR 6362902.
1126 if (FLAG_IS_DEFAULT(YoungPLABSize)) {
1127 FLAG_SET_DEFAULT(YoungPLABSize, (intx)1024);
1128 }
1129 if (FLAG_IS_DEFAULT(OldPLABSize)) {
1130 FLAG_SET_DEFAULT(OldPLABSize, (intx)1024);
1131 }
1133 // AlwaysTenure flag should make ParNew promote all at first collection.
1134 // See CR 6362902.
1135 if (AlwaysTenure) {
1136 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0);
1137 }
1138 // When using compressed oops, we use local overflow stacks,
1139 // rather than using a global overflow list chained through
1140 // the klass word of the object's pre-image.
1141 if (UseCompressedOops && !ParGCUseLocalOverflow) {
1142 if (!FLAG_IS_DEFAULT(ParGCUseLocalOverflow)) {
1143 warning("Forcing +ParGCUseLocalOverflow: needed if using compressed references");
1144 }
1145 FLAG_SET_DEFAULT(ParGCUseLocalOverflow, true);
1146 }
1147 assert(ParGCUseLocalOverflow || !UseCompressedOops, "Error");
1148 }
1150 // Adjust some sizes to suit CMS and/or ParNew needs; these work well on
1151 // sparc/solaris for certain applications, but would gain from
1152 // further optimization and tuning efforts, and would almost
1153 // certainly gain from analysis of platform and environment.
1154 void Arguments::set_cms_and_parnew_gc_flags() {
1155 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC, "Error");
1156 assert(UseConcMarkSweepGC, "CMS is expected to be on here");
1158 // If we are using CMS, we prefer to UseParNewGC,
1159 // unless explicitly forbidden.
1160 if (FLAG_IS_DEFAULT(UseParNewGC)) {
1161 FLAG_SET_ERGO(bool, UseParNewGC, true);
1162 }
1164 // Turn off AdaptiveSizePolicy by default for cms until it is complete.
1165 disable_adaptive_size_policy("UseConcMarkSweepGC");
1167 // In either case, adjust ParallelGCThreads and/or UseParNewGC
1168 // as needed.
1169 if (UseParNewGC) {
1170 set_parnew_gc_flags();
1171 }
1173 size_t max_heap = align_size_down(MaxHeapSize,
1174 CardTableRS::ct_max_alignment_constraint());
1176 // Now make adjustments for CMS
1177 intx tenuring_default = (intx)6;
1178 size_t young_gen_per_worker = CMSYoungGenPerWorker;
1180 // Preferred young gen size for "short" pauses:
1181 // upper bound depends on # of threads and NewRatio.
1182 const uintx parallel_gc_threads =
1183 (ParallelGCThreads == 0 ? 1 : ParallelGCThreads);
1184 const size_t preferred_max_new_size_unaligned =
1185 MIN2(max_heap/(NewRatio+1), ScaleForWordSize(young_gen_per_worker * parallel_gc_threads));
1186 size_t preferred_max_new_size =
1187 align_size_up(preferred_max_new_size_unaligned, os::vm_page_size());
1189 // Unless explicitly requested otherwise, size young gen
1190 // for "short" pauses ~ CMSYoungGenPerWorker*ParallelGCThreads
1192 // If either MaxNewSize or NewRatio is set on the command line,
1193 // assume the user is trying to set the size of the young gen.
1194 if (FLAG_IS_DEFAULT(MaxNewSize) && FLAG_IS_DEFAULT(NewRatio)) {
1196 // Set MaxNewSize to our calculated preferred_max_new_size unless
1197 // NewSize was set on the command line and it is larger than
1198 // preferred_max_new_size.
1199 if (!FLAG_IS_DEFAULT(NewSize)) { // NewSize explicitly set at command-line
1200 FLAG_SET_ERGO(uintx, MaxNewSize, MAX2(NewSize, preferred_max_new_size));
1201 } else {
1202 FLAG_SET_ERGO(uintx, MaxNewSize, preferred_max_new_size);
1203 }
1204 if (PrintGCDetails && Verbose) {
1205 // Too early to use gclog_or_tty
1206 tty->print_cr("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize);
1207 }
1209 // Code along this path potentially sets NewSize and OldSize
1210 if (PrintGCDetails && Verbose) {
1211 // Too early to use gclog_or_tty
1212 tty->print_cr("CMS set min_heap_size: " SIZE_FORMAT
1213 " initial_heap_size: " SIZE_FORMAT
1214 " max_heap: " SIZE_FORMAT,
1215 min_heap_size(), InitialHeapSize, max_heap);
1216 }
1217 size_t min_new = preferred_max_new_size;
1218 if (FLAG_IS_CMDLINE(NewSize)) {
1219 min_new = NewSize;
1220 }
1221 if (max_heap > min_new && min_heap_size() > min_new) {
1222 // Unless explicitly requested otherwise, make young gen
1223 // at least min_new, and at most preferred_max_new_size.
1224 if (FLAG_IS_DEFAULT(NewSize)) {
1225 FLAG_SET_ERGO(uintx, NewSize, MAX2(NewSize, min_new));
1226 FLAG_SET_ERGO(uintx, NewSize, MIN2(preferred_max_new_size, NewSize));
1227 if (PrintGCDetails && Verbose) {
1228 // Too early to use gclog_or_tty
1229 tty->print_cr("CMS ergo set NewSize: " SIZE_FORMAT, NewSize);
1230 }
1231 }
1232 // Unless explicitly requested otherwise, size old gen
1233 // so it's NewRatio x of NewSize.
1234 if (FLAG_IS_DEFAULT(OldSize)) {
1235 if (max_heap > NewSize) {
1236 FLAG_SET_ERGO(uintx, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize));
1237 if (PrintGCDetails && Verbose) {
1238 // Too early to use gclog_or_tty
1239 tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);
1240 }
1241 }
1242 }
1243 }
1244 }
1245 // Unless explicitly requested otherwise, definitely
1246 // promote all objects surviving "tenuring_default" scavenges.
1247 if (FLAG_IS_DEFAULT(MaxTenuringThreshold) &&
1248 FLAG_IS_DEFAULT(SurvivorRatio)) {
1249 FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default);
1250 }
1251 // If we decided above (or user explicitly requested)
1252 // `promote all' (via MaxTenuringThreshold := 0),
1253 // prefer minuscule survivor spaces so as not to waste
1254 // space for (non-existent) survivors
1255 if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) {
1256 FLAG_SET_ERGO(uintx, SurvivorRatio, MAX2((uintx)1024, SurvivorRatio));
1257 }
1258 // If OldPLABSize is set and CMSParPromoteBlocksToClaim is not,
1259 // set CMSParPromoteBlocksToClaim equal to OldPLABSize.
1260 // This is done in order to make ParNew+CMS configuration to work
1261 // with YoungPLABSize and OldPLABSize options.
1262 // See CR 6362902.
1263 if (!FLAG_IS_DEFAULT(OldPLABSize)) {
1264 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) {
1265 // OldPLABSize is not the default value but CMSParPromoteBlocksToClaim
1266 // is. In this situtation let CMSParPromoteBlocksToClaim follow
1267 // the value (either from the command line or ergonomics) of
1268 // OldPLABSize. Following OldPLABSize is an ergonomics decision.
1269 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, OldPLABSize);
1270 } else {
1271 // OldPLABSize and CMSParPromoteBlocksToClaim are both set.
1272 // CMSParPromoteBlocksToClaim is a collector-specific flag, so
1273 // we'll let it to take precedence.
1274 jio_fprintf(defaultStream::error_stream(),
1275 "Both OldPLABSize and CMSParPromoteBlocksToClaim"
1276 " options are specified for the CMS collector."
1277 " CMSParPromoteBlocksToClaim will take precedence.\n");
1278 }
1279 }
1280 if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) {
1281 // OldPLAB sizing manually turned off: Use a larger default setting,
1282 // unless it was manually specified. This is because a too-low value
1283 // will slow down scavenges.
1284 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) {
1285 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, 50); // default value before 6631166
1286 }
1287 }
1288 // Overwrite OldPLABSize which is the variable we will internally use everywhere.
1289 FLAG_SET_ERGO(uintx, OldPLABSize, CMSParPromoteBlocksToClaim);
1290 // If either of the static initialization defaults have changed, note this
1291 // modification.
1292 if (!FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim) || !FLAG_IS_DEFAULT(OldPLABWeight)) {
1293 CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight);
1294 }
1295 if (PrintGCDetails && Verbose) {
1296 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk",
1297 MarkStackSize / K, MarkStackSizeMax / K);
1298 tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
1299 }
1300 }
1301 #endif // INCLUDE_ALL_GCS
1303 void set_object_alignment() {
1304 // Object alignment.
1305 assert(is_power_of_2(ObjectAlignmentInBytes), "ObjectAlignmentInBytes must be power of 2");
1306 MinObjAlignmentInBytes = ObjectAlignmentInBytes;
1307 assert(MinObjAlignmentInBytes >= HeapWordsPerLong * HeapWordSize, "ObjectAlignmentInBytes value is too small");
1308 MinObjAlignment = MinObjAlignmentInBytes / HeapWordSize;
1309 assert(MinObjAlignmentInBytes == MinObjAlignment * HeapWordSize, "ObjectAlignmentInBytes value is incorrect");
1310 MinObjAlignmentInBytesMask = MinObjAlignmentInBytes - 1;
1312 LogMinObjAlignmentInBytes = exact_log2(ObjectAlignmentInBytes);
1313 LogMinObjAlignment = LogMinObjAlignmentInBytes - LogHeapWordSize;
1315 // Oop encoding heap max
1316 OopEncodingHeapMax = (uint64_t(max_juint) + 1) << LogMinObjAlignmentInBytes;
1318 #if INCLUDE_ALL_GCS
1319 // Set CMS global values
1320 CompactibleFreeListSpace::set_cms_values();
1321 #endif // INCLUDE_ALL_GCS
1322 }
1324 bool verify_object_alignment() {
1325 // Object alignment.
1326 if (!is_power_of_2(ObjectAlignmentInBytes)) {
1327 jio_fprintf(defaultStream::error_stream(),
1328 "error: ObjectAlignmentInBytes=%d must be power of 2\n",
1329 (int)ObjectAlignmentInBytes);
1330 return false;
1331 }
1332 if ((int)ObjectAlignmentInBytes < BytesPerLong) {
1333 jio_fprintf(defaultStream::error_stream(),
1334 "error: ObjectAlignmentInBytes=%d must be greater or equal %d\n",
1335 (int)ObjectAlignmentInBytes, BytesPerLong);
1336 return false;
1337 }
1338 // It does not make sense to have big object alignment
1339 // since a space lost due to alignment will be greater
1340 // then a saved space from compressed oops.
1341 if ((int)ObjectAlignmentInBytes > 256) {
1342 jio_fprintf(defaultStream::error_stream(),
1343 "error: ObjectAlignmentInBytes=%d must not be greater than 256\n",
1344 (int)ObjectAlignmentInBytes);
1345 return false;
1346 }
1347 // In case page size is very small.
1348 if ((int)ObjectAlignmentInBytes >= os::vm_page_size()) {
1349 jio_fprintf(defaultStream::error_stream(),
1350 "error: ObjectAlignmentInBytes=%d must be less than page size %d\n",
1351 (int)ObjectAlignmentInBytes, os::vm_page_size());
1352 return false;
1353 }
1354 return true;
1355 }
1357 inline uintx max_heap_for_compressed_oops() {
1358 // Avoid sign flip.
1359 if (OopEncodingHeapMax < ClassMetaspaceSize + os::vm_page_size()) {
1360 return 0;
1361 }
1362 LP64_ONLY(return OopEncodingHeapMax - ClassMetaspaceSize - os::vm_page_size());
1363 NOT_LP64(ShouldNotReachHere(); return 0);
1364 }
1366 bool Arguments::should_auto_select_low_pause_collector() {
1367 if (UseAutoGCSelectPolicy &&
1368 !FLAG_IS_DEFAULT(MaxGCPauseMillis) &&
1369 (MaxGCPauseMillis <= AutoGCSelectPauseMillis)) {
1370 if (PrintGCDetails) {
1371 // Cannot use gclog_or_tty yet.
1372 tty->print_cr("Automatic selection of the low pause collector"
1373 " based on pause goal of %d (ms)", MaxGCPauseMillis);
1374 }
1375 return true;
1376 }
1377 return false;
1378 }
1380 void Arguments::set_use_compressed_oops() {
1381 #ifndef ZERO
1382 #ifdef _LP64
1383 // MaxHeapSize is not set up properly at this point, but
1384 // the only value that can override MaxHeapSize if we are
1385 // to use UseCompressedOops is InitialHeapSize.
1386 size_t max_heap_size = MAX2(MaxHeapSize, InitialHeapSize);
1388 if (max_heap_size <= max_heap_for_compressed_oops()) {
1389 #if !defined(COMPILER1) || defined(TIERED)
1390 if (FLAG_IS_DEFAULT(UseCompressedOops)) {
1391 FLAG_SET_ERGO(bool, UseCompressedOops, true);
1392 }
1393 #endif
1394 #ifdef _WIN64
1395 if (UseLargePages && UseCompressedOops) {
1396 // Cannot allocate guard pages for implicit checks in indexed addressing
1397 // mode, when large pages are specified on windows.
1398 // This flag could be switched ON if narrow oop base address is set to 0,
1399 // see code in Universe::initialize_heap().
1400 Universe::set_narrow_oop_use_implicit_null_checks(false);
1401 }
1402 #endif // _WIN64
1403 } else {
1404 if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) {
1405 warning("Max heap size too large for Compressed Oops");
1406 FLAG_SET_DEFAULT(UseCompressedOops, false);
1407 FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
1408 }
1409 }
1410 #endif // _LP64
1411 #endif // ZERO
1412 }
1414 void Arguments::set_ergonomics_flags() {
1416 if (os::is_server_class_machine()) {
1417 // If no other collector is requested explicitly,
1418 // let the VM select the collector based on
1419 // machine class and automatic selection policy.
1420 if (!UseSerialGC &&
1421 !UseConcMarkSweepGC &&
1422 !UseG1GC &&
1423 !UseParNewGC &&
1424 FLAG_IS_DEFAULT(UseParallelGC)) {
1425 if (should_auto_select_low_pause_collector()) {
1426 FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
1427 } else {
1428 FLAG_SET_ERGO(bool, UseParallelGC, true);
1429 }
1430 }
1431 // Shared spaces work fine with other GCs but causes bytecode rewriting
1432 // to be disabled, which hurts interpreter performance and decreases
1433 // server performance. On server class machines, keep the default
1434 // off unless it is asked for. Future work: either add bytecode rewriting
1435 // at link time, or rewrite bytecodes in non-shared methods.
1436 if (!DumpSharedSpaces && !RequireSharedSpaces) {
1437 no_shared_spaces();
1438 }
1439 }
1441 #ifndef ZERO
1442 #ifdef _LP64
1443 set_use_compressed_oops();
1444 // UseCompressedOops must be on for UseCompressedKlassPointers to be on.
1445 if (!UseCompressedOops) {
1446 if (UseCompressedKlassPointers) {
1447 warning("UseCompressedKlassPointers requires UseCompressedOops");
1448 }
1449 FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
1450 } else {
1451 // Turn on UseCompressedKlassPointers too
1452 if (FLAG_IS_DEFAULT(UseCompressedKlassPointers)) {
1453 FLAG_SET_ERGO(bool, UseCompressedKlassPointers, true);
1454 }
1455 // Set the ClassMetaspaceSize to something that will not need to be
1456 // expanded, since it cannot be expanded.
1457 if (UseCompressedKlassPointers) {
1458 if (ClassMetaspaceSize > KlassEncodingMetaspaceMax) {
1459 warning("Class metaspace size is too large for UseCompressedKlassPointers");
1460 FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
1461 } else if (FLAG_IS_DEFAULT(ClassMetaspaceSize)) {
1462 // 100,000 classes seems like a good size, so 100M assumes around 1K
1463 // per klass. The vtable and oopMap is embedded so we don't have a fixed
1464 // size per klass. Eventually, this will be parameterized because it
1465 // would also be useful to determine the optimal size of the
1466 // systemDictionary.
1467 FLAG_SET_ERGO(uintx, ClassMetaspaceSize, 100*M);
1468 }
1469 }
1470 }
1471 // Also checks that certain machines are slower with compressed oops
1472 // in vm_version initialization code.
1473 #endif // _LP64
1474 #endif // !ZERO
1475 }
1477 void Arguments::set_parallel_gc_flags() {
1478 assert(UseParallelGC || UseParallelOldGC, "Error");
1479 // Enable ParallelOld unless it was explicitly disabled (cmd line or rc file).
1480 if (FLAG_IS_DEFAULT(UseParallelOldGC)) {
1481 FLAG_SET_DEFAULT(UseParallelOldGC, true);
1482 }
1483 FLAG_SET_DEFAULT(UseParallelGC, true);
1485 // If no heap maximum was requested explicitly, use some reasonable fraction
1486 // of the physical memory, up to a maximum of 1GB.
1487 FLAG_SET_DEFAULT(ParallelGCThreads,
1488 Abstract_VM_Version::parallel_worker_threads());
1489 if (ParallelGCThreads == 0) {
1490 jio_fprintf(defaultStream::error_stream(),
1491 "The Parallel GC can not be combined with -XX:ParallelGCThreads=0\n");
1492 vm_exit(1);
1493 }
1496 // If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the
1497 // SurvivorRatio has been set, reset their default values to SurvivorRatio +
1498 // 2. By doing this we make SurvivorRatio also work for Parallel Scavenger.
1499 // See CR 6362902 for details.
1500 if (!FLAG_IS_DEFAULT(SurvivorRatio)) {
1501 if (FLAG_IS_DEFAULT(InitialSurvivorRatio)) {
1502 FLAG_SET_DEFAULT(InitialSurvivorRatio, SurvivorRatio + 2);
1503 }
1504 if (FLAG_IS_DEFAULT(MinSurvivorRatio)) {
1505 FLAG_SET_DEFAULT(MinSurvivorRatio, SurvivorRatio + 2);
1506 }
1507 }
1509 if (UseParallelOldGC) {
1510 // Par compact uses lower default values since they are treated as
1511 // minimums. These are different defaults because of the different
1512 // interpretation and are not ergonomically set.
1513 if (FLAG_IS_DEFAULT(MarkSweepDeadRatio)) {
1514 FLAG_SET_DEFAULT(MarkSweepDeadRatio, 1);
1515 }
1516 }
1517 }
1519 void Arguments::set_g1_gc_flags() {
1520 assert(UseG1GC, "Error");
1521 #ifdef COMPILER1
1522 FastTLABRefill = false;
1523 #endif
1524 FLAG_SET_DEFAULT(ParallelGCThreads,
1525 Abstract_VM_Version::parallel_worker_threads());
1526 if (ParallelGCThreads == 0) {
1527 FLAG_SET_DEFAULT(ParallelGCThreads,
1528 Abstract_VM_Version::parallel_worker_threads());
1529 }
1531 // MarkStackSize will be set (if it hasn't been set by the user)
1532 // when concurrent marking is initialized.
1533 // Its value will be based upon the number of parallel marking threads.
1534 // But we do set the maximum mark stack size here.
1535 if (FLAG_IS_DEFAULT(MarkStackSizeMax)) {
1536 FLAG_SET_DEFAULT(MarkStackSizeMax, 128 * TASKQUEUE_SIZE);
1537 }
1539 if (FLAG_IS_DEFAULT(GCTimeRatio) || GCTimeRatio == 0) {
1540 // In G1, we want the default GC overhead goal to be higher than
1541 // say in PS. So we set it here to 10%. Otherwise the heap might
1542 // be expanded more aggressively than we would like it to. In
1543 // fact, even 10% seems to not be high enough in some cases
1544 // (especially small GC stress tests that the main thing they do
1545 // is allocation). We might consider increase it further.
1546 FLAG_SET_DEFAULT(GCTimeRatio, 9);
1547 }
1549 if (PrintGCDetails && Verbose) {
1550 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk",
1551 MarkStackSize / K, MarkStackSizeMax / K);
1552 tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
1553 }
1554 }
1556 julong Arguments::limit_by_allocatable_memory(julong limit) {
1557 julong max_allocatable;
1558 julong result = limit;
1559 if (os::has_allocatable_memory_limit(&max_allocatable)) {
1560 result = MIN2(result, max_allocatable / MaxVirtMemFraction);
1561 }
1562 return result;
1563 }
1565 void Arguments::set_heap_size() {
1566 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
1567 // Deprecated flag
1568 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
1569 }
1571 const julong phys_mem =
1572 FLAG_IS_DEFAULT(MaxRAM) ? MIN2(os::physical_memory(), (julong)MaxRAM)
1573 : (julong)MaxRAM;
1575 // If the maximum heap size has not been set with -Xmx,
1576 // then set it as fraction of the size of physical memory,
1577 // respecting the maximum and minimum sizes of the heap.
1578 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
1579 julong reasonable_max = phys_mem / MaxRAMFraction;
1581 if (phys_mem <= MaxHeapSize * MinRAMFraction) {
1582 // Small physical memory, so use a minimum fraction of it for the heap
1583 reasonable_max = phys_mem / MinRAMFraction;
1584 } else {
1585 // Not-small physical memory, so require a heap at least
1586 // as large as MaxHeapSize
1587 reasonable_max = MAX2(reasonable_max, (julong)MaxHeapSize);
1588 }
1589 if (!FLAG_IS_DEFAULT(ErgoHeapSizeLimit) && ErgoHeapSizeLimit != 0) {
1590 // Limit the heap size to ErgoHeapSizeLimit
1591 reasonable_max = MIN2(reasonable_max, (julong)ErgoHeapSizeLimit);
1592 }
1593 if (UseCompressedOops) {
1594 // Limit the heap size to the maximum possible when using compressed oops
1595 julong max_coop_heap = (julong)max_heap_for_compressed_oops();
1596 if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) {
1597 // Heap should be above HeapBaseMinAddress to get zero based compressed oops
1598 // but it should be not less than default MaxHeapSize.
1599 max_coop_heap -= HeapBaseMinAddress;
1600 }
1601 reasonable_max = MIN2(reasonable_max, max_coop_heap);
1602 }
1603 reasonable_max = limit_by_allocatable_memory(reasonable_max);
1605 if (!FLAG_IS_DEFAULT(InitialHeapSize)) {
1606 // An initial heap size was specified on the command line,
1607 // so be sure that the maximum size is consistent. Done
1608 // after call to limit_by_allocatable_memory because that
1609 // method might reduce the allocation size.
1610 reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize);
1611 }
1613 if (PrintGCDetails && Verbose) {
1614 // Cannot use gclog_or_tty yet.
1615 tty->print_cr(" Maximum heap size " SIZE_FORMAT, reasonable_max);
1616 }
1617 FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx)reasonable_max);
1618 }
1620 // If the minimum or initial heap_size have not been set or requested to be set
1621 // ergonomically, set them accordingly.
1622 if (InitialHeapSize == 0 || min_heap_size() == 0) {
1623 julong reasonable_minimum = (julong)(OldSize + NewSize);
1625 reasonable_minimum = MIN2(reasonable_minimum, (julong)MaxHeapSize);
1627 reasonable_minimum = limit_by_allocatable_memory(reasonable_minimum);
1629 if (InitialHeapSize == 0) {
1630 julong reasonable_initial = phys_mem / InitialRAMFraction;
1632 reasonable_initial = MAX3(reasonable_initial, reasonable_minimum, (julong)min_heap_size());
1633 reasonable_initial = MIN2(reasonable_initial, (julong)MaxHeapSize);
1635 reasonable_initial = limit_by_allocatable_memory(reasonable_initial);
1637 if (PrintGCDetails && Verbose) {
1638 // Cannot use gclog_or_tty yet.
1639 tty->print_cr(" Initial heap size " SIZE_FORMAT, (uintx)reasonable_initial);
1640 }
1641 FLAG_SET_ERGO(uintx, InitialHeapSize, (uintx)reasonable_initial);
1642 }
1643 // If the minimum heap size has not been set (via -Xms),
1644 // synchronize with InitialHeapSize to avoid errors with the default value.
1645 if (min_heap_size() == 0) {
1646 set_min_heap_size(MIN2((uintx)reasonable_minimum, InitialHeapSize));
1647 if (PrintGCDetails && Verbose) {
1648 // Cannot use gclog_or_tty yet.
1649 tty->print_cr(" Minimum heap size " SIZE_FORMAT, min_heap_size());
1650 }
1651 }
1652 }
1653 }
1655 // This must be called after ergonomics because we want bytecode rewriting
1656 // if the server compiler is used, or if UseSharedSpaces is disabled.
1657 void Arguments::set_bytecode_flags() {
1658 // Better not attempt to store into a read-only space.
1659 if (UseSharedSpaces) {
1660 FLAG_SET_DEFAULT(RewriteBytecodes, false);
1661 FLAG_SET_DEFAULT(RewriteFrequentPairs, false);
1662 }
1664 if (!RewriteBytecodes) {
1665 FLAG_SET_DEFAULT(RewriteFrequentPairs, false);
1666 }
1667 }
1669 // Aggressive optimization flags -XX:+AggressiveOpts
1670 void Arguments::set_aggressive_opts_flags() {
1671 #ifdef COMPILER2
1672 if (AggressiveOpts || !FLAG_IS_DEFAULT(AutoBoxCacheMax)) {
1673 if (FLAG_IS_DEFAULT(EliminateAutoBox)) {
1674 FLAG_SET_DEFAULT(EliminateAutoBox, true);
1675 }
1676 if (FLAG_IS_DEFAULT(AutoBoxCacheMax)) {
1677 FLAG_SET_DEFAULT(AutoBoxCacheMax, 20000);
1678 }
1680 // Feed the cache size setting into the JDK
1681 char buffer[1024];
1682 sprintf(buffer, "java.lang.Integer.IntegerCache.high=" INTX_FORMAT, AutoBoxCacheMax);
1683 add_property(buffer);
1684 }
1685 if (AggressiveOpts && FLAG_IS_DEFAULT(BiasedLockingStartupDelay)) {
1686 FLAG_SET_DEFAULT(BiasedLockingStartupDelay, 500);
1687 }
1688 #endif
1690 if (AggressiveOpts) {
1691 // Sample flag setting code
1692 // if (FLAG_IS_DEFAULT(EliminateZeroing)) {
1693 // FLAG_SET_DEFAULT(EliminateZeroing, true);
1694 // }
1695 }
1696 }
1698 //===========================================================================================================
1699 // Parsing of java.compiler property
1701 void Arguments::process_java_compiler_argument(char* arg) {
1702 // For backwards compatibility, Djava.compiler=NONE or ""
1703 // causes us to switch to -Xint mode UNLESS -Xdebug
1704 // is also specified.
1705 if (strlen(arg) == 0 || strcasecmp(arg, "NONE") == 0) {
1706 set_java_compiler(true); // "-Djava.compiler[=...]" most recently seen.
1707 }
1708 }
1710 void Arguments::process_java_launcher_argument(const char* launcher, void* extra_info) {
1711 _sun_java_launcher = strdup(launcher);
1712 if (strcmp("gamma", _sun_java_launcher) == 0) {
1713 _created_by_gamma_launcher = true;
1714 }
1715 }
1717 bool Arguments::created_by_java_launcher() {
1718 assert(_sun_java_launcher != NULL, "property must have value");
1719 return strcmp(DEFAULT_JAVA_LAUNCHER, _sun_java_launcher) != 0;
1720 }
1722 bool Arguments::created_by_gamma_launcher() {
1723 return _created_by_gamma_launcher;
1724 }
1726 //===========================================================================================================
1727 // Parsing of main arguments
1729 bool Arguments::verify_interval(uintx val, uintx min,
1730 uintx max, const char* name) {
1731 // Returns true iff value is in the inclusive interval [min..max]
1732 // false, otherwise.
1733 if (val >= min && val <= max) {
1734 return true;
1735 }
1736 jio_fprintf(defaultStream::error_stream(),
1737 "%s of " UINTX_FORMAT " is invalid; must be between " UINTX_FORMAT
1738 " and " UINTX_FORMAT "\n",
1739 name, val, min, max);
1740 return false;
1741 }
1743 bool Arguments::verify_min_value(intx val, intx min, const char* name) {
1744 // Returns true if given value is at least specified min threshold
1745 // false, otherwise.
1746 if (val >= min ) {
1747 return true;
1748 }
1749 jio_fprintf(defaultStream::error_stream(),
1750 "%s of " INTX_FORMAT " is invalid; must be at least " INTX_FORMAT "\n",
1751 name, val, min);
1752 return false;
1753 }
1755 bool Arguments::verify_percentage(uintx value, const char* name) {
1756 if (value <= 100) {
1757 return true;
1758 }
1759 jio_fprintf(defaultStream::error_stream(),
1760 "%s of " UINTX_FORMAT " is invalid; must be between 0 and 100\n",
1761 name, value);
1762 return false;
1763 }
1765 #if !INCLUDE_ALL_GCS
1766 #ifdef ASSERT
1767 static bool verify_serial_gc_flags() {
1768 return (UseSerialGC &&
1769 !(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC ||
1770 UseParallelGC || UseParallelOldGC));
1771 }
1772 #endif // ASSERT
1773 #endif // INCLUDE_ALL_GCS
1775 // check if do gclog rotation
1776 // +UseGCLogFileRotation is a must,
1777 // no gc log rotation when log file not supplied or
1778 // NumberOfGCLogFiles is 0, or GCLogFileSize is 0
1779 void check_gclog_consistency() {
1780 if (UseGCLogFileRotation) {
1781 if ((Arguments::gc_log_filename() == NULL) ||
1782 (NumberOfGCLogFiles == 0) ||
1783 (GCLogFileSize == 0)) {
1784 jio_fprintf(defaultStream::output_stream(),
1785 "To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>\n"
1786 "where num_of_file > 0 and num_of_size > 0\n"
1787 "GC log rotation is turned off\n");
1788 UseGCLogFileRotation = false;
1789 }
1790 }
1792 if (UseGCLogFileRotation && GCLogFileSize < 8*K) {
1793 FLAG_SET_CMDLINE(uintx, GCLogFileSize, 8*K);
1794 jio_fprintf(defaultStream::output_stream(),
1795 "GCLogFileSize changed to minimum 8K\n");
1796 }
1797 }
1799 // Check consistency of GC selection
1800 bool Arguments::check_gc_consistency() {
1801 check_gclog_consistency();
1802 bool status = true;
1803 // Ensure that the user has not selected conflicting sets
1804 // of collectors. [Note: this check is merely a user convenience;
1805 // collectors over-ride each other so that only a non-conflicting
1806 // set is selected; however what the user gets is not what they
1807 // may have expected from the combination they asked for. It's
1808 // better to reduce user confusion by not allowing them to
1809 // select conflicting combinations.
1810 uint i = 0;
1811 if (UseSerialGC) i++;
1812 if (UseConcMarkSweepGC || UseParNewGC) i++;
1813 if (UseParallelGC || UseParallelOldGC) i++;
1814 if (UseG1GC) i++;
1815 if (i > 1) {
1816 jio_fprintf(defaultStream::error_stream(),
1817 "Conflicting collector combinations in option list; "
1818 "please refer to the release notes for the combinations "
1819 "allowed\n");
1820 status = false;
1821 }
1823 return status;
1824 }
1826 void Arguments::check_deprecated_gcs() {
1827 if (UseConcMarkSweepGC && !UseParNewGC) {
1828 warning("Using the DefNew young collector with the CMS collector is deprecated "
1829 "and will likely be removed in a future release");
1830 }
1832 if (UseParNewGC && !UseConcMarkSweepGC) {
1833 // !UseConcMarkSweepGC means that we are using serial old gc. Unfortunately we don't
1834 // set up UseSerialGC properly, so that can't be used in the check here.
1835 warning("Using the ParNew young collector with the Serial old collector is deprecated "
1836 "and will likely be removed in a future release");
1837 }
1839 if (CMSIncrementalMode) {
1840 warning("Using incremental CMS is deprecated and will likely be removed in a future release");
1841 }
1842 }
1844 void Arguments::check_deprecated_gc_flags() {
1845 if (FLAG_IS_CMDLINE(MaxGCMinorPauseMillis)) {
1846 warning("Using MaxGCMinorPauseMillis as minor pause goal is deprecated"
1847 "and will likely be removed in future release");
1848 }
1849 }
1851 // Check stack pages settings
1852 bool Arguments::check_stack_pages()
1853 {
1854 bool status = true;
1855 status = status && verify_min_value(StackYellowPages, 1, "StackYellowPages");
1856 status = status && verify_min_value(StackRedPages, 1, "StackRedPages");
1857 // greater stack shadow pages can't generate instruction to bang stack
1858 status = status && verify_interval(StackShadowPages, 1, 50, "StackShadowPages");
1859 return status;
1860 }
1862 // Check the consistency of vm_init_args
1863 bool Arguments::check_vm_args_consistency() {
1864 // Method for adding checks for flag consistency.
1865 // The intent is to warn the user of all possible conflicts,
1866 // before returning an error.
1867 // Note: Needs platform-dependent factoring.
1868 bool status = true;
1870 #if ( (defined(COMPILER2) && defined(SPARC)))
1871 // NOTE: The call to VM_Version_init depends on the fact that VM_Version_init
1872 // on sparc doesn't require generation of a stub as is the case on, e.g.,
1873 // x86. Normally, VM_Version_init must be called from init_globals in
1874 // init.cpp, which is called by the initial java thread *after* arguments
1875 // have been parsed. VM_Version_init gets called twice on sparc.
1876 extern void VM_Version_init();
1877 VM_Version_init();
1878 if (!VM_Version::has_v9()) {
1879 jio_fprintf(defaultStream::error_stream(),
1880 "V8 Machine detected, Server requires V9\n");
1881 status = false;
1882 }
1883 #endif /* COMPILER2 && SPARC */
1885 // Allow both -XX:-UseStackBanging and -XX:-UseBoundThreads in non-product
1886 // builds so the cost of stack banging can be measured.
1887 #if (defined(PRODUCT) && defined(SOLARIS))
1888 if (!UseBoundThreads && !UseStackBanging) {
1889 jio_fprintf(defaultStream::error_stream(),
1890 "-UseStackBanging conflicts with -UseBoundThreads\n");
1892 status = false;
1893 }
1894 #endif
1896 if (TLABRefillWasteFraction == 0) {
1897 jio_fprintf(defaultStream::error_stream(),
1898 "TLABRefillWasteFraction should be a denominator, "
1899 "not " SIZE_FORMAT "\n",
1900 TLABRefillWasteFraction);
1901 status = false;
1902 }
1904 status = status && verify_percentage(AdaptiveSizePolicyWeight,
1905 "AdaptiveSizePolicyWeight");
1906 status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance");
1907 status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio");
1908 status = status && verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio");
1910 // Divide by bucket size to prevent a large size from causing rollover when
1911 // calculating amount of memory needed to be allocated for the String table.
1912 status = status && verify_interval(StringTableSize, minimumStringTableSize,
1913 (max_uintx / StringTable::bucket_size()), "StringTable size");
1915 if (MinHeapFreeRatio > MaxHeapFreeRatio) {
1916 jio_fprintf(defaultStream::error_stream(),
1917 "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
1918 "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
1919 MinHeapFreeRatio, MaxHeapFreeRatio);
1920 status = false;
1921 }
1922 // Keeping the heap 100% free is hard ;-) so limit it to 99%.
1923 MinHeapFreeRatio = MIN2(MinHeapFreeRatio, (uintx) 99);
1925 // Min/MaxMetaspaceFreeRatio
1926 status = status && verify_percentage(MinMetaspaceFreeRatio, "MinMetaspaceFreeRatio");
1927 status = status && verify_percentage(MaxMetaspaceFreeRatio, "MaxMetaspaceFreeRatio");
1929 if (MinMetaspaceFreeRatio > MaxMetaspaceFreeRatio) {
1930 jio_fprintf(defaultStream::error_stream(),
1931 "MinMetaspaceFreeRatio (%s" UINTX_FORMAT ") must be less than or "
1932 "equal to MaxMetaspaceFreeRatio (%s" UINTX_FORMAT ")\n",
1933 FLAG_IS_DEFAULT(MinMetaspaceFreeRatio) ? "Default: " : "",
1934 MinMetaspaceFreeRatio,
1935 FLAG_IS_DEFAULT(MaxMetaspaceFreeRatio) ? "Default: " : "",
1936 MaxMetaspaceFreeRatio);
1937 status = false;
1938 }
1940 // Trying to keep 100% free is not practical
1941 MinMetaspaceFreeRatio = MIN2(MinMetaspaceFreeRatio, (uintx) 99);
1943 if (FullGCALot && FLAG_IS_DEFAULT(MarkSweepAlwaysCompactCount)) {
1944 MarkSweepAlwaysCompactCount = 1; // Move objects every gc.
1945 }
1947 if (UseParallelOldGC && ParallelOldGCSplitALot) {
1948 // Settings to encourage splitting.
1949 if (!FLAG_IS_CMDLINE(NewRatio)) {
1950 FLAG_SET_CMDLINE(uintx, NewRatio, 2);
1951 }
1952 if (!FLAG_IS_CMDLINE(ScavengeBeforeFullGC)) {
1953 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false);
1954 }
1955 }
1957 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
1958 status = status && verify_percentage(GCTimeLimit, "GCTimeLimit");
1959 if (GCTimeLimit == 100) {
1960 // Turn off gc-overhead-limit-exceeded checks
1961 FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
1962 }
1964 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
1966 status = status && check_gc_consistency();
1967 status = status && check_stack_pages();
1969 if (_has_alloc_profile) {
1970 if (UseParallelGC || UseParallelOldGC) {
1971 jio_fprintf(defaultStream::error_stream(),
1972 "error: invalid argument combination.\n"
1973 "Allocation profiling (-Xaprof) cannot be used together with "
1974 "Parallel GC (-XX:+UseParallelGC or -XX:+UseParallelOldGC).\n");
1975 status = false;
1976 }
1977 if (UseConcMarkSweepGC) {
1978 jio_fprintf(defaultStream::error_stream(),
1979 "error: invalid argument combination.\n"
1980 "Allocation profiling (-Xaprof) cannot be used together with "
1981 "the CMS collector (-XX:+UseConcMarkSweepGC).\n");
1982 status = false;
1983 }
1984 }
1986 if (CMSIncrementalMode) {
1987 if (!UseConcMarkSweepGC) {
1988 jio_fprintf(defaultStream::error_stream(),
1989 "error: invalid argument combination.\n"
1990 "The CMS collector (-XX:+UseConcMarkSweepGC) must be "
1991 "selected in order\nto use CMSIncrementalMode.\n");
1992 status = false;
1993 } else {
1994 status = status && verify_percentage(CMSIncrementalDutyCycle,
1995 "CMSIncrementalDutyCycle");
1996 status = status && verify_percentage(CMSIncrementalDutyCycleMin,
1997 "CMSIncrementalDutyCycleMin");
1998 status = status && verify_percentage(CMSIncrementalSafetyFactor,
1999 "CMSIncrementalSafetyFactor");
2000 status = status && verify_percentage(CMSIncrementalOffset,
2001 "CMSIncrementalOffset");
2002 status = status && verify_percentage(CMSExpAvgFactor,
2003 "CMSExpAvgFactor");
2004 // If it was not set on the command line, set
2005 // CMSInitiatingOccupancyFraction to 1 so icms can initiate cycles early.
2006 if (CMSInitiatingOccupancyFraction < 0) {
2007 FLAG_SET_DEFAULT(CMSInitiatingOccupancyFraction, 1);
2008 }
2009 }
2010 }
2012 // CMS space iteration, which FLSVerifyAllHeapreferences entails,
2013 // insists that we hold the requisite locks so that the iteration is
2014 // MT-safe. For the verification at start-up and shut-down, we don't
2015 // yet have a good way of acquiring and releasing these locks,
2016 // which are not visible at the CollectedHeap level. We want to
2017 // be able to acquire these locks and then do the iteration rather
2018 // than just disable the lock verification. This will be fixed under
2019 // bug 4788986.
2020 if (UseConcMarkSweepGC && FLSVerifyAllHeapReferences) {
2021 if (VerifyDuringStartup) {
2022 warning("Heap verification at start-up disabled "
2023 "(due to current incompatibility with FLSVerifyAllHeapReferences)");
2024 VerifyDuringStartup = false; // Disable verification at start-up
2025 }
2027 if (VerifyBeforeExit) {
2028 warning("Heap verification at shutdown disabled "
2029 "(due to current incompatibility with FLSVerifyAllHeapReferences)");
2030 VerifyBeforeExit = false; // Disable verification at shutdown
2031 }
2032 }
2034 // Note: only executed in non-PRODUCT mode
2035 if (!UseAsyncConcMarkSweepGC &&
2036 (ExplicitGCInvokesConcurrent ||
2037 ExplicitGCInvokesConcurrentAndUnloadsClasses)) {
2038 jio_fprintf(defaultStream::error_stream(),
2039 "error: +ExplicitGCInvokesConcurrent[AndUnloadsClasses] conflicts"
2040 " with -UseAsyncConcMarkSweepGC");
2041 status = false;
2042 }
2044 status = status && verify_min_value(ParGCArrayScanChunk, 1, "ParGCArrayScanChunk");
2046 #if INCLUDE_ALL_GCS
2047 if (UseG1GC) {
2048 status = status && verify_percentage(InitiatingHeapOccupancyPercent,
2049 "InitiatingHeapOccupancyPercent");
2050 status = status && verify_min_value(G1RefProcDrainInterval, 1,
2051 "G1RefProcDrainInterval");
2052 status = status && verify_min_value((intx)G1ConcMarkStepDurationMillis, 1,
2053 "G1ConcMarkStepDurationMillis");
2054 }
2055 #endif // INCLUDE_ALL_GCS
2057 status = status && verify_interval(RefDiscoveryPolicy,
2058 ReferenceProcessor::DiscoveryPolicyMin,
2059 ReferenceProcessor::DiscoveryPolicyMax,
2060 "RefDiscoveryPolicy");
2062 // Limit the lower bound of this flag to 1 as it is used in a division
2063 // expression.
2064 status = status && verify_interval(TLABWasteTargetPercent,
2065 1, 100, "TLABWasteTargetPercent");
2067 status = status && verify_object_alignment();
2069 status = status && verify_min_value(ClassMetaspaceSize, 1*M,
2070 "ClassMetaspaceSize");
2072 status = status && verify_interval(MarkStackSizeMax,
2073 1, (max_jint - 1), "MarkStackSizeMax");
2075 #ifdef SPARC
2076 if (UseConcMarkSweepGC || UseG1GC) {
2077 // Issue a stern warning if the user has explicitly set
2078 // UseMemSetInBOT (it is known to cause issues), but allow
2079 // use for experimentation and debugging.
2080 if (VM_Version::is_sun4v() && UseMemSetInBOT) {
2081 assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error");
2082 warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability"
2083 " on sun4v; please understand that you are using at your own risk!");
2084 }
2085 }
2086 #endif // SPARC
2088 if (PrintNMTStatistics) {
2089 #if INCLUDE_NMT
2090 if (MemTracker::tracking_level() == MemTracker::NMT_off) {
2091 #endif // INCLUDE_NMT
2092 warning("PrintNMTStatistics is disabled, because native memory tracking is not enabled");
2093 PrintNMTStatistics = false;
2094 #if INCLUDE_NMT
2095 }
2096 #endif
2097 }
2099 return status;
2100 }
2102 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
2103 const char* option_type) {
2104 if (ignore) return false;
2106 const char* spacer = " ";
2107 if (option_type == NULL) {
2108 option_type = ++spacer; // Set both to the empty string.
2109 }
2111 if (os::obsolete_option(option)) {
2112 jio_fprintf(defaultStream::error_stream(),
2113 "Obsolete %s%soption: %s\n", option_type, spacer,
2114 option->optionString);
2115 return false;
2116 } else {
2117 jio_fprintf(defaultStream::error_stream(),
2118 "Unrecognized %s%soption: %s\n", option_type, spacer,
2119 option->optionString);
2120 return true;
2121 }
2122 }
2124 static const char* user_assertion_options[] = {
2125 "-da", "-ea", "-disableassertions", "-enableassertions", 0
2126 };
2128 static const char* system_assertion_options[] = {
2129 "-dsa", "-esa", "-disablesystemassertions", "-enablesystemassertions", 0
2130 };
2132 // Return true if any of the strings in null-terminated array 'names' matches.
2133 // If tail_allowed is true, then the tail must begin with a colon; otherwise,
2134 // the option must match exactly.
2135 static bool match_option(const JavaVMOption* option, const char** names, const char** tail,
2136 bool tail_allowed) {
2137 for (/* empty */; *names != NULL; ++names) {
2138 if (match_option(option, *names, tail)) {
2139 if (**tail == '\0' || tail_allowed && **tail == ':') {
2140 return true;
2141 }
2142 }
2143 }
2144 return false;
2145 }
2147 bool Arguments::parse_uintx(const char* value,
2148 uintx* uintx_arg,
2149 uintx min_size) {
2151 // Check the sign first since atomull() parses only unsigned values.
2152 bool value_is_positive = !(*value == '-');
2154 if (value_is_positive) {
2155 julong n;
2156 bool good_return = atomull(value, &n);
2157 if (good_return) {
2158 bool above_minimum = n >= min_size;
2159 bool value_is_too_large = n > max_uintx;
2161 if (above_minimum && !value_is_too_large) {
2162 *uintx_arg = n;
2163 return true;
2164 }
2165 }
2166 }
2167 return false;
2168 }
2170 Arguments::ArgsRange Arguments::parse_memory_size(const char* s,
2171 julong* long_arg,
2172 julong min_size) {
2173 if (!atomull(s, long_arg)) return arg_unreadable;
2174 return check_memory_size(*long_arg, min_size);
2175 }
2177 // Parse JavaVMInitArgs structure
2179 jint Arguments::parse_vm_init_args(const JavaVMInitArgs* args) {
2180 // For components of the system classpath.
2181 SysClassPath scp(Arguments::get_sysclasspath());
2182 bool scp_assembly_required = false;
2184 // Save default settings for some mode flags
2185 Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
2186 Arguments::_UseOnStackReplacement = UseOnStackReplacement;
2187 Arguments::_ClipInlining = ClipInlining;
2188 Arguments::_BackgroundCompilation = BackgroundCompilation;
2190 // Setup flags for mixed which is the default
2191 set_mode_flags(_mixed);
2193 // Parse JAVA_TOOL_OPTIONS environment variable (if present)
2194 jint result = parse_java_tool_options_environment_variable(&scp, &scp_assembly_required);
2195 if (result != JNI_OK) {
2196 return result;
2197 }
2199 // Parse JavaVMInitArgs structure passed in
2200 result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, COMMAND_LINE);
2201 if (result != JNI_OK) {
2202 return result;
2203 }
2205 if (AggressiveOpts) {
2206 // Insert alt-rt.jar between user-specified bootclasspath
2207 // prefix and the default bootclasspath. os::set_boot_path()
2208 // uses meta_index_dir as the default bootclasspath directory.
2209 const char* altclasses_jar = "alt-rt.jar";
2210 size_t altclasses_path_len = strlen(get_meta_index_dir()) + 1 +
2211 strlen(altclasses_jar);
2212 char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len, mtInternal);
2213 strcpy(altclasses_path, get_meta_index_dir());
2214 strcat(altclasses_path, altclasses_jar);
2215 scp.add_suffix_to_prefix(altclasses_path);
2216 scp_assembly_required = true;
2217 FREE_C_HEAP_ARRAY(char, altclasses_path, mtInternal);
2218 }
2220 // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM)
2221 result = parse_java_options_environment_variable(&scp, &scp_assembly_required);
2222 if (result != JNI_OK) {
2223 return result;
2224 }
2226 // Do final processing now that all arguments have been parsed
2227 result = finalize_vm_init_args(&scp, scp_assembly_required);
2228 if (result != JNI_OK) {
2229 return result;
2230 }
2232 return JNI_OK;
2233 }
2235 // Checks if name in command-line argument -agent{lib,path}:name[=options]
2236 // represents a valid HPROF of JDWP agent. is_path==true denotes that we
2237 // are dealing with -agentpath (case where name is a path), otherwise with
2238 // -agentlib
2239 bool valid_hprof_or_jdwp_agent(char *name, bool is_path) {
2240 char *_name;
2241 const char *_hprof = "hprof", *_jdwp = "jdwp";
2242 size_t _len_hprof, _len_jdwp, _len_prefix;
2244 if (is_path) {
2245 if ((_name = strrchr(name, (int) *os::file_separator())) == NULL) {
2246 return false;
2247 }
2249 _name++; // skip past last path separator
2250 _len_prefix = strlen(JNI_LIB_PREFIX);
2252 if (strncmp(_name, JNI_LIB_PREFIX, _len_prefix) != 0) {
2253 return false;
2254 }
2256 _name += _len_prefix;
2257 _len_hprof = strlen(_hprof);
2258 _len_jdwp = strlen(_jdwp);
2260 if (strncmp(_name, _hprof, _len_hprof) == 0) {
2261 _name += _len_hprof;
2262 }
2263 else if (strncmp(_name, _jdwp, _len_jdwp) == 0) {
2264 _name += _len_jdwp;
2265 }
2266 else {
2267 return false;
2268 }
2270 if (strcmp(_name, JNI_LIB_SUFFIX) != 0) {
2271 return false;
2272 }
2274 return true;
2275 }
2277 if (strcmp(name, _hprof) == 0 || strcmp(name, _jdwp) == 0) {
2278 return true;
2279 }
2281 return false;
2282 }
2284 jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args,
2285 SysClassPath* scp_p,
2286 bool* scp_assembly_required_p,
2287 FlagValueOrigin origin) {
2288 // Remaining part of option string
2289 const char* tail;
2291 // iterate over arguments
2292 for (int index = 0; index < args->nOptions; index++) {
2293 bool is_absolute_path = false; // for -agentpath vs -agentlib
2295 const JavaVMOption* option = args->options + index;
2297 if (!match_option(option, "-Djava.class.path", &tail) &&
2298 !match_option(option, "-Dsun.java.command", &tail) &&
2299 !match_option(option, "-Dsun.java.launcher", &tail)) {
2301 // add all jvm options to the jvm_args string. This string
2302 // is used later to set the java.vm.args PerfData string constant.
2303 // the -Djava.class.path and the -Dsun.java.command options are
2304 // omitted from jvm_args string as each have their own PerfData
2305 // string constant object.
2306 build_jvm_args(option->optionString);
2307 }
2309 // -verbose:[class/gc/jni]
2310 if (match_option(option, "-verbose", &tail)) {
2311 if (!strcmp(tail, ":class") || !strcmp(tail, "")) {
2312 FLAG_SET_CMDLINE(bool, TraceClassLoading, true);
2313 FLAG_SET_CMDLINE(bool, TraceClassUnloading, true);
2314 } else if (!strcmp(tail, ":gc")) {
2315 FLAG_SET_CMDLINE(bool, PrintGC, true);
2316 } else if (!strcmp(tail, ":jni")) {
2317 FLAG_SET_CMDLINE(bool, PrintJNIResolving, true);
2318 }
2319 // -da / -ea / -disableassertions / -enableassertions
2320 // These accept an optional class/package name separated by a colon, e.g.,
2321 // -da:java.lang.Thread.
2322 } else if (match_option(option, user_assertion_options, &tail, true)) {
2323 bool enable = option->optionString[1] == 'e'; // char after '-' is 'e'
2324 if (*tail == '\0') {
2325 JavaAssertions::setUserClassDefault(enable);
2326 } else {
2327 assert(*tail == ':', "bogus match by match_option()");
2328 JavaAssertions::addOption(tail + 1, enable);
2329 }
2330 // -dsa / -esa / -disablesystemassertions / -enablesystemassertions
2331 } else if (match_option(option, system_assertion_options, &tail, false)) {
2332 bool enable = option->optionString[1] == 'e'; // char after '-' is 'e'
2333 JavaAssertions::setSystemClassDefault(enable);
2334 // -bootclasspath:
2335 } else if (match_option(option, "-Xbootclasspath:", &tail)) {
2336 scp_p->reset_path(tail);
2337 *scp_assembly_required_p = true;
2338 // -bootclasspath/a:
2339 } else if (match_option(option, "-Xbootclasspath/a:", &tail)) {
2340 scp_p->add_suffix(tail);
2341 *scp_assembly_required_p = true;
2342 // -bootclasspath/p:
2343 } else if (match_option(option, "-Xbootclasspath/p:", &tail)) {
2344 scp_p->add_prefix(tail);
2345 *scp_assembly_required_p = true;
2346 // -Xrun
2347 } else if (match_option(option, "-Xrun", &tail)) {
2348 if (tail != NULL) {
2349 const char* pos = strchr(tail, ':');
2350 size_t len = (pos == NULL) ? strlen(tail) : pos - tail;
2351 char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len);
2352 name[len] = '\0';
2354 char *options = NULL;
2355 if(pos != NULL) {
2356 size_t len2 = strlen(pos+1) + 1; // options start after ':'. Final zero must be copied.
2357 options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2);
2358 }
2359 #if !INCLUDE_JVMTI
2360 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
2361 jio_fprintf(defaultStream::error_stream(),
2362 "Profiling and debugging agents are not supported in this VM\n");
2363 return JNI_ERR;
2364 }
2365 #endif // !INCLUDE_JVMTI
2366 add_init_library(name, options);
2367 }
2368 // -agentlib and -agentpath
2369 } else if (match_option(option, "-agentlib:", &tail) ||
2370 (is_absolute_path = match_option(option, "-agentpath:", &tail))) {
2371 if(tail != NULL) {
2372 const char* pos = strchr(tail, '=');
2373 size_t len = (pos == NULL) ? strlen(tail) : pos - tail;
2374 char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len);
2375 name[len] = '\0';
2377 char *options = NULL;
2378 if(pos != NULL) {
2379 options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1);
2380 }
2381 #if !INCLUDE_JVMTI
2382 if (valid_hprof_or_jdwp_agent(name, is_absolute_path)) {
2383 jio_fprintf(defaultStream::error_stream(),
2384 "Profiling and debugging agents are not supported in this VM\n");
2385 return JNI_ERR;
2386 }
2387 #endif // !INCLUDE_JVMTI
2388 add_init_agent(name, options, is_absolute_path);
2389 }
2390 // -javaagent
2391 } else if (match_option(option, "-javaagent:", &tail)) {
2392 #if !INCLUDE_JVMTI
2393 jio_fprintf(defaultStream::error_stream(),
2394 "Instrumentation agents are not supported in this VM\n");
2395 return JNI_ERR;
2396 #else
2397 if(tail != NULL) {
2398 char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail);
2399 add_init_agent("instrument", options, false);
2400 }
2401 #endif // !INCLUDE_JVMTI
2402 // -Xnoclassgc
2403 } else if (match_option(option, "-Xnoclassgc", &tail)) {
2404 FLAG_SET_CMDLINE(bool, ClassUnloading, false);
2405 // -Xincgc: i-CMS
2406 } else if (match_option(option, "-Xincgc", &tail)) {
2407 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true);
2408 FLAG_SET_CMDLINE(bool, CMSIncrementalMode, true);
2409 // -Xnoincgc: no i-CMS
2410 } else if (match_option(option, "-Xnoincgc", &tail)) {
2411 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, false);
2412 FLAG_SET_CMDLINE(bool, CMSIncrementalMode, false);
2413 // -Xconcgc
2414 } else if (match_option(option, "-Xconcgc", &tail)) {
2415 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true);
2416 // -Xnoconcgc
2417 } else if (match_option(option, "-Xnoconcgc", &tail)) {
2418 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, false);
2419 // -Xbatch
2420 } else if (match_option(option, "-Xbatch", &tail)) {
2421 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
2422 // -Xmn for compatibility with other JVM vendors
2423 } else if (match_option(option, "-Xmn", &tail)) {
2424 julong long_initial_eden_size = 0;
2425 ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1);
2426 if (errcode != arg_in_range) {
2427 jio_fprintf(defaultStream::error_stream(),
2428 "Invalid initial eden size: %s\n", option->optionString);
2429 describe_range_error(errcode);
2430 return JNI_EINVAL;
2431 }
2432 FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size);
2433 FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size);
2434 // -Xms
2435 } else if (match_option(option, "-Xms", &tail)) {
2436 julong long_initial_heap_size = 0;
2437 // an initial heap size of 0 means automatically determine
2438 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 0);
2439 if (errcode != arg_in_range) {
2440 jio_fprintf(defaultStream::error_stream(),
2441 "Invalid initial heap size: %s\n", option->optionString);
2442 describe_range_error(errcode);
2443 return JNI_EINVAL;
2444 }
2445 FLAG_SET_CMDLINE(uintx, InitialHeapSize, (uintx)long_initial_heap_size);
2446 // Currently the minimum size and the initial heap sizes are the same.
2447 set_min_heap_size(InitialHeapSize);
2448 // -Xmx
2449 } else if (match_option(option, "-Xmx", &tail) || match_option(option, "-XX:MaxHeapSize=", &tail)) {
2450 julong long_max_heap_size = 0;
2451 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1);
2452 if (errcode != arg_in_range) {
2453 jio_fprintf(defaultStream::error_stream(),
2454 "Invalid maximum heap size: %s\n", option->optionString);
2455 describe_range_error(errcode);
2456 return JNI_EINVAL;
2457 }
2458 FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size);
2459 // Xmaxf
2460 } else if (match_option(option, "-Xmaxf", &tail)) {
2461 int maxf = (int)(atof(tail) * 100);
2462 if (maxf < 0 || maxf > 100) {
2463 jio_fprintf(defaultStream::error_stream(),
2464 "Bad max heap free percentage size: %s\n",
2465 option->optionString);
2466 return JNI_EINVAL;
2467 } else {
2468 FLAG_SET_CMDLINE(uintx, MaxHeapFreeRatio, maxf);
2469 }
2470 // Xminf
2471 } else if (match_option(option, "-Xminf", &tail)) {
2472 int minf = (int)(atof(tail) * 100);
2473 if (minf < 0 || minf > 100) {
2474 jio_fprintf(defaultStream::error_stream(),
2475 "Bad min heap free percentage size: %s\n",
2476 option->optionString);
2477 return JNI_EINVAL;
2478 } else {
2479 FLAG_SET_CMDLINE(uintx, MinHeapFreeRatio, minf);
2480 }
2481 // -Xss
2482 } else if (match_option(option, "-Xss", &tail)) {
2483 julong long_ThreadStackSize = 0;
2484 ArgsRange errcode = parse_memory_size(tail, &long_ThreadStackSize, 1000);
2485 if (errcode != arg_in_range) {
2486 jio_fprintf(defaultStream::error_stream(),
2487 "Invalid thread stack size: %s\n", option->optionString);
2488 describe_range_error(errcode);
2489 return JNI_EINVAL;
2490 }
2491 // Internally track ThreadStackSize in units of 1024 bytes.
2492 FLAG_SET_CMDLINE(intx, ThreadStackSize,
2493 round_to((int)long_ThreadStackSize, K) / K);
2494 // -Xoss
2495 } else if (match_option(option, "-Xoss", &tail)) {
2496 // HotSpot does not have separate native and Java stacks, ignore silently for compatibility
2497 // -Xmaxjitcodesize
2498 } else if (match_option(option, "-Xmaxjitcodesize", &tail) ||
2499 match_option(option, "-XX:ReservedCodeCacheSize=", &tail)) {
2500 julong long_ReservedCodeCacheSize = 0;
2501 ArgsRange errcode = parse_memory_size(tail, &long_ReservedCodeCacheSize,
2502 (size_t)InitialCodeCacheSize);
2503 if (errcode != arg_in_range) {
2504 jio_fprintf(defaultStream::error_stream(),
2505 "Invalid maximum code cache size: %s. Should be greater than InitialCodeCacheSize=%dK\n",
2506 option->optionString, InitialCodeCacheSize/K);
2507 describe_range_error(errcode);
2508 return JNI_EINVAL;
2509 }
2510 FLAG_SET_CMDLINE(uintx, ReservedCodeCacheSize, (uintx)long_ReservedCodeCacheSize);
2511 // -green
2512 } else if (match_option(option, "-green", &tail)) {
2513 jio_fprintf(defaultStream::error_stream(),
2514 "Green threads support not available\n");
2515 return JNI_EINVAL;
2516 // -native
2517 } else if (match_option(option, "-native", &tail)) {
2518 // HotSpot always uses native threads, ignore silently for compatibility
2519 // -Xsqnopause
2520 } else if (match_option(option, "-Xsqnopause", &tail)) {
2521 // EVM option, ignore silently for compatibility
2522 // -Xrs
2523 } else if (match_option(option, "-Xrs", &tail)) {
2524 // Classic/EVM option, new functionality
2525 FLAG_SET_CMDLINE(bool, ReduceSignalUsage, true);
2526 } else if (match_option(option, "-Xusealtsigs", &tail)) {
2527 // change default internal VM signals used - lower case for back compat
2528 FLAG_SET_CMDLINE(bool, UseAltSigs, true);
2529 // -Xoptimize
2530 } else if (match_option(option, "-Xoptimize", &tail)) {
2531 // EVM option, ignore silently for compatibility
2532 // -Xprof
2533 } else if (match_option(option, "-Xprof", &tail)) {
2534 #if INCLUDE_FPROF
2535 _has_profile = true;
2536 #else // INCLUDE_FPROF
2537 jio_fprintf(defaultStream::error_stream(),
2538 "Flat profiling is not supported in this VM.\n");
2539 return JNI_ERR;
2540 #endif // INCLUDE_FPROF
2541 // -Xaprof
2542 } else if (match_option(option, "-Xaprof", &tail)) {
2543 _has_alloc_profile = true;
2544 // -Xconcurrentio
2545 } else if (match_option(option, "-Xconcurrentio", &tail)) {
2546 FLAG_SET_CMDLINE(bool, UseLWPSynchronization, true);
2547 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
2548 FLAG_SET_CMDLINE(intx, DeferThrSuspendLoopCount, 1);
2549 FLAG_SET_CMDLINE(bool, UseTLAB, false);
2550 FLAG_SET_CMDLINE(uintx, NewSizeThreadIncrease, 16 * K); // 20Kb per thread added to new generation
2552 // -Xinternalversion
2553 } else if (match_option(option, "-Xinternalversion", &tail)) {
2554 jio_fprintf(defaultStream::output_stream(), "%s\n",
2555 VM_Version::internal_vm_info_string());
2556 vm_exit(0);
2557 #ifndef PRODUCT
2558 // -Xprintflags
2559 } else if (match_option(option, "-Xprintflags", &tail)) {
2560 CommandLineFlags::printFlags(tty, false);
2561 vm_exit(0);
2562 #endif
2563 // -D
2564 } else if (match_option(option, "-D", &tail)) {
2565 if (!add_property(tail)) {
2566 return JNI_ENOMEM;
2567 }
2568 // Out of the box management support
2569 if (match_option(option, "-Dcom.sun.management", &tail)) {
2570 #if INCLUDE_MANAGEMENT
2571 FLAG_SET_CMDLINE(bool, ManagementServer, true);
2572 #else
2573 jio_fprintf(defaultStream::output_stream(),
2574 "-Dcom.sun.management is not supported in this VM.\n");
2575 return JNI_ERR;
2576 #endif
2577 }
2578 // -Xint
2579 } else if (match_option(option, "-Xint", &tail)) {
2580 set_mode_flags(_int);
2581 // -Xmixed
2582 } else if (match_option(option, "-Xmixed", &tail)) {
2583 set_mode_flags(_mixed);
2584 // -Xcomp
2585 } else if (match_option(option, "-Xcomp", &tail)) {
2586 // for testing the compiler; turn off all flags that inhibit compilation
2587 set_mode_flags(_comp);
2588 // -Xshare:dump
2589 } else if (match_option(option, "-Xshare:dump", &tail)) {
2590 FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true);
2591 set_mode_flags(_int); // Prevent compilation, which creates objects
2592 // -Xshare:on
2593 } else if (match_option(option, "-Xshare:on", &tail)) {
2594 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true);
2595 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, true);
2596 // -Xshare:auto
2597 } else if (match_option(option, "-Xshare:auto", &tail)) {
2598 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true);
2599 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false);
2600 // -Xshare:off
2601 } else if (match_option(option, "-Xshare:off", &tail)) {
2602 FLAG_SET_CMDLINE(bool, UseSharedSpaces, false);
2603 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false);
2604 // -Xverify
2605 } else if (match_option(option, "-Xverify", &tail)) {
2606 if (strcmp(tail, ":all") == 0 || strcmp(tail, "") == 0) {
2607 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, true);
2608 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true);
2609 } else if (strcmp(tail, ":remote") == 0) {
2610 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, false);
2611 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true);
2612 } else if (strcmp(tail, ":none") == 0) {
2613 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, false);
2614 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, false);
2615 } else if (is_bad_option(option, args->ignoreUnrecognized, "verification")) {
2616 return JNI_EINVAL;
2617 }
2618 // -Xdebug
2619 } else if (match_option(option, "-Xdebug", &tail)) {
2620 // note this flag has been used, then ignore
2621 set_xdebug_mode(true);
2622 // -Xnoagent
2623 } else if (match_option(option, "-Xnoagent", &tail)) {
2624 // For compatibility with classic. HotSpot refuses to load the old style agent.dll.
2625 } else if (match_option(option, "-Xboundthreads", &tail)) {
2626 // Bind user level threads to kernel threads (Solaris only)
2627 FLAG_SET_CMDLINE(bool, UseBoundThreads, true);
2628 } else if (match_option(option, "-Xloggc:", &tail)) {
2629 // Redirect GC output to the file. -Xloggc:<filename>
2630 // ostream_init_log(), when called will use this filename
2631 // to initialize a fileStream.
2632 _gc_log_filename = strdup(tail);
2633 FLAG_SET_CMDLINE(bool, PrintGC, true);
2634 FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true);
2636 // JNI hooks
2637 } else if (match_option(option, "-Xcheck", &tail)) {
2638 if (!strcmp(tail, ":jni")) {
2639 #if !INCLUDE_JNI_CHECK
2640 warning("JNI CHECKING is not supported in this VM");
2641 #else
2642 CheckJNICalls = true;
2643 #endif // INCLUDE_JNI_CHECK
2644 } else if (is_bad_option(option, args->ignoreUnrecognized,
2645 "check")) {
2646 return JNI_EINVAL;
2647 }
2648 } else if (match_option(option, "vfprintf", &tail)) {
2649 _vfprintf_hook = CAST_TO_FN_PTR(vfprintf_hook_t, option->extraInfo);
2650 } else if (match_option(option, "exit", &tail)) {
2651 _exit_hook = CAST_TO_FN_PTR(exit_hook_t, option->extraInfo);
2652 } else if (match_option(option, "abort", &tail)) {
2653 _abort_hook = CAST_TO_FN_PTR(abort_hook_t, option->extraInfo);
2654 // -XX:+AggressiveHeap
2655 } else if (match_option(option, "-XX:+AggressiveHeap", &tail)) {
2657 // This option inspects the machine and attempts to set various
2658 // parameters to be optimal for long-running, memory allocation
2659 // intensive jobs. It is intended for machines with large
2660 // amounts of cpu and memory.
2662 // initHeapSize is needed since _initial_heap_size is 4 bytes on a 32 bit
2663 // VM, but we may not be able to represent the total physical memory
2664 // available (like having 8gb of memory on a box but using a 32bit VM).
2665 // Thus, we need to make sure we're using a julong for intermediate
2666 // calculations.
2667 julong initHeapSize;
2668 julong total_memory = os::physical_memory();
2670 if (total_memory < (julong)256*M) {
2671 jio_fprintf(defaultStream::error_stream(),
2672 "You need at least 256mb of memory to use -XX:+AggressiveHeap\n");
2673 vm_exit(1);
2674 }
2676 // The heap size is half of available memory, or (at most)
2677 // all of possible memory less 160mb (leaving room for the OS
2678 // when using ISM). This is the maximum; because adaptive sizing
2679 // is turned on below, the actual space used may be smaller.
2681 initHeapSize = MIN2(total_memory / (julong)2,
2682 total_memory - (julong)160*M);
2684 initHeapSize = limit_by_allocatable_memory(initHeapSize);
2686 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
2687 FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize);
2688 FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize);
2689 // Currently the minimum size and the initial heap sizes are the same.
2690 set_min_heap_size(initHeapSize);
2691 }
2692 if (FLAG_IS_DEFAULT(NewSize)) {
2693 // Make the young generation 3/8ths of the total heap.
2694 FLAG_SET_CMDLINE(uintx, NewSize,
2695 ((julong)MaxHeapSize / (julong)8) * (julong)3);
2696 FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize);
2697 }
2699 #ifndef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD.
2700 FLAG_SET_DEFAULT(UseLargePages, true);
2701 #endif
2703 // Increase some data structure sizes for efficiency
2704 FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize);
2705 FLAG_SET_CMDLINE(bool, ResizeTLAB, false);
2706 FLAG_SET_CMDLINE(uintx, TLABSize, 256*K);
2708 // See the OldPLABSize comment below, but replace 'after promotion'
2709 // with 'after copying'. YoungPLABSize is the size of the survivor
2710 // space per-gc-thread buffers. The default is 4kw.
2711 FLAG_SET_CMDLINE(uintx, YoungPLABSize, 256*K); // Note: this is in words
2713 // OldPLABSize is the size of the buffers in the old gen that
2714 // UseParallelGC uses to promote live data that doesn't fit in the
2715 // survivor spaces. At any given time, there's one for each gc thread.
2716 // The default size is 1kw. These buffers are rarely used, since the
2717 // survivor spaces are usually big enough. For specjbb, however, there
2718 // are occasions when there's lots of live data in the young gen
2719 // and we end up promoting some of it. We don't have a definite
2720 // explanation for why bumping OldPLABSize helps, but the theory
2721 // is that a bigger PLAB results in retaining something like the
2722 // original allocation order after promotion, which improves mutator
2723 // locality. A minor effect may be that larger PLABs reduce the
2724 // number of PLAB allocation events during gc. The value of 8kw
2725 // was arrived at by experimenting with specjbb.
2726 FLAG_SET_CMDLINE(uintx, OldPLABSize, 8*K); // Note: this is in words
2728 // Enable parallel GC and adaptive generation sizing
2729 FLAG_SET_CMDLINE(bool, UseParallelGC, true);
2730 FLAG_SET_DEFAULT(ParallelGCThreads,
2731 Abstract_VM_Version::parallel_worker_threads());
2733 // Encourage steady state memory management
2734 FLAG_SET_CMDLINE(uintx, ThresholdTolerance, 100);
2736 // This appears to improve mutator locality
2737 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false);
2739 // Get around early Solaris scheduling bug
2740 // (affinity vs other jobs on system)
2741 // but disallow DR and offlining (5008695).
2742 FLAG_SET_CMDLINE(bool, BindGCTaskThreadsToCPUs, true);
2744 } else if (match_option(option, "-XX:+NeverTenure", &tail)) {
2745 // The last option must always win.
2746 FLAG_SET_CMDLINE(bool, AlwaysTenure, false);
2747 FLAG_SET_CMDLINE(bool, NeverTenure, true);
2748 } else if (match_option(option, "-XX:+AlwaysTenure", &tail)) {
2749 // The last option must always win.
2750 FLAG_SET_CMDLINE(bool, NeverTenure, false);
2751 FLAG_SET_CMDLINE(bool, AlwaysTenure, true);
2752 } else if (match_option(option, "-XX:+CMSPermGenSweepingEnabled", &tail) ||
2753 match_option(option, "-XX:-CMSPermGenSweepingEnabled", &tail)) {
2754 jio_fprintf(defaultStream::error_stream(),
2755 "Please use CMSClassUnloadingEnabled in place of "
2756 "CMSPermGenSweepingEnabled in the future\n");
2757 } else if (match_option(option, "-XX:+UseGCTimeLimit", &tail)) {
2758 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, true);
2759 jio_fprintf(defaultStream::error_stream(),
2760 "Please use -XX:+UseGCOverheadLimit in place of "
2761 "-XX:+UseGCTimeLimit in the future\n");
2762 } else if (match_option(option, "-XX:-UseGCTimeLimit", &tail)) {
2763 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, false);
2764 jio_fprintf(defaultStream::error_stream(),
2765 "Please use -XX:-UseGCOverheadLimit in place of "
2766 "-XX:-UseGCTimeLimit in the future\n");
2767 // The TLE options are for compatibility with 1.3 and will be
2768 // removed without notice in a future release. These options
2769 // are not to be documented.
2770 } else if (match_option(option, "-XX:MaxTLERatio=", &tail)) {
2771 // No longer used.
2772 } else if (match_option(option, "-XX:+ResizeTLE", &tail)) {
2773 FLAG_SET_CMDLINE(bool, ResizeTLAB, true);
2774 } else if (match_option(option, "-XX:-ResizeTLE", &tail)) {
2775 FLAG_SET_CMDLINE(bool, ResizeTLAB, false);
2776 } else if (match_option(option, "-XX:+PrintTLE", &tail)) {
2777 FLAG_SET_CMDLINE(bool, PrintTLAB, true);
2778 } else if (match_option(option, "-XX:-PrintTLE", &tail)) {
2779 FLAG_SET_CMDLINE(bool, PrintTLAB, false);
2780 } else if (match_option(option, "-XX:TLEFragmentationRatio=", &tail)) {
2781 // No longer used.
2782 } else if (match_option(option, "-XX:TLESize=", &tail)) {
2783 julong long_tlab_size = 0;
2784 ArgsRange errcode = parse_memory_size(tail, &long_tlab_size, 1);
2785 if (errcode != arg_in_range) {
2786 jio_fprintf(defaultStream::error_stream(),
2787 "Invalid TLAB size: %s\n", option->optionString);
2788 describe_range_error(errcode);
2789 return JNI_EINVAL;
2790 }
2791 FLAG_SET_CMDLINE(uintx, TLABSize, long_tlab_size);
2792 } else if (match_option(option, "-XX:TLEThreadRatio=", &tail)) {
2793 // No longer used.
2794 } else if (match_option(option, "-XX:+UseTLE", &tail)) {
2795 FLAG_SET_CMDLINE(bool, UseTLAB, true);
2796 } else if (match_option(option, "-XX:-UseTLE", &tail)) {
2797 FLAG_SET_CMDLINE(bool, UseTLAB, false);
2798 SOLARIS_ONLY(
2799 } else if (match_option(option, "-XX:+UsePermISM", &tail)) {
2800 warning("-XX:+UsePermISM is obsolete.");
2801 FLAG_SET_CMDLINE(bool, UseISM, true);
2802 } else if (match_option(option, "-XX:-UsePermISM", &tail)) {
2803 FLAG_SET_CMDLINE(bool, UseISM, false);
2804 )
2805 } else if (match_option(option, "-XX:+DisplayVMOutputToStderr", &tail)) {
2806 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, false);
2807 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, true);
2808 } else if (match_option(option, "-XX:+DisplayVMOutputToStdout", &tail)) {
2809 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, false);
2810 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, true);
2811 } else if (match_option(option, "-XX:+ExtendedDTraceProbes", &tail)) {
2812 #if defined(DTRACE_ENABLED)
2813 FLAG_SET_CMDLINE(bool, ExtendedDTraceProbes, true);
2814 FLAG_SET_CMDLINE(bool, DTraceMethodProbes, true);
2815 FLAG_SET_CMDLINE(bool, DTraceAllocProbes, true);
2816 FLAG_SET_CMDLINE(bool, DTraceMonitorProbes, true);
2817 #else // defined(DTRACE_ENABLED)
2818 jio_fprintf(defaultStream::error_stream(),
2819 "ExtendedDTraceProbes flag is not applicable for this configuration\n");
2820 return JNI_EINVAL;
2821 #endif // defined(DTRACE_ENABLED)
2822 #ifdef ASSERT
2823 } else if (match_option(option, "-XX:+FullGCALot", &tail)) {
2824 FLAG_SET_CMDLINE(bool, FullGCALot, true);
2825 // disable scavenge before parallel mark-compact
2826 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false);
2827 #endif
2828 } else if (match_option(option, "-XX:CMSParPromoteBlocksToClaim=", &tail)) {
2829 julong cms_blocks_to_claim = (julong)atol(tail);
2830 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim);
2831 jio_fprintf(defaultStream::error_stream(),
2832 "Please use -XX:OldPLABSize in place of "
2833 "-XX:CMSParPromoteBlocksToClaim in the future\n");
2834 } else if (match_option(option, "-XX:ParCMSPromoteBlocksToClaim=", &tail)) {
2835 julong cms_blocks_to_claim = (julong)atol(tail);
2836 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim);
2837 jio_fprintf(defaultStream::error_stream(),
2838 "Please use -XX:OldPLABSize in place of "
2839 "-XX:ParCMSPromoteBlocksToClaim in the future\n");
2840 } else if (match_option(option, "-XX:ParallelGCOldGenAllocBufferSize=", &tail)) {
2841 julong old_plab_size = 0;
2842 ArgsRange errcode = parse_memory_size(tail, &old_plab_size, 1);
2843 if (errcode != arg_in_range) {
2844 jio_fprintf(defaultStream::error_stream(),
2845 "Invalid old PLAB size: %s\n", option->optionString);
2846 describe_range_error(errcode);
2847 return JNI_EINVAL;
2848 }
2849 FLAG_SET_CMDLINE(uintx, OldPLABSize, old_plab_size);
2850 jio_fprintf(defaultStream::error_stream(),
2851 "Please use -XX:OldPLABSize in place of "
2852 "-XX:ParallelGCOldGenAllocBufferSize in the future\n");
2853 } else if (match_option(option, "-XX:ParallelGCToSpaceAllocBufferSize=", &tail)) {
2854 julong young_plab_size = 0;
2855 ArgsRange errcode = parse_memory_size(tail, &young_plab_size, 1);
2856 if (errcode != arg_in_range) {
2857 jio_fprintf(defaultStream::error_stream(),
2858 "Invalid young PLAB size: %s\n", option->optionString);
2859 describe_range_error(errcode);
2860 return JNI_EINVAL;
2861 }
2862 FLAG_SET_CMDLINE(uintx, YoungPLABSize, young_plab_size);
2863 jio_fprintf(defaultStream::error_stream(),
2864 "Please use -XX:YoungPLABSize in place of "
2865 "-XX:ParallelGCToSpaceAllocBufferSize in the future\n");
2866 } else if (match_option(option, "-XX:CMSMarkStackSize=", &tail) ||
2867 match_option(option, "-XX:G1MarkStackSize=", &tail)) {
2868 julong stack_size = 0;
2869 ArgsRange errcode = parse_memory_size(tail, &stack_size, 1);
2870 if (errcode != arg_in_range) {
2871 jio_fprintf(defaultStream::error_stream(),
2872 "Invalid mark stack size: %s\n", option->optionString);
2873 describe_range_error(errcode);
2874 return JNI_EINVAL;
2875 }
2876 FLAG_SET_CMDLINE(uintx, MarkStackSize, stack_size);
2877 } else if (match_option(option, "-XX:CMSMarkStackSizeMax=", &tail)) {
2878 julong max_stack_size = 0;
2879 ArgsRange errcode = parse_memory_size(tail, &max_stack_size, 1);
2880 if (errcode != arg_in_range) {
2881 jio_fprintf(defaultStream::error_stream(),
2882 "Invalid maximum mark stack size: %s\n",
2883 option->optionString);
2884 describe_range_error(errcode);
2885 return JNI_EINVAL;
2886 }
2887 FLAG_SET_CMDLINE(uintx, MarkStackSizeMax, max_stack_size);
2888 } else if (match_option(option, "-XX:ParallelMarkingThreads=", &tail) ||
2889 match_option(option, "-XX:ParallelCMSThreads=", &tail)) {
2890 uintx conc_threads = 0;
2891 if (!parse_uintx(tail, &conc_threads, 1)) {
2892 jio_fprintf(defaultStream::error_stream(),
2893 "Invalid concurrent threads: %s\n", option->optionString);
2894 return JNI_EINVAL;
2895 }
2896 FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads);
2897 } else if (match_option(option, "-XX:MaxDirectMemorySize=", &tail)) {
2898 julong max_direct_memory_size = 0;
2899 ArgsRange errcode = parse_memory_size(tail, &max_direct_memory_size, 0);
2900 if (errcode != arg_in_range) {
2901 jio_fprintf(defaultStream::error_stream(),
2902 "Invalid maximum direct memory size: %s\n",
2903 option->optionString);
2904 describe_range_error(errcode);
2905 return JNI_EINVAL;
2906 }
2907 FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size);
2908 } else if (match_option(option, "-XX:+UseVMInterruptibleIO", &tail)) {
2909 // NOTE! In JDK 9, the UseVMInterruptibleIO flag will completely go
2910 // away and will cause VM initialization failures!
2911 warning("-XX:+UseVMInterruptibleIO is obsolete and will be removed in a future release.");
2912 FLAG_SET_CMDLINE(bool, UseVMInterruptibleIO, true);
2913 #if !INCLUDE_MANAGEMENT
2914 } else if (match_option(option, "-XX:+ManagementServer", &tail)) {
2915 jio_fprintf(defaultStream::error_stream(),
2916 "ManagementServer is not supported in this VM.\n");
2917 return JNI_ERR;
2918 #endif // INCLUDE_MANAGEMENT
2919 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx
2920 // Skip -XX:Flags= since that case has already been handled
2921 if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) {
2922 if (!process_argument(tail, args->ignoreUnrecognized, origin)) {
2923 return JNI_EINVAL;
2924 }
2925 }
2926 // Unknown option
2927 } else if (is_bad_option(option, args->ignoreUnrecognized)) {
2928 return JNI_ERR;
2929 }
2930 }
2932 // Change the default value for flags which have different default values
2933 // when working with older JDKs.
2934 #ifdef LINUX
2935 if (JDK_Version::current().compare_major(6) <= 0 &&
2936 FLAG_IS_DEFAULT(UseLinuxPosixThreadCPUClocks)) {
2937 FLAG_SET_DEFAULT(UseLinuxPosixThreadCPUClocks, false);
2938 }
2939 #endif // LINUX
2940 return JNI_OK;
2941 }
2943 jint Arguments::finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required) {
2944 // This must be done after all -D arguments have been processed.
2945 scp_p->expand_endorsed();
2947 if (scp_assembly_required || scp_p->get_endorsed() != NULL) {
2948 // Assemble the bootclasspath elements into the final path.
2949 Arguments::set_sysclasspath(scp_p->combined_path());
2950 }
2952 // This must be done after all arguments have been processed.
2953 // java_compiler() true means set to "NONE" or empty.
2954 if (java_compiler() && !xdebug_mode()) {
2955 // For backwards compatibility, we switch to interpreted mode if
2956 // -Djava.compiler="NONE" or "" is specified AND "-Xdebug" was
2957 // not specified.
2958 set_mode_flags(_int);
2959 }
2960 if (CompileThreshold == 0) {
2961 set_mode_flags(_int);
2962 }
2964 #ifndef COMPILER2
2965 // Don't degrade server performance for footprint
2966 if (FLAG_IS_DEFAULT(UseLargePages) &&
2967 MaxHeapSize < LargePageHeapSizeThreshold) {
2968 // No need for large granularity pages w/small heaps.
2969 // Note that large pages are enabled/disabled for both the
2970 // Java heap and the code cache.
2971 FLAG_SET_DEFAULT(UseLargePages, false);
2972 SOLARIS_ONLY(FLAG_SET_DEFAULT(UseMPSS, false));
2973 SOLARIS_ONLY(FLAG_SET_DEFAULT(UseISM, false));
2974 }
2976 // Tiered compilation is undefined with C1.
2977 TieredCompilation = false;
2978 #else
2979 if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) {
2980 FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1);
2981 }
2982 #endif
2984 // If we are running in a headless jre, force java.awt.headless property
2985 // to be true unless the property has already been set.
2986 // Also allow the OS environment variable JAVA_AWT_HEADLESS to set headless state.
2987 if (os::is_headless_jre()) {
2988 const char* headless = Arguments::get_property("java.awt.headless");
2989 if (headless == NULL) {
2990 char envbuffer[128];
2991 if (!os::getenv("JAVA_AWT_HEADLESS", envbuffer, sizeof(envbuffer))) {
2992 if (!add_property("java.awt.headless=true")) {
2993 return JNI_ENOMEM;
2994 }
2995 } else {
2996 char buffer[256];
2997 strcpy(buffer, "java.awt.headless=");
2998 strcat(buffer, envbuffer);
2999 if (!add_property(buffer)) {
3000 return JNI_ENOMEM;
3001 }
3002 }
3003 }
3004 }
3006 if (!check_vm_args_consistency()) {
3007 return JNI_ERR;
3008 }
3010 return JNI_OK;
3011 }
3013 jint Arguments::parse_java_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p) {
3014 return parse_options_environment_variable("_JAVA_OPTIONS", scp_p,
3015 scp_assembly_required_p);
3016 }
3018 jint Arguments::parse_java_tool_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p) {
3019 return parse_options_environment_variable("JAVA_TOOL_OPTIONS", scp_p,
3020 scp_assembly_required_p);
3021 }
3023 jint Arguments::parse_options_environment_variable(const char* name, SysClassPath* scp_p, bool* scp_assembly_required_p) {
3024 const int N_MAX_OPTIONS = 64;
3025 const int OPTION_BUFFER_SIZE = 1024;
3026 char buffer[OPTION_BUFFER_SIZE];
3028 // The variable will be ignored if it exceeds the length of the buffer.
3029 // Don't check this variable if user has special privileges
3030 // (e.g. unix su command).
3031 if (os::getenv(name, buffer, sizeof(buffer)) &&
3032 !os::have_special_privileges()) {
3033 JavaVMOption options[N_MAX_OPTIONS]; // Construct option array
3034 jio_fprintf(defaultStream::error_stream(),
3035 "Picked up %s: %s\n", name, buffer);
3036 char* rd = buffer; // pointer to the input string (rd)
3037 int i;
3038 for (i = 0; i < N_MAX_OPTIONS;) { // repeat for all options in the input string
3039 while (isspace(*rd)) rd++; // skip whitespace
3040 if (*rd == 0) break; // we re done when the input string is read completely
3042 // The output, option string, overwrites the input string.
3043 // Because of quoting, the pointer to the option string (wrt) may lag the pointer to
3044 // input string (rd).
3045 char* wrt = rd;
3047 options[i++].optionString = wrt; // Fill in option
3048 while (*rd != 0 && !isspace(*rd)) { // unquoted strings terminate with a space or NULL
3049 if (*rd == '\'' || *rd == '"') { // handle a quoted string
3050 int quote = *rd; // matching quote to look for
3051 rd++; // don't copy open quote
3052 while (*rd != quote) { // include everything (even spaces) up until quote
3053 if (*rd == 0) { // string termination means unmatched string
3054 jio_fprintf(defaultStream::error_stream(),
3055 "Unmatched quote in %s\n", name);
3056 return JNI_ERR;
3057 }
3058 *wrt++ = *rd++; // copy to option string
3059 }
3060 rd++; // don't copy close quote
3061 } else {
3062 *wrt++ = *rd++; // copy to option string
3063 }
3064 }
3065 // Need to check if we're done before writing a NULL,
3066 // because the write could be to the byte that rd is pointing to.
3067 if (*rd++ == 0) {
3068 *wrt = 0;
3069 break;
3070 }
3071 *wrt = 0; // Zero terminate option
3072 }
3073 // Construct JavaVMInitArgs structure and parse as if it was part of the command line
3074 JavaVMInitArgs vm_args;
3075 vm_args.version = JNI_VERSION_1_2;
3076 vm_args.options = options;
3077 vm_args.nOptions = i;
3078 vm_args.ignoreUnrecognized = IgnoreUnrecognizedVMOptions;
3080 if (PrintVMOptions) {
3081 const char* tail;
3082 for (int i = 0; i < vm_args.nOptions; i++) {
3083 const JavaVMOption *option = vm_args.options + i;
3084 if (match_option(option, "-XX:", &tail)) {
3085 logOption(tail);
3086 }
3087 }
3088 }
3090 return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR));
3091 }
3092 return JNI_OK;
3093 }
3095 void Arguments::set_shared_spaces_flags() {
3096 const bool must_share = DumpSharedSpaces || RequireSharedSpaces;
3097 const bool might_share = must_share || UseSharedSpaces;
3099 // CompressedOops cannot be used with CDS. The offsets of oopmaps and
3100 // static fields are incorrect in the archive. With some more clever
3101 // initialization, this restriction can probably be lifted.
3102 // ??? UseLargePages might be okay now
3103 const bool cannot_share = UseCompressedOops ||
3104 (UseLargePages && FLAG_IS_CMDLINE(UseLargePages));
3105 if (cannot_share) {
3106 if (must_share) {
3107 warning("disabling large pages %s"
3108 "because of %s", "" LP64_ONLY("and compressed oops "),
3109 DumpSharedSpaces ? "-Xshare:dump" : "-Xshare:on");
3110 FLAG_SET_CMDLINE(bool, UseLargePages, false);
3111 LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedOops, false));
3112 LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedKlassPointers, false));
3113 } else {
3114 // Prefer compressed oops and large pages to class data sharing
3115 if (UseSharedSpaces && Verbose) {
3116 warning("turning off use of shared archive because of large pages%s",
3117 "" LP64_ONLY(" and/or compressed oops"));
3118 }
3119 no_shared_spaces();
3120 }
3121 } else if (UseLargePages && might_share) {
3122 // Disable large pages to allow shared spaces. This is sub-optimal, since
3123 // there may not even be a shared archive to use.
3124 FLAG_SET_DEFAULT(UseLargePages, false);
3125 }
3127 if (DumpSharedSpaces) {
3128 if (RequireSharedSpaces) {
3129 warning("cannot dump shared archive while using shared archive");
3130 }
3131 UseSharedSpaces = false;
3132 }
3133 }
3135 // Disable options not supported in this release, with a warning if they
3136 // were explicitly requested on the command-line
3137 #define UNSUPPORTED_OPTION(opt, description) \
3138 do { \
3139 if (opt) { \
3140 if (FLAG_IS_CMDLINE(opt)) { \
3141 warning(description " is disabled in this release."); \
3142 } \
3143 FLAG_SET_DEFAULT(opt, false); \
3144 } \
3145 } while(0)
3148 #define UNSUPPORTED_GC_OPTION(gc) \
3149 do { \
3150 if (gc) { \
3151 if (FLAG_IS_CMDLINE(gc)) { \
3152 warning(#gc " is not supported in this VM. Using Serial GC."); \
3153 } \
3154 FLAG_SET_DEFAULT(gc, false); \
3155 } \
3156 } while(0)
3158 #if !INCLUDE_ALL_GCS
3159 static void force_serial_gc() {
3160 FLAG_SET_DEFAULT(UseSerialGC, true);
3161 FLAG_SET_DEFAULT(CMSIncrementalMode, false); // special CMS suboption
3162 UNSUPPORTED_GC_OPTION(UseG1GC);
3163 UNSUPPORTED_GC_OPTION(UseParallelGC);
3164 UNSUPPORTED_GC_OPTION(UseParallelOldGC);
3165 UNSUPPORTED_GC_OPTION(UseConcMarkSweepGC);
3166 UNSUPPORTED_GC_OPTION(UseParNewGC);
3167 }
3168 #endif // INCLUDE_ALL_GCS
3170 // Parse entry point called from JNI_CreateJavaVM
3172 jint Arguments::parse(const JavaVMInitArgs* args) {
3174 // Sharing support
3175 // Construct the path to the archive
3176 char jvm_path[JVM_MAXPATHLEN];
3177 os::jvm_path(jvm_path, sizeof(jvm_path));
3178 char *end = strrchr(jvm_path, *os::file_separator());
3179 if (end != NULL) *end = '\0';
3180 char *shared_archive_path = NEW_C_HEAP_ARRAY(char, strlen(jvm_path) +
3181 strlen(os::file_separator()) + 20, mtInternal);
3182 if (shared_archive_path == NULL) return JNI_ENOMEM;
3183 strcpy(shared_archive_path, jvm_path);
3184 strcat(shared_archive_path, os::file_separator());
3185 strcat(shared_archive_path, "classes");
3186 strcat(shared_archive_path, ".jsa");
3187 SharedArchivePath = shared_archive_path;
3189 // Remaining part of option string
3190 const char* tail;
3192 // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed.
3193 const char* hotspotrc = ".hotspotrc";
3194 bool settings_file_specified = false;
3195 bool needs_hotspotrc_warning = false;
3197 const char* flags_file;
3198 int index;
3199 for (index = 0; index < args->nOptions; index++) {
3200 const JavaVMOption *option = args->options + index;
3201 if (match_option(option, "-XX:Flags=", &tail)) {
3202 flags_file = tail;
3203 settings_file_specified = true;
3204 }
3205 if (match_option(option, "-XX:+PrintVMOptions", &tail)) {
3206 PrintVMOptions = true;
3207 }
3208 if (match_option(option, "-XX:-PrintVMOptions", &tail)) {
3209 PrintVMOptions = false;
3210 }
3211 if (match_option(option, "-XX:+IgnoreUnrecognizedVMOptions", &tail)) {
3212 IgnoreUnrecognizedVMOptions = true;
3213 }
3214 if (match_option(option, "-XX:-IgnoreUnrecognizedVMOptions", &tail)) {
3215 IgnoreUnrecognizedVMOptions = false;
3216 }
3217 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) {
3218 CommandLineFlags::printFlags(tty, false);
3219 vm_exit(0);
3220 }
3221 if (match_option(option, "-XX:NativeMemoryTracking", &tail)) {
3222 #if INCLUDE_NMT
3223 MemTracker::init_tracking_options(tail);
3224 #else
3225 jio_fprintf(defaultStream::error_stream(),
3226 "Native Memory Tracking is not supported in this VM\n");
3227 return JNI_ERR;
3228 #endif
3229 }
3232 #ifndef PRODUCT
3233 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) {
3234 CommandLineFlags::printFlags(tty, true);
3235 vm_exit(0);
3236 }
3237 #endif
3238 }
3240 if (IgnoreUnrecognizedVMOptions) {
3241 // uncast const to modify the flag args->ignoreUnrecognized
3242 *(jboolean*)(&args->ignoreUnrecognized) = true;
3243 }
3245 // Parse specified settings file
3246 if (settings_file_specified) {
3247 if (!process_settings_file(flags_file, true, args->ignoreUnrecognized)) {
3248 return JNI_EINVAL;
3249 }
3250 } else {
3251 #ifdef ASSERT
3252 // Parse default .hotspotrc settings file
3253 if (!process_settings_file(".hotspotrc", false, args->ignoreUnrecognized)) {
3254 return JNI_EINVAL;
3255 }
3256 #else
3257 struct stat buf;
3258 if (os::stat(hotspotrc, &buf) == 0) {
3259 needs_hotspotrc_warning = true;
3260 }
3261 #endif
3262 }
3264 if (PrintVMOptions) {
3265 for (index = 0; index < args->nOptions; index++) {
3266 const JavaVMOption *option = args->options + index;
3267 if (match_option(option, "-XX:", &tail)) {
3268 logOption(tail);
3269 }
3270 }
3271 }
3273 // Parse JavaVMInitArgs structure passed in, as well as JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
3274 jint result = parse_vm_init_args(args);
3275 if (result != JNI_OK) {
3276 return result;
3277 }
3279 // Delay warning until here so that we've had a chance to process
3280 // the -XX:-PrintWarnings flag
3281 if (needs_hotspotrc_warning) {
3282 warning("%s file is present but has been ignored. "
3283 "Run with -XX:Flags=%s to load the file.",
3284 hotspotrc, hotspotrc);
3285 }
3287 #ifdef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD.
3288 UNSUPPORTED_OPTION(UseLargePages, "-XX:+UseLargePages");
3289 #endif
3291 #if INCLUDE_ALL_GCS
3292 #if (defined JAVASE_EMBEDDED || defined ARM)
3293 UNSUPPORTED_OPTION(UseG1GC, "G1 GC");
3294 #endif
3295 #endif
3297 #ifndef PRODUCT
3298 if (TraceBytecodesAt != 0) {
3299 TraceBytecodes = true;
3300 }
3301 if (CountCompiledCalls) {
3302 if (UseCounterDecay) {
3303 warning("UseCounterDecay disabled because CountCalls is set");
3304 UseCounterDecay = false;
3305 }
3306 }
3307 #endif // PRODUCT
3309 // JSR 292 is not supported before 1.7
3310 if (!JDK_Version::is_gte_jdk17x_version()) {
3311 if (EnableInvokeDynamic) {
3312 if (!FLAG_IS_DEFAULT(EnableInvokeDynamic)) {
3313 warning("JSR 292 is not supported before 1.7. Disabling support.");
3314 }
3315 EnableInvokeDynamic = false;
3316 }
3317 }
3319 if (EnableInvokeDynamic && ScavengeRootsInCode == 0) {
3320 if (!FLAG_IS_DEFAULT(ScavengeRootsInCode)) {
3321 warning("forcing ScavengeRootsInCode non-zero because EnableInvokeDynamic is true");
3322 }
3323 ScavengeRootsInCode = 1;
3324 }
3326 if (PrintGCDetails) {
3327 // Turn on -verbose:gc options as well
3328 PrintGC = true;
3329 }
3331 if (!JDK_Version::is_gte_jdk18x_version()) {
3332 // To avoid changing the log format for 7 updates this flag is only
3333 // true by default in JDK8 and above.
3334 if (FLAG_IS_DEFAULT(PrintGCCause)) {
3335 FLAG_SET_DEFAULT(PrintGCCause, false);
3336 }
3337 }
3339 // Set object alignment values.
3340 set_object_alignment();
3342 #if !INCLUDE_ALL_GCS
3343 force_serial_gc();
3344 #endif // INCLUDE_ALL_GCS
3345 #if !INCLUDE_CDS
3346 if (DumpSharedSpaces || RequireSharedSpaces) {
3347 jio_fprintf(defaultStream::error_stream(),
3348 "Shared spaces are not supported in this VM\n");
3349 return JNI_ERR;
3350 }
3351 if ((UseSharedSpaces && FLAG_IS_CMDLINE(UseSharedSpaces)) || PrintSharedSpaces) {
3352 warning("Shared spaces are not supported in this VM");
3353 FLAG_SET_DEFAULT(UseSharedSpaces, false);
3354 FLAG_SET_DEFAULT(PrintSharedSpaces, false);
3355 }
3356 no_shared_spaces();
3357 #endif // INCLUDE_CDS
3359 // Set flags based on ergonomics.
3360 set_ergonomics_flags();
3362 set_shared_spaces_flags();
3364 // Check the GC selections again.
3365 if (!check_gc_consistency()) {
3366 return JNI_EINVAL;
3367 }
3369 if (TieredCompilation) {
3370 set_tiered_flags();
3371 } else {
3372 // Check if the policy is valid. Policies 0 and 1 are valid for non-tiered setup.
3373 if (CompilationPolicyChoice >= 2) {
3374 vm_exit_during_initialization(
3375 "Incompatible compilation policy selected", NULL);
3376 }
3377 }
3379 // Set heap size based on available physical memory
3380 set_heap_size();
3382 #if INCLUDE_ALL_GCS
3383 // Set per-collector flags
3384 if (UseParallelGC || UseParallelOldGC) {
3385 set_parallel_gc_flags();
3386 } else if (UseConcMarkSweepGC) { // should be done before ParNew check below
3387 set_cms_and_parnew_gc_flags();
3388 } else if (UseParNewGC) { // skipped if CMS is set above
3389 set_parnew_gc_flags();
3390 } else if (UseG1GC) {
3391 set_g1_gc_flags();
3392 }
3393 check_deprecated_gcs();
3394 check_deprecated_gc_flags();
3395 if (AssumeMP && !UseSerialGC) {
3396 if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
3397 warning("If the number of processors is expected to increase from one, then"
3398 " you should configure the number of parallel GC threads appropriately"
3399 " using -XX:ParallelGCThreads=N");
3400 }
3401 }
3402 #else // INCLUDE_ALL_GCS
3403 assert(verify_serial_gc_flags(), "SerialGC unset");
3404 #endif // INCLUDE_ALL_GCS
3406 // Set bytecode rewriting flags
3407 set_bytecode_flags();
3409 // Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled.
3410 set_aggressive_opts_flags();
3412 // Turn off biased locking for locking debug mode flags,
3413 // which are subtlely different from each other but neither works with
3414 // biased locking.
3415 if (UseHeavyMonitors
3416 #ifdef COMPILER1
3417 || !UseFastLocking
3418 #endif // COMPILER1
3419 ) {
3420 if (!FLAG_IS_DEFAULT(UseBiasedLocking) && UseBiasedLocking) {
3421 // flag set to true on command line; warn the user that they
3422 // can't enable biased locking here
3423 warning("Biased Locking is not supported with locking debug flags"
3424 "; ignoring UseBiasedLocking flag." );
3425 }
3426 UseBiasedLocking = false;
3427 }
3429 #ifdef CC_INTERP
3430 // Clear flags not supported by the C++ interpreter
3431 FLAG_SET_DEFAULT(ProfileInterpreter, false);
3432 FLAG_SET_DEFAULT(UseBiasedLocking, false);
3433 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false));
3434 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedKlassPointers, false));
3435 #endif // CC_INTERP
3437 #ifdef COMPILER2
3438 if (!UseBiasedLocking || EmitSync != 0) {
3439 UseOptoBiasInlining = false;
3440 }
3441 if (!EliminateLocks) {
3442 EliminateNestedLocks = false;
3443 }
3444 if (!Inline) {
3445 IncrementalInline = false;
3446 }
3447 #ifndef PRODUCT
3448 if (!IncrementalInline) {
3449 AlwaysIncrementalInline = false;
3450 }
3451 #endif
3452 if (IncrementalInline && FLAG_IS_DEFAULT(MaxNodeLimit)) {
3453 // incremental inlining: bump MaxNodeLimit
3454 FLAG_SET_DEFAULT(MaxNodeLimit, (intx)75000);
3455 }
3456 #endif
3458 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
3459 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
3460 DebugNonSafepoints = true;
3461 }
3463 #ifndef PRODUCT
3464 if (CompileTheWorld) {
3465 // Force NmethodSweeper to sweep whole CodeCache each time.
3466 if (FLAG_IS_DEFAULT(NmethodSweepFraction)) {
3467 NmethodSweepFraction = 1;
3468 }
3469 }
3470 #endif
3472 if (PrintCommandLineFlags) {
3473 CommandLineFlags::printSetFlags(tty);
3474 }
3476 // Apply CPU specific policy for the BiasedLocking
3477 if (UseBiasedLocking) {
3478 if (!VM_Version::use_biased_locking() &&
3479 !(FLAG_IS_CMDLINE(UseBiasedLocking))) {
3480 UseBiasedLocking = false;
3481 }
3482 }
3484 // set PauseAtExit if the gamma launcher was used and a debugger is attached
3485 // but only if not already set on the commandline
3486 if (Arguments::created_by_gamma_launcher() && os::is_debugger_attached()) {
3487 bool set = false;
3488 CommandLineFlags::wasSetOnCmdline("PauseAtExit", &set);
3489 if (!set) {
3490 FLAG_SET_DEFAULT(PauseAtExit, true);
3491 }
3492 }
3494 return JNI_OK;
3495 }
3497 jint Arguments::adjust_after_os() {
3498 #if INCLUDE_ALL_GCS
3499 if (UseParallelGC || UseParallelOldGC) {
3500 if (UseNUMA) {
3501 if (FLAG_IS_DEFAULT(MinHeapDeltaBytes)) {
3502 FLAG_SET_DEFAULT(MinHeapDeltaBytes, 64*M);
3503 }
3504 // For those collectors or operating systems (eg, Windows) that do
3505 // not support full UseNUMA, we will map to UseNUMAInterleaving for now
3506 UseNUMAInterleaving = true;
3507 }
3508 }
3509 #endif // INCLUDE_ALL_GCS
3510 return JNI_OK;
3511 }
3513 int Arguments::PropertyList_count(SystemProperty* pl) {
3514 int count = 0;
3515 while(pl != NULL) {
3516 count++;
3517 pl = pl->next();
3518 }
3519 return count;
3520 }
3522 const char* Arguments::PropertyList_get_value(SystemProperty *pl, const char* key) {
3523 assert(key != NULL, "just checking");
3524 SystemProperty* prop;
3525 for (prop = pl; prop != NULL; prop = prop->next()) {
3526 if (strcmp(key, prop->key()) == 0) return prop->value();
3527 }
3528 return NULL;
3529 }
3531 const char* Arguments::PropertyList_get_key_at(SystemProperty *pl, int index) {
3532 int count = 0;
3533 const char* ret_val = NULL;
3535 while(pl != NULL) {
3536 if(count >= index) {
3537 ret_val = pl->key();
3538 break;
3539 }
3540 count++;
3541 pl = pl->next();
3542 }
3544 return ret_val;
3545 }
3547 char* Arguments::PropertyList_get_value_at(SystemProperty* pl, int index) {
3548 int count = 0;
3549 char* ret_val = NULL;
3551 while(pl != NULL) {
3552 if(count >= index) {
3553 ret_val = pl->value();
3554 break;
3555 }
3556 count++;
3557 pl = pl->next();
3558 }
3560 return ret_val;
3561 }
3563 void Arguments::PropertyList_add(SystemProperty** plist, SystemProperty *new_p) {
3564 SystemProperty* p = *plist;
3565 if (p == NULL) {
3566 *plist = new_p;
3567 } else {
3568 while (p->next() != NULL) {
3569 p = p->next();
3570 }
3571 p->set_next(new_p);
3572 }
3573 }
3575 void Arguments::PropertyList_add(SystemProperty** plist, const char* k, char* v) {
3576 if (plist == NULL)
3577 return;
3579 SystemProperty* new_p = new SystemProperty(k, v, true);
3580 PropertyList_add(plist, new_p);
3581 }
3583 // This add maintains unique property key in the list.
3584 void Arguments::PropertyList_unique_add(SystemProperty** plist, const char* k, char* v, jboolean append) {
3585 if (plist == NULL)
3586 return;
3588 // If property key exist then update with new value.
3589 SystemProperty* prop;
3590 for (prop = *plist; prop != NULL; prop = prop->next()) {
3591 if (strcmp(k, prop->key()) == 0) {
3592 if (append) {
3593 prop->append_value(v);
3594 } else {
3595 prop->set_value(v);
3596 }
3597 return;
3598 }
3599 }
3601 PropertyList_add(plist, k, v);
3602 }
3604 // Copies src into buf, replacing "%%" with "%" and "%p" with pid
3605 // Returns true if all of the source pointed by src has been copied over to
3606 // the destination buffer pointed by buf. Otherwise, returns false.
3607 // Notes:
3608 // 1. If the length (buflen) of the destination buffer excluding the
3609 // NULL terminator character is not long enough for holding the expanded
3610 // pid characters, it also returns false instead of returning the partially
3611 // expanded one.
3612 // 2. The passed in "buflen" should be large enough to hold the null terminator.
3613 bool Arguments::copy_expand_pid(const char* src, size_t srclen,
3614 char* buf, size_t buflen) {
3615 const char* p = src;
3616 char* b = buf;
3617 const char* src_end = &src[srclen];
3618 char* buf_end = &buf[buflen - 1];
3620 while (p < src_end && b < buf_end) {
3621 if (*p == '%') {
3622 switch (*(++p)) {
3623 case '%': // "%%" ==> "%"
3624 *b++ = *p++;
3625 break;
3626 case 'p': { // "%p" ==> current process id
3627 // buf_end points to the character before the last character so
3628 // that we could write '\0' to the end of the buffer.
3629 size_t buf_sz = buf_end - b + 1;
3630 int ret = jio_snprintf(b, buf_sz, "%d", os::current_process_id());
3632 // if jio_snprintf fails or the buffer is not long enough to hold
3633 // the expanded pid, returns false.
3634 if (ret < 0 || ret >= (int)buf_sz) {
3635 return false;
3636 } else {
3637 b += ret;
3638 assert(*b == '\0', "fail in copy_expand_pid");
3639 if (p == src_end && b == buf_end + 1) {
3640 // reach the end of the buffer.
3641 return true;
3642 }
3643 }
3644 p++;
3645 break;
3646 }
3647 default :
3648 *b++ = '%';
3649 }
3650 } else {
3651 *b++ = *p++;
3652 }
3653 }
3654 *b = '\0';
3655 return (p == src_end); // return false if not all of the source was copied
3656 }