1/*
2 * Copyright (c) 1997, 2016, 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 */
24
25#ifndef SHARE_VM_RUNTIME_ARGUMENTS_HPP
26#define SHARE_VM_RUNTIME_ARGUMENTS_HPP
27
28#include "logging/logLevel.hpp"
29#include "logging/logTag.hpp"
30#include "runtime/java.hpp"
31#include "runtime/os.hpp"
32#include "runtime/perfData.hpp"
33#include "utilities/debug.hpp"
34
35// Arguments parses the command line and recognizes options
36
37// Invocation API hook typedefs (these should really be defined in jni.hpp)
38extern "C" {
39  typedef void (JNICALL *abort_hook_t)(void);
40  typedef void (JNICALL *exit_hook_t)(jint code);
41  typedef jint (JNICALL *vfprintf_hook_t)(FILE *fp, const char *format, va_list args)  ATTRIBUTE_PRINTF(2, 0);
42}
43
44// Obsolete or deprecated -XX flag.
45struct SpecialFlag {
46  const char* name;
47  JDK_Version deprecated_in; // When the deprecation warning started (or "undefined").
48  JDK_Version obsolete_in;   // When the obsolete warning started (or "undefined").
49  JDK_Version expired_in;    // When the option expires (or "undefined").
50};
51
52// PathString is used as:
53//  - the underlying value for a SystemProperty
54//  - the path portion of an --patch-module module/path pair
55//  - the string that represents the system boot class path, Arguments::_system_boot_class_path.
56class PathString : public CHeapObj<mtArguments> {
57 protected:
58  char* _value;
59 public:
60  char* value() const { return _value; }
61
62  bool set_value(const char *value) {
63    if (_value != NULL) {
64      FreeHeap(_value);
65    }
66    _value = AllocateHeap(strlen(value)+1, mtArguments);
67    assert(_value != NULL, "Unable to allocate space for new path value");
68    if (_value != NULL) {
69      strcpy(_value, value);
70    } else {
71      // not able to allocate
72      return false;
73    }
74    return true;
75  }
76
77  void append_value(const char *value) {
78    char *sp;
79    size_t len = 0;
80    if (value != NULL) {
81      len = strlen(value);
82      if (_value != NULL) {
83        len += strlen(_value);
84      }
85      sp = AllocateHeap(len+2, mtArguments);
86      assert(sp != NULL, "Unable to allocate space for new append path value");
87      if (sp != NULL) {
88        if (_value != NULL) {
89          strcpy(sp, _value);
90          strcat(sp, os::path_separator());
91          strcat(sp, value);
92          FreeHeap(_value);
93        } else {
94          strcpy(sp, value);
95        }
96        _value = sp;
97      }
98    }
99  }
100
101  PathString(const char* value) {
102    if (value == NULL) {
103      _value = NULL;
104    } else {
105      _value = AllocateHeap(strlen(value)+1, mtArguments);
106      strcpy(_value, value);
107    }
108  }
109
110  ~PathString() {
111    if (_value != NULL) {
112      FreeHeap(_value);
113      _value = NULL;
114    }
115  }
116};
117
118// ModulePatchPath records the module/path pair as specified to --patch-module.
119class ModulePatchPath : public CHeapObj<mtInternal> {
120private:
121  char* _module_name;
122  PathString* _path;
123public:
124  ModulePatchPath(const char* module_name, const char* path) {
125    assert(module_name != NULL && path != NULL, "Invalid module name or path value");
126    size_t len = strlen(module_name) + 1;
127    _module_name = AllocateHeap(len, mtInternal);
128    strncpy(_module_name, module_name, len); // copy the trailing null
129    _path =  new PathString(path);
130  }
131
132  ~ModulePatchPath() {
133    if (_module_name != NULL) {
134      FreeHeap(_module_name);
135      _module_name = NULL;
136    }
137    if (_path != NULL) {
138      delete _path;
139      _path = NULL;
140    }
141  }
142
143  inline void set_path(const char* path) { _path->set_value(path); }
144  inline const char* module_name() const { return _module_name; }
145  inline char* path_string() const { return _path->value(); }
146};
147
148// Element describing System and User (-Dkey=value flags) defined property.
149//
150// An internal SystemProperty is one that has been removed in
151// jdk.internal.VM.saveAndRemoveProperties, like jdk.boot.class.path.append.
152//
153class SystemProperty : public PathString {
154 private:
155  char*           _key;
156  SystemProperty* _next;
157  bool            _internal;
158  bool            _writeable;
159  bool writeable() { return _writeable; }
160
161 public:
162  // Accessors
163  char* value() const                 { return PathString::value(); }
164  const char* key() const             { return _key; }
165  bool internal() const               { return _internal; }
166  SystemProperty* next() const        { return _next; }
167  void set_next(SystemProperty* next) { _next = next; }
168
169  bool is_readable() const {
170    return !_internal || strcmp(_key, "jdk.boot.class.path.append") == 0;
171  }
172
173  // A system property should only have its value set
174  // via an external interface if it is a writeable property.
175  // The internal, non-writeable property jdk.boot.class.path.append
176  // is the only exception to this rule.  It can be set externally
177  // via -Xbootclasspath/a or JVMTI OnLoad phase call to AddToBootstrapClassLoaderSearch.
178  // In those cases for jdk.boot.class.path.append, the base class
179  // set_value and append_value methods are called directly.
180  bool set_writeable_value(const char *value) {
181    if (writeable()) {
182      return set_value(value);
183    }
184    return false;
185  }
186
187  // Constructor
188  SystemProperty(const char* key, const char* value, bool writeable, bool internal = false) : PathString(value) {
189    if (key == NULL) {
190      _key = NULL;
191    } else {
192      _key = AllocateHeap(strlen(key)+1, mtArguments);
193      strcpy(_key, key);
194    }
195    _next = NULL;
196    _internal = internal;
197    _writeable = writeable;
198  }
199};
200
201
202// For use by -agentlib, -agentpath and -Xrun
203class AgentLibrary : public CHeapObj<mtArguments> {
204  friend class AgentLibraryList;
205public:
206  // Is this library valid or not. Don't rely on os_lib == NULL as statically
207  // linked lib could have handle of RTLD_DEFAULT which == 0 on some platforms
208  enum AgentState {
209    agent_invalid = 0,
210    agent_valid   = 1
211  };
212
213 private:
214  char*           _name;
215  char*           _options;
216  void*           _os_lib;
217  bool            _is_absolute_path;
218  bool            _is_static_lib;
219  AgentState      _state;
220  AgentLibrary*   _next;
221
222 public:
223  // Accessors
224  const char* name() const                  { return _name; }
225  char* options() const                     { return _options; }
226  bool is_absolute_path() const             { return _is_absolute_path; }
227  void* os_lib() const                      { return _os_lib; }
228  void set_os_lib(void* os_lib)             { _os_lib = os_lib; }
229  AgentLibrary* next() const                { return _next; }
230  bool is_static_lib() const                { return _is_static_lib; }
231  void set_static_lib(bool is_static_lib)   { _is_static_lib = is_static_lib; }
232  bool valid()                              { return (_state == agent_valid); }
233  void set_valid()                          { _state = agent_valid; }
234  void set_invalid()                        { _state = agent_invalid; }
235
236  // Constructor
237  AgentLibrary(const char* name, const char* options, bool is_absolute_path, void* os_lib) {
238    _name = AllocateHeap(strlen(name)+1, mtArguments);
239    strcpy(_name, name);
240    if (options == NULL) {
241      _options = NULL;
242    } else {
243      _options = AllocateHeap(strlen(options)+1, mtArguments);
244      strcpy(_options, options);
245    }
246    _is_absolute_path = is_absolute_path;
247    _os_lib = os_lib;
248    _next = NULL;
249    _state = agent_invalid;
250    _is_static_lib = false;
251  }
252};
253
254// maintain an order of entry list of AgentLibrary
255class AgentLibraryList VALUE_OBJ_CLASS_SPEC {
256 private:
257  AgentLibrary*   _first;
258  AgentLibrary*   _last;
259 public:
260  bool is_empty() const                     { return _first == NULL; }
261  AgentLibrary* first() const               { return _first; }
262
263  // add to the end of the list
264  void add(AgentLibrary* lib) {
265    if (is_empty()) {
266      _first = _last = lib;
267    } else {
268      _last->_next = lib;
269      _last = lib;
270    }
271    lib->_next = NULL;
272  }
273
274  // search for and remove a library known to be in the list
275  void remove(AgentLibrary* lib) {
276    AgentLibrary* curr;
277    AgentLibrary* prev = NULL;
278    for (curr = first(); curr != NULL; prev = curr, curr = curr->next()) {
279      if (curr == lib) {
280        break;
281      }
282    }
283    assert(curr != NULL, "always should be found");
284
285    if (curr != NULL) {
286      // it was found, by-pass this library
287      if (prev == NULL) {
288        _first = curr->_next;
289      } else {
290        prev->_next = curr->_next;
291      }
292      if (curr == _last) {
293        _last = prev;
294      }
295      curr->_next = NULL;
296    }
297  }
298
299  AgentLibraryList() {
300    _first = NULL;
301    _last = NULL;
302  }
303};
304
305// Helper class for controlling the lifetime of JavaVMInitArgs objects.
306class ScopedVMInitArgs;
307
308// Most logging functions require 5 tags. Some of them may be _NO_TAG.
309typedef struct {
310  const char* alias_name;
311  LogLevelType level;
312  bool exactMatch;
313  LogTagType tag0;
314  LogTagType tag1;
315  LogTagType tag2;
316  LogTagType tag3;
317  LogTagType tag4;
318  LogTagType tag5;
319} AliasedLoggingFlag;
320
321class Arguments : AllStatic {
322  friend class VMStructs;
323  friend class JvmtiExport;
324  friend class CodeCacheExtensions;
325 public:
326  // Operation modi
327  enum Mode {
328    _int,       // corresponds to -Xint
329    _mixed,     // corresponds to -Xmixed
330    _comp       // corresponds to -Xcomp
331  };
332
333  enum ArgsRange {
334    arg_unreadable = -3,
335    arg_too_small  = -2,
336    arg_too_big    = -1,
337    arg_in_range   = 0
338  };
339
340  enum PropertyAppendable {
341    AppendProperty,
342    AddProperty
343  };
344
345  enum PropertyWriteable {
346    WriteableProperty,
347    UnwriteableProperty
348  };
349
350  enum PropertyInternal {
351    InternalProperty,
352    ExternalProperty
353  };
354
355 private:
356
357  // a pointer to the flags file name if it is specified
358  static char*  _jvm_flags_file;
359  // an array containing all flags specified in the .hotspotrc file
360  static char** _jvm_flags_array;
361  static int    _num_jvm_flags;
362  // an array containing all jvm arguments specified in the command line
363  static char** _jvm_args_array;
364  static int    _num_jvm_args;
365  // string containing all java command (class/jarfile name and app args)
366  static char* _java_command;
367
368  // Property list
369  static SystemProperty* _system_properties;
370
371  // Quick accessor to System properties in the list:
372  static SystemProperty *_sun_boot_library_path;
373  static SystemProperty *_java_library_path;
374  static SystemProperty *_java_home;
375  static SystemProperty *_java_class_path;
376  static SystemProperty *_jdk_boot_class_path_append;
377
378  // --patch-module=module=<file>(<pathsep><file>)*
379  // Each element contains the associated module name, path
380  // string pair as specified to --patch-module.
381  static GrowableArray<ModulePatchPath*>* _patch_mod_prefix;
382
383  // The constructed value of the system class path after
384  // argument processing and JVMTI OnLoad additions via
385  // calls to AddToBootstrapClassLoaderSearch.  This is the
386  // final form before ClassLoader::setup_bootstrap_search().
387  // Note: since --patch-module is a module name/path pair, the
388  // system boot class path string no longer contains the "prefix"
389  // to the boot class path base piece as it did when
390  // -Xbootclasspath/p was supported.
391  static PathString *_system_boot_class_path;
392
393  // Set if a modular java runtime image is present vs. a build with exploded modules
394  static bool _has_jimage;
395
396  // temporary: to emit warning if the default ext dirs are not empty.
397  // remove this variable when the warning is no longer needed.
398  static char* _ext_dirs;
399
400  // java.vendor.url.bug, bug reporting URL for fatal errors.
401  static const char* _java_vendor_url_bug;
402
403  // sun.java.launcher, private property to provide information about
404  // java launcher
405  static const char* _sun_java_launcher;
406
407  // sun.java.launcher.pid, private property
408  static int    _sun_java_launcher_pid;
409
410  // was this VM created via the -XXaltjvm=<path> option
411  static bool   _sun_java_launcher_is_altjvm;
412
413  // Option flags
414  static bool   _has_profile;
415  static const char*  _gc_log_filename;
416  // Value of the conservative maximum heap alignment needed
417  static size_t  _conservative_max_heap_alignment;
418
419  static uintx  _min_heap_size;
420
421  // -Xrun arguments
422  static AgentLibraryList _libraryList;
423  static void add_init_library(const char* name, char* options)
424    { _libraryList.add(new AgentLibrary(name, options, false, NULL)); }
425
426  // -agentlib and -agentpath arguments
427  static AgentLibraryList _agentList;
428  static void add_init_agent(const char* name, char* options, bool absolute_path)
429    { _agentList.add(new AgentLibrary(name, options, absolute_path, NULL)); }
430
431  // Late-binding agents not started via arguments
432  static void add_loaded_agent(AgentLibrary *agentLib)
433    { _agentList.add(agentLib); }
434  static void add_loaded_agent(const char* name, char* options, bool absolute_path, void* os_lib)
435    { _agentList.add(new AgentLibrary(name, options, absolute_path, os_lib)); }
436
437  // Operation modi
438  static Mode _mode;
439  static void set_mode_flags(Mode mode);
440  static bool _java_compiler;
441  static void set_java_compiler(bool arg) { _java_compiler = arg; }
442  static bool java_compiler()   { return _java_compiler; }
443
444  // -Xdebug flag
445  static bool _xdebug_mode;
446  static void set_xdebug_mode(bool arg) { _xdebug_mode = arg; }
447  static bool xdebug_mode()             { return _xdebug_mode; }
448
449  // Used to save default settings
450  static bool _AlwaysCompileLoopMethods;
451  static bool _UseOnStackReplacement;
452  static bool _BackgroundCompilation;
453  static bool _ClipInlining;
454  static bool _CIDynamicCompilePriority;
455  static intx _Tier3InvokeNotifyFreqLog;
456  static intx _Tier4InvocationThreshold;
457
458  // Compilation mode.
459  static bool compilation_mode_selected();
460  static void select_compilation_mode_ergonomically();
461
462  // Tiered
463  static void set_tiered_flags();
464  // CMS/ParNew garbage collectors
465  static void set_parnew_gc_flags();
466  static void set_cms_and_parnew_gc_flags();
467  // UseParallel[Old]GC
468  static void set_parallel_gc_flags();
469  // Garbage-First (UseG1GC)
470  static void set_g1_gc_flags();
471  // GC ergonomics
472  static void set_conservative_max_heap_alignment();
473  static void set_use_compressed_oops();
474  static void set_use_compressed_klass_ptrs();
475  static void select_gc();
476  static void set_ergonomics_flags();
477  static void set_shared_spaces_flags();
478  // limits the given memory size by the maximum amount of memory this process is
479  // currently allowed to allocate or reserve.
480  static julong limit_by_allocatable_memory(julong size);
481  // Setup heap size
482  static void set_heap_size();
483  // Based on automatic selection criteria, should the
484  // low pause collector be used.
485  static bool should_auto_select_low_pause_collector();
486
487  // Bytecode rewriting
488  static void set_bytecode_flags();
489
490  // Invocation API hooks
491  static abort_hook_t     _abort_hook;
492  static exit_hook_t      _exit_hook;
493  static vfprintf_hook_t  _vfprintf_hook;
494
495  // System properties
496  static bool add_property(const char* prop, PropertyWriteable writeable=WriteableProperty,
497                           PropertyInternal internal=ExternalProperty);
498
499  static bool create_property(const char* prop_name, const char* prop_value, PropertyInternal internal);
500  static bool create_numbered_property(const char* prop_base_name, const char* prop_value, unsigned int count);
501
502  static int process_patch_mod_option(const char* patch_mod_tail, bool* patch_mod_javabase);
503
504  // Aggressive optimization flags.
505  static jint set_aggressive_opts_flags();
506
507  static jint set_aggressive_heap_flags();
508
509  // Argument parsing
510  static void do_pd_flag_adjustments();
511  static bool parse_argument(const char* arg, Flag::Flags origin);
512  static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin);
513  static void process_java_launcher_argument(const char*, void*);
514  static void process_java_compiler_argument(const char* arg);
515  static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args);
516  static jint parse_java_tool_options_environment_variable(ScopedVMInitArgs* vm_args);
517  static jint parse_java_options_environment_variable(ScopedVMInitArgs* vm_args);
518  static jint parse_vm_options_file(const char* file_name, ScopedVMInitArgs* vm_args);
519  static jint parse_options_buffer(const char* name, char* buffer, const size_t buf_len, ScopedVMInitArgs* vm_args);
520  static jint insert_vm_options_file(const JavaVMInitArgs* args,
521                                     const char* vm_options_file,
522                                     const int vm_options_file_pos,
523                                     ScopedVMInitArgs* vm_options_file_args,
524                                     ScopedVMInitArgs* args_out);
525  static bool args_contains_vm_options_file_arg(const JavaVMInitArgs* args);
526  static jint expand_vm_options_as_needed(const JavaVMInitArgs* args_in,
527                                          ScopedVMInitArgs* mod_args,
528                                          JavaVMInitArgs** args_out);
529  static jint match_special_option_and_act(const JavaVMInitArgs* args,
530                                           ScopedVMInitArgs* args_out);
531
532  static bool handle_deprecated_print_gc_flags();
533
534  static void handle_extra_cms_flags(const char* msg);
535
536  static jint parse_vm_init_args(const JavaVMInitArgs *java_tool_options_args,
537                                 const JavaVMInitArgs *java_options_args,
538                                 const JavaVMInitArgs *cmd_line_args);
539  static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, Flag::Flags origin);
540  static jint finalize_vm_init_args();
541  static bool is_bad_option(const JavaVMOption* option, jboolean ignore, const char* option_type);
542
543  static bool is_bad_option(const JavaVMOption* option, jboolean ignore) {
544    return is_bad_option(option, ignore, NULL);
545  }
546
547  static void describe_range_error(ArgsRange errcode);
548  static ArgsRange check_memory_size(julong size, julong min_size);
549  static ArgsRange parse_memory_size(const char* s, julong* long_arg,
550                                     julong min_size);
551  // Parse a string for a unsigned integer.  Returns true if value
552  // is an unsigned integer greater than or equal to the minimum
553  // parameter passed and returns the value in uintx_arg.  Returns
554  // false otherwise, with uintx_arg undefined.
555  static bool parse_uintx(const char* value, uintx* uintx_arg,
556                          uintx min_size);
557
558  // methods to build strings from individual args
559  static void build_jvm_args(const char* arg);
560  static void build_jvm_flags(const char* arg);
561  static void add_string(char*** bldarray, int* count, const char* arg);
562  static const char* build_resource_string(char** args, int count);
563
564  static bool methodExists(
565    char* className, char* methodName,
566    int classesNum, char** classes, bool* allMethods,
567    int methodsNum, char** methods, bool* allClasses
568  );
569
570  static void parseOnlyLine(
571    const char* line,
572    short* classesNum, short* classesMax, char*** classes, bool** allMethods,
573    short* methodsNum, short* methodsMax, char*** methods, bool** allClasses
574  );
575
576  // Returns true if the flag is obsolete (and not yet expired).
577  // In this case the 'version' buffer is filled in with
578  // the version number when the flag became obsolete.
579  static bool is_obsolete_flag(const char* flag_name, JDK_Version* version);
580
581#ifndef PRODUCT
582  static const char* removed_develop_logging_flag_name(const char* name);
583#endif // PRODUCT
584
585  // Returns 1 if the flag is deprecated (and not yet obsolete or expired).
586  //     In this case the 'version' buffer is filled in with the version number when
587  //     the flag became deprecated.
588  // Returns -1 if the flag is expired or obsolete.
589  // Returns 0 otherwise.
590  static int is_deprecated_flag(const char* flag_name, JDK_Version* version);
591
592  // Return the real name for the flag passed on the command line (either an alias name or "flag_name").
593  static const char* real_flag_name(const char *flag_name);
594
595  // Return the "real" name for option arg if arg is an alias, and print a warning if arg is deprecated.
596  // Return NULL if the arg has expired.
597  static const char* handle_aliases_and_deprecation(const char* arg, bool warn);
598  static bool lookup_logging_aliases(const char* arg, char* buffer);
599  static AliasedLoggingFlag catch_logging_aliases(const char* name, bool on);
600  static short  CompileOnlyClassesNum;
601  static short  CompileOnlyClassesMax;
602  static char** CompileOnlyClasses;
603  static bool*  CompileOnlyAllMethods;
604
605  static short  CompileOnlyMethodsNum;
606  static short  CompileOnlyMethodsMax;
607  static char** CompileOnlyMethods;
608  static bool*  CompileOnlyAllClasses;
609
610  static short  InterpretOnlyClassesNum;
611  static short  InterpretOnlyClassesMax;
612  static char** InterpretOnlyClasses;
613  static bool*  InterpretOnlyAllMethods;
614
615  static bool   CheckCompileOnly;
616
617  static char*  SharedArchivePath;
618
619 public:
620  // Scale compile thresholds
621  // Returns threshold scaled with CompileThresholdScaling
622  static intx scaled_compile_threshold(intx threshold, double scale);
623  static intx scaled_compile_threshold(intx threshold) {
624    return scaled_compile_threshold(threshold, CompileThresholdScaling);
625  }
626  // Returns freq_log scaled with CompileThresholdScaling
627  static intx scaled_freq_log(intx freq_log, double scale);
628  static intx scaled_freq_log(intx freq_log) {
629    return scaled_freq_log(freq_log, CompileThresholdScaling);
630  }
631
632  // Parses the arguments, first phase
633  static jint parse(const JavaVMInitArgs* args);
634  // Apply ergonomics
635  static jint apply_ergo();
636  // Adjusts the arguments after the OS have adjusted the arguments
637  static jint adjust_after_os();
638
639  static void set_gc_specific_flags();
640  static bool gc_selected(); // whether a gc has been selected
641  static void select_gc_ergonomically();
642#if INCLUDE_JVMCI
643  // Check consistency of jvmci vm argument settings.
644  static bool check_jvmci_args_consistency();
645  static void set_jvmci_specific_flags();
646#endif
647  // Check for consistency in the selection of the garbage collector.
648  static bool check_gc_consistency();        // Check user-selected gc
649  // Check consistency or otherwise of VM argument settings
650  static bool check_vm_args_consistency();
651  // Used by os_solaris
652  static bool process_settings_file(const char* file_name, bool should_exist, jboolean ignore_unrecognized);
653
654  static size_t conservative_max_heap_alignment() { return _conservative_max_heap_alignment; }
655  // Return the maximum size a heap with compressed oops can take
656  static size_t max_heap_for_compressed_oops();
657
658  // return a char* array containing all options
659  static char** jvm_flags_array()          { return _jvm_flags_array; }
660  static char** jvm_args_array()           { return _jvm_args_array; }
661  static int num_jvm_flags()               { return _num_jvm_flags; }
662  static int num_jvm_args()                { return _num_jvm_args; }
663  // return the arguments passed to the Java application
664  static const char* java_command()        { return _java_command; }
665
666  // print jvm_flags, jvm_args and java_command
667  static void print_on(outputStream* st);
668  static void print_summary_on(outputStream* st);
669
670  // convenient methods to get and set jvm_flags_file
671  static const char* get_jvm_flags_file()  { return _jvm_flags_file; }
672  static void set_jvm_flags_file(const char *value) {
673    if (_jvm_flags_file != NULL) {
674      os::free(_jvm_flags_file);
675    }
676    _jvm_flags_file = os::strdup_check_oom(value);
677  }
678  // convenient methods to obtain / print jvm_flags and jvm_args
679  static const char* jvm_flags()           { return build_resource_string(_jvm_flags_array, _num_jvm_flags); }
680  static const char* jvm_args()            { return build_resource_string(_jvm_args_array, _num_jvm_args); }
681  static void print_jvm_flags_on(outputStream* st);
682  static void print_jvm_args_on(outputStream* st);
683
684  // -Dkey=value flags
685  static SystemProperty*  system_properties()   { return _system_properties; }
686  static const char*    get_property(const char* key);
687
688  // -Djava.vendor.url.bug
689  static const char* java_vendor_url_bug()  { return _java_vendor_url_bug; }
690
691  // -Dsun.java.launcher
692  static const char* sun_java_launcher()    { return _sun_java_launcher; }
693  // Was VM created by a Java launcher?
694  static bool created_by_java_launcher();
695  // -Dsun.java.launcher.is_altjvm
696  static bool sun_java_launcher_is_altjvm();
697  // -Dsun.java.launcher.pid
698  static int sun_java_launcher_pid()        { return _sun_java_launcher_pid; }
699
700  // -Xprof
701  static bool has_profile()                 { return _has_profile; }
702
703  // -Xms
704  static size_t min_heap_size()             { return _min_heap_size; }
705  static void  set_min_heap_size(size_t v)  { _min_heap_size = v;  }
706
707  // -Xrun
708  static AgentLibrary* libraries()          { return _libraryList.first(); }
709  static bool init_libraries_at_startup()   { return !_libraryList.is_empty(); }
710  static void convert_library_to_agent(AgentLibrary* lib)
711                                            { _libraryList.remove(lib);
712                                              _agentList.add(lib); }
713
714  // -agentlib -agentpath
715  static AgentLibrary* agents()             { return _agentList.first(); }
716  static bool init_agents_at_startup()      { return !_agentList.is_empty(); }
717
718  // abort, exit, vfprintf hooks
719  static abort_hook_t    abort_hook()       { return _abort_hook; }
720  static exit_hook_t     exit_hook()        { return _exit_hook; }
721  static vfprintf_hook_t vfprintf_hook()    { return _vfprintf_hook; }
722
723  static bool GetCheckCompileOnly ()        { return CheckCompileOnly; }
724
725  static const char* GetSharedArchivePath() { return SharedArchivePath; }
726
727  static bool CompileMethod(char* className, char* methodName) {
728    return
729      methodExists(
730        className, methodName,
731        CompileOnlyClassesNum, CompileOnlyClasses, CompileOnlyAllMethods,
732        CompileOnlyMethodsNum, CompileOnlyMethods, CompileOnlyAllClasses
733      );
734  }
735
736  // Java launcher properties
737  static void process_sun_java_launcher_properties(JavaVMInitArgs* args);
738
739  // System properties
740  static void init_system_properties();
741
742  // Update/Initialize System properties after JDK version number is known
743  static void init_version_specific_system_properties();
744
745  // Property List manipulation
746  static void PropertyList_add(SystemProperty *element);
747  static void PropertyList_add(SystemProperty** plist, SystemProperty *element);
748  static void PropertyList_add(SystemProperty** plist, const char* k, const char* v, bool writeable, bool internal);
749
750  static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v,
751                                      PropertyAppendable append, PropertyWriteable writeable,
752                                      PropertyInternal internal);
753  static const char* PropertyList_get_value(SystemProperty* plist, const char* key);
754  static const char* PropertyList_get_readable_value(SystemProperty* plist, const char* key);
755  static int  PropertyList_count(SystemProperty* pl);
756  static int  PropertyList_readable_count(SystemProperty* pl);
757  static const char* PropertyList_get_key_at(SystemProperty* pl,int index);
758  static char* PropertyList_get_value_at(SystemProperty* pl,int index);
759
760  static bool is_internal_module_property(const char* option);
761
762  // Miscellaneous System property value getter and setters.
763  static void set_dll_dir(const char *value) { _sun_boot_library_path->set_value(value); }
764  static void set_java_home(const char *value) { _java_home->set_value(value); }
765  static void set_library_path(const char *value) { _java_library_path->set_value(value); }
766  static void set_ext_dirs(char *value)     { _ext_dirs = os::strdup_check_oom(value); }
767
768  // Set up the underlying pieces of the system boot class path
769  static void add_patch_mod_prefix(const char *module_name, const char *path, bool* patch_mod_javabase);
770  static void set_sysclasspath(const char *value, bool has_jimage) {
771    // During start up, set by os::set_boot_path()
772    assert(get_sysclasspath() == NULL, "System boot class path previously set");
773    _system_boot_class_path->set_value(value);
774    _has_jimage = has_jimage;
775  }
776  static void append_sysclasspath(const char *value) {
777    _system_boot_class_path->append_value(value);
778    _jdk_boot_class_path_append->append_value(value);
779  }
780
781  static GrowableArray<ModulePatchPath*>* get_patch_mod_prefix() { return _patch_mod_prefix; }
782  static char* get_sysclasspath() { return _system_boot_class_path->value(); }
783  static char* get_jdk_boot_class_path_append() { return _jdk_boot_class_path_append->value(); }
784  static bool has_jimage() { return _has_jimage; }
785
786  static char* get_java_home()    { return _java_home->value(); }
787  static char* get_dll_dir()      { return _sun_boot_library_path->value(); }
788  static char* get_ext_dirs()     { return _ext_dirs;  }
789  static char* get_appclasspath() { return _java_class_path->value(); }
790  static void  fix_appclasspath();
791
792
793  // Operation modi
794  static Mode mode()                        { return _mode; }
795  static bool is_interpreter_only() { return mode() == _int; }
796
797
798  // Utility: copies src into buf, replacing "%%" with "%" and "%p" with pid.
799  static bool copy_expand_pid(const char* src, size_t srclen, char* buf, size_t buflen);
800
801  static void check_unsupported_dumping_properties() NOT_CDS_RETURN;
802
803  static bool atojulong(const char *s, julong* result);
804};
805
806// Disable options not supported in this release, with a warning if they
807// were explicitly requested on the command-line
808#define UNSUPPORTED_OPTION(opt)                          \
809do {                                                     \
810  if (opt) {                                             \
811    if (FLAG_IS_CMDLINE(opt)) {                          \
812      warning("-XX:+" #opt " not supported in this VM"); \
813    }                                                    \
814    FLAG_SET_DEFAULT(opt, false);                        \
815  }                                                      \
816} while(0)
817
818#endif // SHARE_VM_RUNTIME_ARGUMENTS_HPP
819