< prev index next >

src/share/vm/runtime/arguments.hpp

Print this page




  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)
  38 extern "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 // PathString is used as:
  45 //  - the underlying value for a SystemProperty
  46 //  - the path portion of an -Xpatch module/path pair
  47 //  - the string that represents the system boot class path, Arguments::_system_boot_class_path.
  48 class PathString : public CHeapObj<mtArguments> {
  49  protected:
  50   char* _value;
  51  public:
  52   char* value() const { return _value; }
  53 
  54   bool set_value(const char *value) {
  55     if (_value != NULL) {
  56       FreeHeap(_value);
  57     }
  58     _value = AllocateHeap(strlen(value)+1, mtArguments);
  59     assert(_value != NULL, "Unable to allocate space for new path value");
  60     if (_value != NULL) {
  61       strcpy(_value, value);
  62     } else {
  63       // not able to allocate
  64       return false;
  65     }
  66     return true;


  90     }
  91   }
  92 
  93   PathString(const char* value) {
  94     if (value == NULL) {
  95       _value = NULL;
  96     } else {
  97       _value = AllocateHeap(strlen(value)+1, mtArguments);
  98       strcpy(_value, value);
  99     }
 100   }
 101 
 102   ~PathString() {
 103     if (_value != NULL) {
 104       FreeHeap(_value);
 105       _value = NULL;
 106     }
 107   }
 108 };
 109 
 110 // ModuleXPatchPath records the module/path pair as specified to -Xpatch.
 111 class ModuleXPatchPath : public CHeapObj<mtInternal> {
 112 private:
 113   char* _module_name;
 114   PathString* _path;
 115 public:
 116   ModuleXPatchPath(const char* module_name, const char* path) {
 117     assert(module_name != NULL && path != NULL, "Invalid module name or path value");
 118     size_t len = strlen(module_name) + 1;
 119     _module_name = AllocateHeap(len, mtInternal);
 120     strncpy(_module_name, module_name, len); // copy the trailing null
 121     _path =  new PathString(path);
 122   }
 123 
 124   ~ModuleXPatchPath() {
 125     if (_module_name != NULL) {
 126       FreeHeap(_module_name);
 127       _module_name = NULL;
 128     }
 129     if (_path != NULL) {
 130       delete _path;
 131       _path = NULL;
 132     }
 133   }
 134 
 135   inline void set_path(const char* path) { _path->set_value(path); }
 136   inline const char* module_name() const { return _module_name; }
 137   inline char* path_string() const { return _path->value(); }
 138 };
 139 
 140 // Element describing System and User (-Dkey=value flags) defined property.
 141 //
 142 // An internal SystemProperty is one that has been removed in
 143 // jdk.internal.VM.saveAndRemoveProperties, like jdk.boot.class.path.append.
 144 //


 308 
 309 class Arguments : AllStatic {
 310   friend class VMStructs;
 311   friend class JvmtiExport;
 312   friend class CodeCacheExtensions;
 313  public:
 314   // Operation modi
 315   enum Mode {
 316     _int,       // corresponds to -Xint
 317     _mixed,     // corresponds to -Xmixed
 318     _comp       // corresponds to -Xcomp
 319   };
 320 
 321   enum ArgsRange {
 322     arg_unreadable = -3,
 323     arg_too_small  = -2,
 324     arg_too_big    = -1,
 325     arg_in_range   = 0
 326   };
 327 















 328  private:
 329 
 330   // a pointer to the flags file name if it is specified
 331   static char*  _jvm_flags_file;
 332   // an array containing all flags specified in the .hotspotrc file
 333   static char** _jvm_flags_array;
 334   static int    _num_jvm_flags;
 335   // an array containing all jvm arguments specified in the command line
 336   static char** _jvm_args_array;
 337   static int    _num_jvm_args;
 338   // string containing all java command (class/jarfile name and app args)
 339   static char* _java_command;
 340 
 341   // Property list
 342   static SystemProperty* _system_properties;
 343 
 344   // Quick accessor to System properties in the list:
 345   static SystemProperty *_sun_boot_library_path;
 346   static SystemProperty *_java_library_path;
 347   static SystemProperty *_java_home;
 348   static SystemProperty *_java_class_path;
 349   static SystemProperty *_jdk_boot_class_path_append;
 350 
 351   // -Xpatch:module=<file>(<pathsep><file>)*
 352   // Each element contains the associated module name, path
 353   // string pair as specified to -Xpatch.
 354   static GrowableArray<ModuleXPatchPath*>* _xpatchprefix;
 355 
 356   // The constructed value of the system class path after
 357   // argument processing and JVMTI OnLoad additions via
 358   // calls to AddToBootstrapClassLoaderSearch.  This is the
 359   // final form before ClassLoader::setup_bootstrap_search().
 360   // Note: since -Xpatch is a module name/path pair, the system
 361   // boot class path string no longer contains the "prefix" to
 362   // the boot class path base piece as it did when
 363   // -Xbootclasspath/p was supported.
 364   static PathString *_system_boot_class_path;
 365 
 366   // temporary: to emit warning if the default ext dirs are not empty.
 367   // remove this variable when the warning is no longer needed.
 368   static char* _ext_dirs;
 369 
 370   // java.vendor.url.bug, bug reporting URL for fatal errors.
 371   static const char* _java_vendor_url_bug;
 372 
 373   // sun.java.launcher, private property to provide information about
 374   // java launcher
 375   static const char* _sun_java_launcher;
 376 
 377   // sun.java.launcher.pid, private property
 378   static int    _sun_java_launcher_pid;
 379 
 380   // was this VM created via the -XXaltjvm=<path> option
 381   static bool   _sun_java_launcher_is_altjvm;
 382 


 447   static void set_ergonomics_flags();
 448   static void set_shared_spaces_flags();
 449   // limits the given memory size by the maximum amount of memory this process is
 450   // currently allowed to allocate or reserve.
 451   static julong limit_by_allocatable_memory(julong size);
 452   // Setup heap size
 453   static void set_heap_size();
 454   // Based on automatic selection criteria, should the
 455   // low pause collector be used.
 456   static bool should_auto_select_low_pause_collector();
 457 
 458   // Bytecode rewriting
 459   static void set_bytecode_flags();
 460 
 461   // Invocation API hooks
 462   static abort_hook_t     _abort_hook;
 463   static exit_hook_t      _exit_hook;
 464   static vfprintf_hook_t  _vfprintf_hook;
 465 
 466   // System properties
 467   static bool add_property(const char* prop);






 468 
 469   // Miscellaneous system property setter
 470   static bool append_to_addmods_property(const char* module_name);
 471 
 472   // Aggressive optimization flags.
 473   static jint set_aggressive_opts_flags();
 474 
 475   static jint set_aggressive_heap_flags();
 476 
 477   // Argument parsing
 478   static void do_pd_flag_adjustments();
 479   static bool parse_argument(const char* arg, Flag::Flags origin);
 480   static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin);
 481   static void process_java_launcher_argument(const char*, void*);
 482   static void process_java_compiler_argument(const char* arg);
 483   static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args);
 484   static jint parse_java_tool_options_environment_variable(ScopedVMInitArgs* vm_args);
 485   static jint parse_java_options_environment_variable(ScopedVMInitArgs* vm_args);
 486   static jint parse_vm_options_file(const char* file_name, ScopedVMInitArgs* vm_args);
 487   static jint parse_options_buffer(const char* name, char* buffer, const size_t buf_len, ScopedVMInitArgs* vm_args);
 488   static jint insert_vm_options_file(const JavaVMInitArgs* args,
 489                                      const char* vm_options_file,
 490                                      const int vm_options_file_pos,
 491                                      ScopedVMInitArgs* vm_options_file_args,
 492                                      ScopedVMInitArgs* args_out);
 493   static bool args_contains_vm_options_file_arg(const JavaVMInitArgs* args);
 494   static jint expand_vm_options_as_needed(const JavaVMInitArgs* args_in,
 495                                           ScopedVMInitArgs* mod_args,
 496                                           JavaVMInitArgs** args_out);
 497   static jint match_special_option_and_act(const JavaVMInitArgs* args,
 498                                            ScopedVMInitArgs* args_out);
 499 
 500   static bool handle_deprecated_print_gc_flags();
 501 
 502   static jint parse_vm_init_args(const JavaVMInitArgs *java_tool_options_args,
 503                                  const JavaVMInitArgs *java_options_args,
 504                                  const JavaVMInitArgs *cmd_line_args);
 505   static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* xpatch_javabase, Flag::Flags origin);
 506   static jint finalize_vm_init_args();
 507   static bool is_bad_option(const JavaVMOption* option, jboolean ignore, const char* option_type);
 508 
 509   static bool is_bad_option(const JavaVMOption* option, jboolean ignore) {
 510     return is_bad_option(option, ignore, NULL);
 511   }
 512 
 513   static void describe_range_error(ArgsRange errcode);
 514   static ArgsRange check_memory_size(julong size, julong min_size);
 515   static ArgsRange parse_memory_size(const char* s, julong* long_arg,
 516                                      julong min_size);
 517   // Parse a string for a unsigned integer.  Returns true if value
 518   // is an unsigned integer greater than or equal to the minimum
 519   // parameter passed and returns the value in uintx_arg.  Returns
 520   // false otherwise, with uintx_arg undefined.
 521   static bool parse_uintx(const char* value, uintx* uintx_arg,
 522                           uintx min_size);
 523 
 524   // methods to build strings from individual args
 525   static void build_jvm_args(const char* arg);


 704     return
 705       methodExists(
 706         className, methodName,
 707         CompileOnlyClassesNum, CompileOnlyClasses, CompileOnlyAllMethods,
 708         CompileOnlyMethodsNum, CompileOnlyMethods, CompileOnlyAllClasses
 709       );
 710   }
 711 
 712   // Java launcher properties
 713   static void process_sun_java_launcher_properties(JavaVMInitArgs* args);
 714 
 715   // System properties
 716   static void init_system_properties();
 717 
 718   // Update/Initialize System properties after JDK version number is known
 719   static void init_version_specific_system_properties();
 720 
 721   // Property List manipulation
 722   static void PropertyList_add(SystemProperty *element);
 723   static void PropertyList_add(SystemProperty** plist, SystemProperty *element);
 724   static void PropertyList_add(SystemProperty** plist, const char* k, const char* v);
 725   static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v) {
 726     PropertyList_unique_add(plist, k, v, false);
 727   }
 728   static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v, jboolean append);
 729   static const char* PropertyList_get_value(SystemProperty* plist, const char* key);
 730   static int  PropertyList_count(SystemProperty* pl);
 731   static const char* PropertyList_get_key_at(SystemProperty* pl,int index);
 732   static char* PropertyList_get_value_at(SystemProperty* pl,int index);
 733 


 734   // Miscellaneous System property value getter and setters.
 735   static void set_dll_dir(const char *value) { _sun_boot_library_path->set_value(value); }
 736   static void set_java_home(const char *value) { _java_home->set_value(value); }
 737   static void set_library_path(const char *value) { _java_library_path->set_value(value); }
 738   static void set_ext_dirs(char *value)     { _ext_dirs = os::strdup_check_oom(value); }
 739 
 740   // Set up the underlying pieces of the system boot class path
 741   static void add_xpatchprefix(const char *module_name, const char *path, bool* xpatch_javabase);
 742   static void set_sysclasspath(const char *value) {
 743     _system_boot_class_path->set_value(value);
 744     set_jdkbootclasspath_append();
 745   }
 746   static void append_sysclasspath(const char *value) {
 747     _system_boot_class_path->append_value(value);
 748     set_jdkbootclasspath_append();
 749   }
 750   static void set_jdkbootclasspath_append();
 751 
 752   static GrowableArray<ModuleXPatchPath*>* get_xpatchprefix() { return _xpatchprefix; }
 753   static char* get_sysclasspath() { return _system_boot_class_path->value(); }
 754   static char* get_jdk_boot_class_path_append() { return _jdk_boot_class_path_append->value(); }
 755 
 756   static char* get_java_home()    { return _java_home->value(); }
 757   static char* get_dll_dir()      { return _sun_boot_library_path->value(); }
 758   static char* get_ext_dirs()     { return _ext_dirs;  }
 759   static char* get_appclasspath() { return _java_class_path->value(); }
 760   static void  fix_appclasspath();
 761 
 762 
 763   // Operation modi
 764   static Mode mode()                        { return _mode; }
 765   static bool is_interpreter_only() { return mode() == _int; }
 766 
 767 
 768   // Utility: copies src into buf, replacing "%%" with "%" and "%p" with pid.
 769   static bool copy_expand_pid(const char* src, size_t srclen, char* buf, size_t buflen);
 770 
 771   static void check_unsupported_dumping_properties() NOT_CDS_RETURN;
 772 


  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)
  38 extern "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 // PathString is used as:
  45 //  - the underlying value for a SystemProperty
  46 //  - the path portion of an --patch-module module/path pair
  47 //  - the string that represents the system boot class path, Arguments::_system_boot_class_path.
  48 class PathString : public CHeapObj<mtArguments> {
  49  protected:
  50   char* _value;
  51  public:
  52   char* value() const { return _value; }
  53 
  54   bool set_value(const char *value) {
  55     if (_value != NULL) {
  56       FreeHeap(_value);
  57     }
  58     _value = AllocateHeap(strlen(value)+1, mtArguments);
  59     assert(_value != NULL, "Unable to allocate space for new path value");
  60     if (_value != NULL) {
  61       strcpy(_value, value);
  62     } else {
  63       // not able to allocate
  64       return false;
  65     }
  66     return true;


  90     }
  91   }
  92 
  93   PathString(const char* value) {
  94     if (value == NULL) {
  95       _value = NULL;
  96     } else {
  97       _value = AllocateHeap(strlen(value)+1, mtArguments);
  98       strcpy(_value, value);
  99     }
 100   }
 101 
 102   ~PathString() {
 103     if (_value != NULL) {
 104       FreeHeap(_value);
 105       _value = NULL;
 106     }
 107   }
 108 };
 109 
 110 // ModulePatchPath records the module/path pair as specified to --patch-module.
 111 class ModulePatchPath : public CHeapObj<mtInternal> {
 112 private:
 113   char* _module_name;
 114   PathString* _path;
 115 public:
 116   ModulePatchPath(const char* module_name, const char* path) {
 117     assert(module_name != NULL && path != NULL, "Invalid module name or path value");
 118     size_t len = strlen(module_name) + 1;
 119     _module_name = AllocateHeap(len, mtInternal);
 120     strncpy(_module_name, module_name, len); // copy the trailing null
 121     _path =  new PathString(path);
 122   }
 123 
 124   ~ModulePatchPath() {
 125     if (_module_name != NULL) {
 126       FreeHeap(_module_name);
 127       _module_name = NULL;
 128     }
 129     if (_path != NULL) {
 130       delete _path;
 131       _path = NULL;
 132     }
 133   }
 134 
 135   inline void set_path(const char* path) { _path->set_value(path); }
 136   inline const char* module_name() const { return _module_name; }
 137   inline char* path_string() const { return _path->value(); }
 138 };
 139 
 140 // Element describing System and User (-Dkey=value flags) defined property.
 141 //
 142 // An internal SystemProperty is one that has been removed in
 143 // jdk.internal.VM.saveAndRemoveProperties, like jdk.boot.class.path.append.
 144 //


 308 
 309 class Arguments : AllStatic {
 310   friend class VMStructs;
 311   friend class JvmtiExport;
 312   friend class CodeCacheExtensions;
 313  public:
 314   // Operation modi
 315   enum Mode {
 316     _int,       // corresponds to -Xint
 317     _mixed,     // corresponds to -Xmixed
 318     _comp       // corresponds to -Xcomp
 319   };
 320 
 321   enum ArgsRange {
 322     arg_unreadable = -3,
 323     arg_too_small  = -2,
 324     arg_too_big    = -1,
 325     arg_in_range   = 0
 326   };
 327 
 328   enum PropertyAppendable {
 329     AppendProperty,
 330     AddProperty
 331   };
 332 
 333   enum PropertyWriteable {
 334     WriteableProperty,
 335     UnwriteableProperty
 336   };
 337 
 338   enum PropertyInternal {
 339     InternalProperty,
 340     ExternalProperty
 341   };
 342 
 343  private:
 344 
 345   // a pointer to the flags file name if it is specified
 346   static char*  _jvm_flags_file;
 347   // an array containing all flags specified in the .hotspotrc file
 348   static char** _jvm_flags_array;
 349   static int    _num_jvm_flags;
 350   // an array containing all jvm arguments specified in the command line
 351   static char** _jvm_args_array;
 352   static int    _num_jvm_args;
 353   // string containing all java command (class/jarfile name and app args)
 354   static char* _java_command;
 355 
 356   // Property list
 357   static SystemProperty* _system_properties;
 358 
 359   // Quick accessor to System properties in the list:
 360   static SystemProperty *_sun_boot_library_path;
 361   static SystemProperty *_java_library_path;
 362   static SystemProperty *_java_home;
 363   static SystemProperty *_java_class_path;
 364   static SystemProperty *_jdk_boot_class_path_append;
 365 
 366   // --patch-module=module=<file>(<pathsep><file>)*
 367   // Each element contains the associated module name, path
 368   // string pair as specified to --patch-module.
 369   static GrowableArray<ModulePatchPath*>* _patch_mod_prefix;
 370 
 371   // The constructed value of the system class path after
 372   // argument processing and JVMTI OnLoad additions via
 373   // calls to AddToBootstrapClassLoaderSearch.  This is the
 374   // final form before ClassLoader::setup_bootstrap_search().
 375   // Note: since --patch-module is a module name/path pair, the
 376   // system boot class path string no longer contains the "prefix"
 377   // to the boot class path base piece as it did when
 378   // -Xbootclasspath/p was supported.
 379   static PathString *_system_boot_class_path;
 380 
 381   // temporary: to emit warning if the default ext dirs are not empty.
 382   // remove this variable when the warning is no longer needed.
 383   static char* _ext_dirs;
 384 
 385   // java.vendor.url.bug, bug reporting URL for fatal errors.
 386   static const char* _java_vendor_url_bug;
 387 
 388   // sun.java.launcher, private property to provide information about
 389   // java launcher
 390   static const char* _sun_java_launcher;
 391 
 392   // sun.java.launcher.pid, private property
 393   static int    _sun_java_launcher_pid;
 394 
 395   // was this VM created via the -XXaltjvm=<path> option
 396   static bool   _sun_java_launcher_is_altjvm;
 397 


 462   static void set_ergonomics_flags();
 463   static void set_shared_spaces_flags();
 464   // limits the given memory size by the maximum amount of memory this process is
 465   // currently allowed to allocate or reserve.
 466   static julong limit_by_allocatable_memory(julong size);
 467   // Setup heap size
 468   static void set_heap_size();
 469   // Based on automatic selection criteria, should the
 470   // low pause collector be used.
 471   static bool should_auto_select_low_pause_collector();
 472 
 473   // Bytecode rewriting
 474   static void set_bytecode_flags();
 475 
 476   // Invocation API hooks
 477   static abort_hook_t     _abort_hook;
 478   static exit_hook_t      _exit_hook;
 479   static vfprintf_hook_t  _vfprintf_hook;
 480 
 481   // System properties
 482   static bool add_property(const char* prop, PropertyWriteable writeable=WriteableProperty,
 483                            PropertyInternal internal=ExternalProperty);
 484 
 485   static bool create_property(const char* prop_name, const char* prop_value, PropertyInternal internal);
 486   static bool create_numbered_property(const char* prop_base_name, const char* prop_value, unsigned int count);
 487 
 488   static int process_patch_mod_option(const char* patch_mod_tail, bool* patch_mod_javabase);
 489 
 490   // Miscellaneous system property setter
 491   static bool append_to_addmods_property(const char* module_name);
 492 
 493   // Aggressive optimization flags.
 494   static jint set_aggressive_opts_flags();
 495 
 496   static jint set_aggressive_heap_flags();
 497 
 498   // Argument parsing
 499   static void do_pd_flag_adjustments();
 500   static bool parse_argument(const char* arg, Flag::Flags origin);
 501   static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin);
 502   static void process_java_launcher_argument(const char*, void*);
 503   static void process_java_compiler_argument(const char* arg);
 504   static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args);
 505   static jint parse_java_tool_options_environment_variable(ScopedVMInitArgs* vm_args);
 506   static jint parse_java_options_environment_variable(ScopedVMInitArgs* vm_args);
 507   static jint parse_vm_options_file(const char* file_name, ScopedVMInitArgs* vm_args);
 508   static jint parse_options_buffer(const char* name, char* buffer, const size_t buf_len, ScopedVMInitArgs* vm_args);
 509   static jint insert_vm_options_file(const JavaVMInitArgs* args,
 510                                      const char* vm_options_file,
 511                                      const int vm_options_file_pos,
 512                                      ScopedVMInitArgs* vm_options_file_args,
 513                                      ScopedVMInitArgs* args_out);
 514   static bool args_contains_vm_options_file_arg(const JavaVMInitArgs* args);
 515   static jint expand_vm_options_as_needed(const JavaVMInitArgs* args_in,
 516                                           ScopedVMInitArgs* mod_args,
 517                                           JavaVMInitArgs** args_out);
 518   static jint match_special_option_and_act(const JavaVMInitArgs* args,
 519                                            ScopedVMInitArgs* args_out);
 520 
 521   static bool handle_deprecated_print_gc_flags();
 522 
 523   static jint parse_vm_init_args(const JavaVMInitArgs *java_tool_options_args,
 524                                  const JavaVMInitArgs *java_options_args,
 525                                  const JavaVMInitArgs *cmd_line_args);
 526   static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, Flag::Flags origin);
 527   static jint finalize_vm_init_args();
 528   static bool is_bad_option(const JavaVMOption* option, jboolean ignore, const char* option_type);
 529 
 530   static bool is_bad_option(const JavaVMOption* option, jboolean ignore) {
 531     return is_bad_option(option, ignore, NULL);
 532   }
 533 
 534   static void describe_range_error(ArgsRange errcode);
 535   static ArgsRange check_memory_size(julong size, julong min_size);
 536   static ArgsRange parse_memory_size(const char* s, julong* long_arg,
 537                                      julong min_size);
 538   // Parse a string for a unsigned integer.  Returns true if value
 539   // is an unsigned integer greater than or equal to the minimum
 540   // parameter passed and returns the value in uintx_arg.  Returns
 541   // false otherwise, with uintx_arg undefined.
 542   static bool parse_uintx(const char* value, uintx* uintx_arg,
 543                           uintx min_size);
 544 
 545   // methods to build strings from individual args
 546   static void build_jvm_args(const char* arg);


 725     return
 726       methodExists(
 727         className, methodName,
 728         CompileOnlyClassesNum, CompileOnlyClasses, CompileOnlyAllMethods,
 729         CompileOnlyMethodsNum, CompileOnlyMethods, CompileOnlyAllClasses
 730       );
 731   }
 732 
 733   // Java launcher properties
 734   static void process_sun_java_launcher_properties(JavaVMInitArgs* args);
 735 
 736   // System properties
 737   static void init_system_properties();
 738 
 739   // Update/Initialize System properties after JDK version number is known
 740   static void init_version_specific_system_properties();
 741 
 742   // Property List manipulation
 743   static void PropertyList_add(SystemProperty *element);
 744   static void PropertyList_add(SystemProperty** plist, SystemProperty *element);
 745   static void PropertyList_add(SystemProperty** plist, const char* k, const char* v, bool writeable, bool internal);
 746 
 747   static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v,
 748                                       PropertyAppendable append, PropertyWriteable writeable,
 749                                       PropertyInternal internal);
 750   static const char* PropertyList_get_value(SystemProperty* plist, const char* key);
 751   static int  PropertyList_count(SystemProperty* pl);
 752   static const char* PropertyList_get_key_at(SystemProperty* pl,int index);
 753   static char* PropertyList_get_value_at(SystemProperty* pl,int index);
 754 
 755   static bool is_internal_module_property(const char* option);
 756 
 757   // Miscellaneous System property value getter and setters.
 758   static void set_dll_dir(const char *value) { _sun_boot_library_path->set_value(value); }
 759   static void set_java_home(const char *value) { _java_home->set_value(value); }
 760   static void set_library_path(const char *value) { _java_library_path->set_value(value); }
 761   static void set_ext_dirs(char *value)     { _ext_dirs = os::strdup_check_oom(value); }
 762 
 763   // Set up the underlying pieces of the system boot class path
 764   static void add_patch_mod_prefix(const char *module_name, const char *path, bool* patch_mod_javabase);
 765   static void set_sysclasspath(const char *value) {
 766     _system_boot_class_path->set_value(value);
 767     set_jdkbootclasspath_append();
 768   }
 769   static void append_sysclasspath(const char *value) {
 770     _system_boot_class_path->append_value(value);
 771     set_jdkbootclasspath_append();
 772   }
 773   static void set_jdkbootclasspath_append();
 774 
 775   static GrowableArray<ModulePatchPath*>* get_patch_mod_prefix() { return _patch_mod_prefix; }
 776   static char* get_sysclasspath() { return _system_boot_class_path->value(); }
 777   static char* get_jdk_boot_class_path_append() { return _jdk_boot_class_path_append->value(); }
 778 
 779   static char* get_java_home()    { return _java_home->value(); }
 780   static char* get_dll_dir()      { return _sun_boot_library_path->value(); }
 781   static char* get_ext_dirs()     { return _ext_dirs;  }
 782   static char* get_appclasspath() { return _java_class_path->value(); }
 783   static void  fix_appclasspath();
 784 
 785 
 786   // Operation modi
 787   static Mode mode()                        { return _mode; }
 788   static bool is_interpreter_only() { return mode() == _int; }
 789 
 790 
 791   // Utility: copies src into buf, replacing "%%" with "%" and "%p" with pid.
 792   static bool copy_expand_pid(const char* src, size_t srclen, char* buf, size_t buflen);
 793 
 794   static void check_unsupported_dumping_properties() NOT_CDS_RETURN;
 795 
< prev index next >