src/hotspot/share/runtime/arguments.hpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 47106 hotspot/src/share/vm/runtime/arguments.hpp@bed18a111b90
child 47901 4c42aa431f40
child 55767 8e22715afabc
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
43605
07baf498d588 8173421: Obsolete and expired flags for JDK 10 need to be removed and related tests updated
dholmes
parents: 41708
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5035
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5035
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5035
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
    25
#ifndef SHARE_VM_RUNTIME_ARGUMENTS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
    26
#define SHARE_VM_RUNTIME_ARGUMENTS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
    27
35489
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
    28
#include "logging/logLevel.hpp"
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
    29
#include "logging/logTag.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
    30
#include "runtime/java.hpp"
25468
5331df506290 8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents: 25074
diff changeset
    31
#include "runtime/os.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
    32
#include "runtime/perfData.hpp"
22555
ea32f6c51d08 8028391: Make the Min/MaxHeapFreeRatio flags manageable
jwilhelm
parents: 22551
diff changeset
    33
#include "utilities/debug.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
    34
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// Arguments parses the command line and recognizes options
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// Invocation API hook typedefs (these should really be defined in jni.hpp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  typedef void (JNICALL *abort_hook_t)(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  typedef void (JNICALL *exit_hook_t)(jint code);
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22735
diff changeset
    41
  typedef jint (JNICALL *vfprintf_hook_t)(FILE *fp, const char *format, va_list args)  ATTRIBUTE_PRINTF(2, 0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
41708
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    44
// Obsolete or deprecated -XX flag.
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    45
struct SpecialFlag {
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    46
  const char* name;
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    47
  JDK_Version deprecated_in; // When the deprecation warning started (or "undefined").
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    48
  JDK_Version obsolete_in;   // When the obsolete warning started (or "undefined").
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    49
  JDK_Version expired_in;    // When the option expires (or "undefined").
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    50
};
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
    51
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
    52
// PathString is used as:
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
    53
//  - the underlying value for a SystemProperty
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
    54
//  - the path portion of an --patch-module module/path pair
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
    55
//  - the string that represents the system boot class path, Arguments::_system_boot_class_path.
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
    56
class PathString : public CHeapObj<mtArguments> {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    57
 protected:
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
    58
  char* _value;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
 public:
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
    60
  char* value() const { return _value; }
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    61
32595
8cde9aca5e9f 8132725: Memory leak in Arguments::add_property function
ddmitriev
parents: 32366
diff changeset
    62
  bool set_value(const char *value) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    63
    if (_value != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    64
      FreeHeap(_value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
    }
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
    66
    _value = AllocateHeap(strlen(value)+1, mtArguments);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    67
    assert(_value != NULL, "Unable to allocate space for new path value");
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    68
    if (_value != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    69
      strcpy(_value, value);
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    70
    } else {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    71
      // not able to allocate
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    72
      return false;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    73
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    74
    return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  void append_value(const char *value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    char *sp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    size_t len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    if (value != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
      len = strlen(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
      if (_value != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
        len += strlen(_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
      }
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
    85
      sp = AllocateHeap(len+2, mtArguments);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
    86
      assert(sp != NULL, "Unable to allocate space for new append path value");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
      if (sp != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
        if (_value != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
          strcpy(sp, _value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
          strcat(sp, os::path_separator());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
          strcat(sp, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
          FreeHeap(_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
          strcpy(sp, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
        _value = sp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   101
  PathString(const char* value) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   102
    if (value == NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   103
      _value = NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   104
    } else {
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
   105
      _value = AllocateHeap(strlen(value)+1, mtArguments);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   106
      strcpy(_value, value);
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   107
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   108
  }
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   109
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   110
  ~PathString() {
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   111
    if (_value != NULL) {
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   112
      FreeHeap(_value);
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   113
      _value = NULL;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   114
    }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   115
  }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   116
};
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   117
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   118
// ModulePatchPath records the module/path pair as specified to --patch-module.
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   119
class ModulePatchPath : public CHeapObj<mtInternal> {
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   120
private:
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   121
  char* _module_name;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   122
  PathString* _path;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   123
public:
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   124
  ModulePatchPath(const char* module_name, const char* path) {
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   125
    assert(module_name != NULL && path != NULL, "Invalid module name or path value");
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   126
    size_t len = strlen(module_name) + 1;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   127
    _module_name = AllocateHeap(len, mtInternal);
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   128
    strncpy(_module_name, module_name, len); // copy the trailing null
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   129
    _path =  new PathString(path);
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   130
  }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   131
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   132
  ~ModulePatchPath() {
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   133
    if (_module_name != NULL) {
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   134
      FreeHeap(_module_name);
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   135
      _module_name = NULL;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   136
    }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   137
    if (_path != NULL) {
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   138
      delete _path;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   139
      _path = NULL;
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   140
    }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   141
  }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   142
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   143
  inline void set_path(const char* path) { _path->set_value(path); }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   144
  inline const char* module_name() const { return _module_name; }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   145
  inline char* path_string() const { return _path->value(); }
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   146
};
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   147
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   148
// Element describing System and User (-Dkey=value flags) defined property.
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   149
//
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   150
// An internal SystemProperty is one that has been removed in
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   151
// jdk.internal.VM.saveAndRemoveProperties, like jdk.boot.class.path.append.
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   152
//
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   153
class SystemProperty : public PathString {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   154
 private:
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   155
  char*           _key;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   156
  SystemProperty* _next;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   157
  bool            _internal;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   158
  bool            _writeable;
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   159
  bool writeable() { return _writeable; }
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   160
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   161
 public:
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   162
  // Accessors
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   163
  char* value() const                 { return PathString::value(); }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   164
  const char* key() const             { return _key; }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   165
  bool internal() const               { return _internal; }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   166
  SystemProperty* next() const        { return _next; }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   167
  void set_next(SystemProperty* next) { _next = next; }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   168
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   169
  bool is_readable() const {
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   170
    return !_internal || strcmp(_key, "jdk.boot.class.path.append") == 0;
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   171
  }
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   172
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   173
  // A system property should only have its value set
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   174
  // via an external interface if it is a writeable property.
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   175
  // The internal, non-writeable property jdk.boot.class.path.append
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   176
  // is the only exception to this rule.  It can be set externally
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   177
  // via -Xbootclasspath/a or JVMTI OnLoad phase call to AddToBootstrapClassLoaderSearch.
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   178
  // In those cases for jdk.boot.class.path.append, the base class
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   179
  // set_value and append_value methods are called directly.
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   180
  bool set_writeable_value(const char *value) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   181
    if (writeable()) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   182
      return set_value(value);
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   183
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   184
    return false;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   185
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   186
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   187
  // Constructor
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   188
  SystemProperty(const char* key, const char* value, bool writeable, bool internal = false) : PathString(value) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    if (key == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
      _key = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    } else {
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
   192
      _key = AllocateHeap(strlen(key)+1, mtArguments);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
      strcpy(_key, key);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    _next = NULL;
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   196
    _internal = internal;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    _writeable = writeable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
// For use by -agentlib, -agentpath and -Xrun
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
   203
class AgentLibrary : public CHeapObj<mtArguments> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  friend class AgentLibraryList;
19553
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   205
public:
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   206
  // Is this library valid or not. Don't rely on os_lib == NULL as statically
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   207
  // linked lib could have handle of RTLD_DEFAULT which == 0 on some platforms
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   208
  enum AgentState {
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   209
    agent_invalid = 0,
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   210
    agent_valid   = 1
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   211
  };
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   212
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  char*           _name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  char*           _options;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  void*           _os_lib;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  bool            _is_absolute_path;
19553
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   218
  bool            _is_static_lib;
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   219
  AgentState      _state;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  AgentLibrary*   _next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // Accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  const char* name() const                  { return _name; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  char* options() const                     { return _options; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  bool is_absolute_path() const             { return _is_absolute_path; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  void* os_lib() const                      { return _os_lib; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  void set_os_lib(void* os_lib)             { _os_lib = os_lib; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  AgentLibrary* next() const                { return _next; }
19553
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   230
  bool is_static_lib() const                { return _is_static_lib; }
19973
d98623e1f50b 8024007: Misc. cleanup of static agent code
bpittore
parents: 19732
diff changeset
   231
  void set_static_lib(bool is_static_lib)   { _is_static_lib = is_static_lib; }
19553
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   232
  bool valid()                              { return (_state == agent_valid); }
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   233
  void set_valid()                          { _state = agent_valid; }
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   234
  void set_invalid()                        { _state = agent_invalid; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  AgentLibrary(const char* name, const char* options, bool is_absolute_path, void* os_lib) {
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
   238
    _name = AllocateHeap(strlen(name)+1, mtArguments);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    strcpy(_name, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    if (options == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      _options = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    } else {
37491
edf4cc53f5a3 8153039: Command line processing should use mtCommand or mtArguments rather than mtInternal for NMT
gziemski
parents: 37466
diff changeset
   243
      _options = AllocateHeap(strlen(options)+1, mtArguments);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
      strcpy(_options, options);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    _is_absolute_path = is_absolute_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    _os_lib = os_lib;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    _next = NULL;
19553
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   249
    _state = agent_invalid;
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   250
    _is_static_lib = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
// maintain an order of entry list of AgentLibrary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
class AgentLibraryList VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  AgentLibrary*   _first;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  AgentLibrary*   _last;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  bool is_empty() const                     { return _first == NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  AgentLibrary* first() const               { return _first; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // add to the end of the list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  void add(AgentLibrary* lib) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    if (is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
      _first = _last = lib;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
      _last->_next = lib;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
      _last = lib;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    lib->_next = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  // search for and remove a library known to be in the list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  void remove(AgentLibrary* lib) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    AgentLibrary* curr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    AgentLibrary* prev = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    for (curr = first(); curr != NULL; prev = curr, curr = curr->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
      if (curr == lib) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    assert(curr != NULL, "always should be found");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    if (curr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
      // it was found, by-pass this library
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      if (prev == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
        _first = curr->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
        prev->_next = curr->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
      if (curr == _last) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
        _last = prev;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
      curr->_next = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  AgentLibraryList() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    _first = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    _last = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
31853
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   305
// Helper class for controlling the lifetime of JavaVMInitArgs objects.
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   306
class ScopedVMInitArgs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
35489
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   308
// Most logging functions require 5 tags. Some of them may be _NO_TAG.
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   309
typedef struct {
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   310
  const char* alias_name;
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   311
  LogLevelType level;
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   312
  bool exactMatch;
37094
c12f414936a1 8149995: TraceClassLoadingPreorder has been converted to Unified Logging.
mockner
parents: 36313
diff changeset
   313
  LogTagType tag0;
c12f414936a1 8149995: TraceClassLoadingPreorder has been converted to Unified Logging.
mockner
parents: 36313
diff changeset
   314
  LogTagType tag1;
c12f414936a1 8149995: TraceClassLoadingPreorder has been converted to Unified Logging.
mockner
parents: 36313
diff changeset
   315
  LogTagType tag2;
c12f414936a1 8149995: TraceClassLoadingPreorder has been converted to Unified Logging.
mockner
parents: 36313
diff changeset
   316
  LogTagType tag3;
c12f414936a1 8149995: TraceClassLoadingPreorder has been converted to Unified Logging.
mockner
parents: 36313
diff changeset
   317
  LogTagType tag4;
c12f414936a1 8149995: TraceClassLoadingPreorder has been converted to Unified Logging.
mockner
parents: 36313
diff changeset
   318
  LogTagType tag5;
35489
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   319
} AliasedLoggingFlag;
368deab8e88b 8146800: Reorganize logging alias code.
mockner
parents: 35466
diff changeset
   320
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
class Arguments : AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  friend class JvmtiExport;
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31608
diff changeset
   324
  friend class CodeCacheExtensions;
46616
66d452cca30f 8178491: -Xss and -XX:ThreadStackSize argument parsing truncates bits
stefank
parents: 43607
diff changeset
   325
  friend class ArgumentsTest;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // Operation modi
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  enum Mode {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    _int,       // corresponds to -Xint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
    _mixed,     // corresponds to -Xmixed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    _comp       // corresponds to -Xcomp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  enum ArgsRange {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    arg_unreadable = -3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    arg_too_small  = -2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    arg_too_big    = -1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
    arg_in_range   = 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   341
  enum PropertyAppendable {
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   342
    AppendProperty,
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   343
    AddProperty
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   344
  };
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   345
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   346
  enum PropertyWriteable {
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   347
    WriteableProperty,
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   348
    UnwriteableProperty
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   349
  };
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   350
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   351
  enum PropertyInternal {
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   352
    InternalProperty,
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   353
    ExternalProperty
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   354
  };
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   355
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
34125
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   358
  // a pointer to the flags file name if it is specified
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   359
  static char*  _jvm_flags_file;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  // an array containing all flags specified in the .hotspotrc file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  static char** _jvm_flags_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  static int    _num_jvm_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  // an array containing all jvm arguments specified in the command line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  static char** _jvm_args_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  static int    _num_jvm_args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  // string containing all java command (class/jarfile name and app args)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  static char* _java_command;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  // Property list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  static SystemProperty* _system_properties;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  // Quick accessor to System properties in the list:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  static SystemProperty *_sun_boot_library_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  static SystemProperty *_java_library_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  static SystemProperty *_java_home;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  static SystemProperty *_java_class_path;
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   377
  static SystemProperty *_jdk_boot_class_path_append;
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   378
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   379
  // --patch-module=module=<file>(<pathsep><file>)*
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   380
  // Each element contains the associated module name, path
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   381
  // string pair as specified to --patch-module.
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   382
  static GrowableArray<ModulePatchPath*>* _patch_mod_prefix;
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   383
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   384
  // The constructed value of the system class path after
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   385
  // argument processing and JVMTI OnLoad additions via
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   386
  // calls to AddToBootstrapClassLoaderSearch.  This is the
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   387
  // final form before ClassLoader::setup_bootstrap_search().
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   388
  // Note: since --patch-module is a module name/path pair, the
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   389
  // system boot class path string no longer contains the "prefix"
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   390
  // to the boot class path base piece as it did when
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   391
  // -Xbootclasspath/p was supported.
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   392
  static PathString *_system_boot_class_path;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
40013
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   394
  // Set if a modular java runtime image is present vs. a build with exploded modules
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   395
  static bool _has_jimage;
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   396
27562
47f369e3c69c 8049367: Modular Run-Time Images
chegar
parents: 27148
diff changeset
   397
  // temporary: to emit warning if the default ext dirs are not empty.
47f369e3c69c 8049367: Modular Run-Time Images
chegar
parents: 27148
diff changeset
   398
  // remove this variable when the warning is no longer needed.
47f369e3c69c 8049367: Modular Run-Time Images
chegar
parents: 27148
diff changeset
   399
  static char* _ext_dirs;
47f369e3c69c 8049367: Modular Run-Time Images
chegar
parents: 27148
diff changeset
   400
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  // java.vendor.url.bug, bug reporting URL for fatal errors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  static const char* _java_vendor_url_bug;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // sun.java.launcher, private property to provide information about
22734
41757c1f3946 8027113: decouple the '-XXaltjvm=<path>' option from the gamma launcher
rdurbin
parents: 20288
diff changeset
   405
  // java launcher
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  static const char* _sun_java_launcher;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  // sun.java.launcher.pid, private property
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  static int    _sun_java_launcher_pid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
22734
41757c1f3946 8027113: decouple the '-XXaltjvm=<path>' option from the gamma launcher
rdurbin
parents: 20288
diff changeset
   411
  // was this VM created via the -XXaltjvm=<path> option
41757c1f3946 8027113: decouple the '-XXaltjvm=<path>' option from the gamma launcher
rdurbin
parents: 20288
diff changeset
   412
  static bool   _sun_java_launcher_is_altjvm;
8476
7e34c2d4cf9b 7022037: Pause when exiting if debugger is attached on windows
sla
parents: 7397
diff changeset
   413
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  // Option flags
35872
7fb1e4de83ff 8145180: Add back PrintGC, PrintGCDetails and -Xloggc
brutisso
parents: 35489
diff changeset
   415
  static const char*  _gc_log_filename;
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   416
  // Value of the conservative maximum heap alignment needed
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   417
  static size_t  _conservative_max_heap_alignment;
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   418
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   419
  static uintx  _min_heap_size;
26824
a04a1291103f 8055006: Store original value of Min/MaxHeapFreeRatio
jwilhelm
parents: 26585
diff changeset
   420
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  // -Xrun arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  static AgentLibraryList _libraryList;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  static void add_init_library(const char* name, char* options)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    { _libraryList.add(new AgentLibrary(name, options, false, NULL)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  // -agentlib and -agentpath arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  static AgentLibraryList _agentList;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  static void add_init_agent(const char* name, char* options, bool absolute_path)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    { _agentList.add(new AgentLibrary(name, options, absolute_path, NULL)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  // Late-binding agents not started via arguments
19553
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   432
  static void add_loaded_agent(AgentLibrary *agentLib)
9bbd930be684 8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents: 19319
diff changeset
   433
    { _agentList.add(agentLib); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  static void add_loaded_agent(const char* name, char* options, bool absolute_path, void* os_lib)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    { _agentList.add(new AgentLibrary(name, options, absolute_path, os_lib)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // Operation modi
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  static Mode _mode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  static void set_mode_flags(Mode mode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  static bool _java_compiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  static void set_java_compiler(bool arg) { _java_compiler = arg; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  static bool java_compiler()   { return _java_compiler; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  // -Xdebug flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  static bool _xdebug_mode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  static void set_xdebug_mode(bool arg) { _xdebug_mode = arg; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  static bool xdebug_mode()             { return _xdebug_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // Used to save default settings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  static bool _AlwaysCompileLoopMethods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  static bool _UseOnStackReplacement;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  static bool _BackgroundCompilation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  static bool _ClipInlining;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  static bool _CIDynamicCompilePriority;
30201
cfe623bb3f9c 8075663: compiler/rangechecks/TestExplicitRangeChecks.java fails in compiler nightlies
roland
parents: 29697
diff changeset
   455
  static intx _Tier3InvokeNotifyFreqLog;
cfe623bb3f9c 8075663: compiler/rangechecks/TestExplicitRangeChecks.java fails in compiler nightlies
roland
parents: 29697
diff changeset
   456
  static intx _Tier4InvocationThreshold;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
43455
96560cffef4d 8166002: Emulate client build on platforms with reduced virtual address space
jcm
parents: 43433
diff changeset
   458
  // Compilation mode.
96560cffef4d 8166002: Emulate client build on platforms with reduced virtual address space
jcm
parents: 43433
diff changeset
   459
  static bool compilation_mode_selected();
96560cffef4d 8166002: Emulate client build on platforms with reduced virtual address space
jcm
parents: 43433
diff changeset
   460
  static void select_compilation_mode_ergonomically();
96560cffef4d 8166002: Emulate client build on platforms with reduced virtual address space
jcm
parents: 43433
diff changeset
   461
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6414
diff changeset
   462
  // Tiered
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6414
diff changeset
   463
  static void set_tiered_flags();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  // CMS/ParNew garbage collectors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  static void set_parnew_gc_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  static void set_cms_and_parnew_gc_flags();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 183
diff changeset
   467
  // UseParallel[Old]GC
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  static void set_parallel_gc_flags();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 183
diff changeset
   469
  // Garbage-First (UseG1GC)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 183
diff changeset
   470
  static void set_g1_gc_flags();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  // GC ergonomics
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   472
  static void set_conservative_max_heap_alignment();
15957
58302a2ffb9a 8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents: 15950
diff changeset
   473
  static void set_use_compressed_oops();
19319
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18687
diff changeset
   474
  static void set_use_compressed_klass_ptrs();
26836
b27ec66071c7 8057531: refactor gc argument processing code slightly
jcoomes
parents: 26824
diff changeset
   475
  static void select_gc();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  static void set_ergonomics_flags();
8681
c691d94813f9 7018056: large pages not always enabled by default
jcoomes
parents: 8476
diff changeset
   477
  static void set_shared_spaces_flags();
16605
ba13efd453bc 7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents: 15957
diff changeset
   478
  // limits the given memory size by the maximum amount of memory this process is
ba13efd453bc 7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents: 15957
diff changeset
   479
  // currently allowed to allocate or reserve.
ba13efd453bc 7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents: 15957
diff changeset
   480
  static julong limit_by_allocatable_memory(julong size);
4434
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 2358
diff changeset
   481
  // Setup heap size
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 2358
diff changeset
   482
  static void set_heap_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  // Bytecode rewriting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  static void set_bytecode_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  // Invocation API hooks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  static abort_hook_t     _abort_hook;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  static exit_hook_t      _exit_hook;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  static vfprintf_hook_t  _vfprintf_hook;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // System properties
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   493
  static bool add_property(const char* prop, PropertyWriteable writeable=WriteableProperty,
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   494
                           PropertyInternal internal=ExternalProperty);
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   495
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   496
  static bool create_property(const char* prop_name, const char* prop_value, PropertyInternal internal);
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   497
  static bool create_numbered_property(const char* prop_base_name, const char* prop_value, unsigned int count);
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   498
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   499
  static int process_patch_mod_option(const char* patch_mod_tail, bool* patch_mod_javabase);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // Aggressive optimization flags.
32595
8cde9aca5e9f 8132725: Memory leak in Arguments::add_property function
ddmitriev
parents: 32366
diff changeset
   502
  static jint set_aggressive_opts_flags();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
32823
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   504
  static jint set_aggressive_heap_flags();
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   505
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  // Argument parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  static void do_pd_flag_adjustments();
20288
e2d549f40de9 8024545: make develop and notproduct flag values available in product builds
twisti
parents: 20006
diff changeset
   508
  static bool parse_argument(const char* arg, Flag::Flags origin);
e2d549f40de9 8024545: make develop and notproduct flag values available in product builds
twisti
parents: 20006
diff changeset
   509
  static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  static void process_java_launcher_argument(const char*, void*);
32595
8cde9aca5e9f 8132725: Memory leak in Arguments::add_property function
ddmitriev
parents: 32366
diff changeset
   511
  static void process_java_compiler_argument(const char* arg);
31853
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   512
  static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args);
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   513
  static jint parse_java_tool_options_environment_variable(ScopedVMInitArgs* vm_args);
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   514
  static jint parse_java_options_environment_variable(ScopedVMInitArgs* vm_args);
32621
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   515
  static jint parse_vm_options_file(const char* file_name, ScopedVMInitArgs* vm_args);
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   516
  static jint parse_options_buffer(const char* name, char* buffer, const size_t buf_len, ScopedVMInitArgs* vm_args);
46616
66d452cca30f 8178491: -Xss and -XX:ThreadStackSize argument parsing truncates bits
stefank
parents: 43607
diff changeset
   517
  static jint parse_xss(const JavaVMOption* option, const char* tail, intx* out_ThreadStackSize);
32621
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   518
  static jint insert_vm_options_file(const JavaVMInitArgs* args,
35466
4ace9ef0201b 8135198: Add -XX:VMOptionsFile support to JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
rdurbin
parents: 35171
diff changeset
   519
                                     const char* vm_options_file,
32621
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   520
                                     const int vm_options_file_pos,
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   521
                                     ScopedVMInitArgs* vm_options_file_args,
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   522
                                     ScopedVMInitArgs* args_out);
35466
4ace9ef0201b 8135198: Add -XX:VMOptionsFile support to JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
rdurbin
parents: 35171
diff changeset
   523
  static bool args_contains_vm_options_file_arg(const JavaVMInitArgs* args);
4ace9ef0201b 8135198: Add -XX:VMOptionsFile support to JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
rdurbin
parents: 35171
diff changeset
   524
  static jint expand_vm_options_as_needed(const JavaVMInitArgs* args_in,
4ace9ef0201b 8135198: Add -XX:VMOptionsFile support to JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
rdurbin
parents: 35171
diff changeset
   525
                                          ScopedVMInitArgs* mod_args,
4ace9ef0201b 8135198: Add -XX:VMOptionsFile support to JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
rdurbin
parents: 35171
diff changeset
   526
                                          JavaVMInitArgs** args_out);
32621
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   527
  static jint match_special_option_and_act(const JavaVMInitArgs* args,
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   528
                                           ScopedVMInitArgs* args_out);
cdab920f3b6c 8061999: Enhance VM option parsing to allow options to be specified in a file
rdurbin
parents: 32619
diff changeset
   529
35872
7fb1e4de83ff 8145180: Add back PrintGC, PrintGCDetails and -Xloggc
brutisso
parents: 35489
diff changeset
   530
  static bool handle_deprecated_print_gc_flags();
7fb1e4de83ff 8145180: Add back PrintGC, PrintGCDetails and -Xloggc
brutisso
parents: 35489
diff changeset
   531
41708
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
   532
  static void handle_extra_cms_flags(const char* msg);
82f5dc0dfccf 8155948: Add message for CMS deprecation for Oracle builds
jmasa
parents: 41073
diff changeset
   533
31853
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   534
  static jint parse_vm_init_args(const JavaVMInitArgs *java_tool_options_args,
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   535
                                 const JavaVMInitArgs *java_options_args,
c70929a2573c 8079301: Some command line options not settable via JAVA_TOOL_OPTIONS
jmanson
parents: 31620
diff changeset
   536
                                 const JavaVMInitArgs *cmd_line_args);
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   537
  static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, Flag::Flags origin);
47103
a993ec29ec75 8186842: Use Java class loaders for creating the CDS archive
ccheung
parents: 46616
diff changeset
   538
  static jint finalize_vm_init_args(bool patch_mod_javabase);
22555
ea32f6c51d08 8028391: Make the Min/MaxHeapFreeRatio flags manageable
jwilhelm
parents: 22551
diff changeset
   539
  static bool is_bad_option(const JavaVMOption* option, jboolean ignore, const char* option_type);
ea32f6c51d08 8028391: Make the Min/MaxHeapFreeRatio flags manageable
jwilhelm
parents: 22551
diff changeset
   540
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  static bool is_bad_option(const JavaVMOption* option, jboolean ignore) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
    return is_bad_option(option, ignore, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  }
22555
ea32f6c51d08 8028391: Make the Min/MaxHeapFreeRatio flags manageable
jwilhelm
parents: 22551
diff changeset
   544
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  static void describe_range_error(ArgsRange errcode);
46616
66d452cca30f 8178491: -Xss and -XX:ThreadStackSize argument parsing truncates bits
stefank
parents: 43607
diff changeset
   546
  static ArgsRange check_memory_size(julong size, julong min_size, julong max_size);
1676
d80e69372634 6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents: 1388
diff changeset
   547
  static ArgsRange parse_memory_size(const char* s, julong* long_arg,
46616
66d452cca30f 8178491: -Xss and -XX:ThreadStackSize argument parsing truncates bits
stefank
parents: 43607
diff changeset
   548
                                     julong min_size, julong max_size = max_uintx);
5035
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 4885
diff changeset
   549
  // Parse a string for a unsigned integer.  Returns true if value
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 4885
diff changeset
   550
  // is an unsigned integer greater than or equal to the minimum
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 4885
diff changeset
   551
  // parameter passed and returns the value in uintx_arg.  Returns
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 4885
diff changeset
   552
  // false otherwise, with uintx_arg undefined.
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 4885
diff changeset
   553
  static bool parse_uintx(const char* value, uintx* uintx_arg,
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 4885
diff changeset
   554
                          uintx min_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  // methods to build strings from individual args
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  static void build_jvm_args(const char* arg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  static void build_jvm_flags(const char* arg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  static void add_string(char*** bldarray, int* count, const char* arg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  static const char* build_resource_string(char** args, int count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  static bool methodExists(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    char* className, char* methodName,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    int classesNum, char** classes, bool* allMethods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    int methodsNum, char** methods, bool* allClasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  static void parseOnlyLine(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    const char* line,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    short* classesNum, short* classesMax, char*** classes, bool** allMethods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    short* methodsNum, short* methodsMax, char*** methods, bool** allClasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
32823
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   574
  // Returns true if the flag is obsolete (and not yet expired).
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   575
  // In this case the 'version' buffer is filled in with
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   576
  // the version number when the flag became obsolete.
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   577
  static bool is_obsolete_flag(const char* flag_name, JDK_Version* version);
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   578
37173
d8aea1500483 8146632: Add descriptive error messages for removed non-product logging flags.
mockner
parents: 37094
diff changeset
   579
#ifndef PRODUCT
d8aea1500483 8146632: Add descriptive error messages for removed non-product logging flags.
mockner
parents: 37094
diff changeset
   580
  static const char* removed_develop_logging_flag_name(const char* name);
d8aea1500483 8146632: Add descriptive error messages for removed non-product logging flags.
mockner
parents: 37094
diff changeset
   581
#endif // PRODUCT
d8aea1500483 8146632: Add descriptive error messages for removed non-product logging flags.
mockner
parents: 37094
diff changeset
   582
32823
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   583
  // Returns 1 if the flag is deprecated (and not yet obsolete or expired).
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   584
  //     In this case the 'version' buffer is filled in with the version number when
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   585
  //     the flag became deprecated.
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   586
  // Returns -1 if the flag is expired or obsolete.
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   587
  // Returns 0 otherwise.
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   588
  static int is_deprecated_flag(const char* flag_name, JDK_Version* version);
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   589
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   590
  // Return the real name for the flag passed on the command line (either an alias name or "flag_name").
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   591
  static const char* real_flag_name(const char *flag_name);
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   592
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   593
  // Return the "real" name for option arg if arg is an alias, and print a warning if arg is deprecated.
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   594
  // Return NULL if the arg has expired.
ca8fef4cd57b 8066821: Enhance command line processing to manage deprecating and obsoleting -XX command line arguments
drwhite
parents: 32621
diff changeset
   595
  static const char* handle_aliases_and_deprecation(const char* arg, bool warn);
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 35061
diff changeset
   596
  static bool lookup_logging_aliases(const char* arg, char* buffer);
37216
5555c1f804c4 8145235: Deprecate product flags that have been converted to Unified Logging
rprotacio
parents: 37199
diff changeset
   597
  static AliasedLoggingFlag catch_logging_aliases(const char* name, bool on);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  static short  CompileOnlyClassesNum;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  static short  CompileOnlyClassesMax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  static char** CompileOnlyClasses;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  static bool*  CompileOnlyAllMethods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  static short  CompileOnlyMethodsNum;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  static short  CompileOnlyMethodsMax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  static char** CompileOnlyMethods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  static bool*  CompileOnlyAllClasses;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  static short  InterpretOnlyClassesNum;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  static short  InterpretOnlyClassesMax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  static char** InterpretOnlyClasses;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  static bool*  InterpretOnlyAllMethods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  static bool   CheckCompileOnly;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  static char*  SharedArchivePath;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
 public:
28650
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   618
  // Scale compile thresholds
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   619
  // Returns threshold scaled with CompileThresholdScaling
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   620
  static intx scaled_compile_threshold(intx threshold, double scale);
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   621
  static intx scaled_compile_threshold(intx threshold) {
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   622
    return scaled_compile_threshold(threshold, CompileThresholdScaling);
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   623
  }
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   624
  // Returns freq_log scaled with CompileThresholdScaling
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   625
  static intx scaled_freq_log(intx freq_log, double scale);
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   626
  static intx scaled_freq_log(intx freq_log) {
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   627
    return scaled_freq_log(freq_log, CompileThresholdScaling);
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   628
  }
772aaab2582f 8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents: 28372
diff changeset
   629
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   630
  // Parses the arguments, first phase
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  static jint parse(const JavaVMInitArgs* args);
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   632
  // Apply ergonomics
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   633
  static jint apply_ergo();
14580
3e2316663327 7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents: 13963
diff changeset
   634
  // Adjusts the arguments after the OS have adjusted the arguments
3e2316663327 7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents: 13963
diff changeset
   635
  static jint adjust_after_os();
22555
ea32f6c51d08 8028391: Make the Min/MaxHeapFreeRatio flags manageable
jwilhelm
parents: 22551
diff changeset
   636
27892
06a143c836ad 8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents: 27148
diff changeset
   637
  static void set_gc_specific_flags();
37199
74703ea13069 8068579: Running with -XX:-UseParallelGC does not turn ParalleGC off
pliden
parents: 37179
diff changeset
   638
  static bool gc_selected(); // whether a gc has been selected
26836
b27ec66071c7 8057531: refactor gc argument processing code slightly
jcoomes
parents: 26824
diff changeset
   639
  static void select_gc_ergonomically();
36313
e7eff81d7f1d 8145333: -XX:+EnableJVMCI -XX:+UseJVMCICompiler -XX:-EnableJVMCI makes JVM crash
jcm
parents: 35872
diff changeset
   640
#if INCLUDE_JVMCI
e7eff81d7f1d 8145333: -XX:+EnableJVMCI -XX:+UseJVMCICompiler -XX:-EnableJVMCI makes JVM crash
jcm
parents: 35872
diff changeset
   641
  // Check consistency of jvmci vm argument settings.
e7eff81d7f1d 8145333: -XX:+EnableJVMCI -XX:+UseJVMCICompiler -XX:-EnableJVMCI makes JVM crash
jcm
parents: 35872
diff changeset
   642
  static bool check_jvmci_args_consistency();
43433
acc1d9072823 8166125: [JVMCI] Missing JVMCI flag default values
davleopo
parents: 41708
diff changeset
   643
  static void set_jvmci_specific_flags();
36313
e7eff81d7f1d 8145333: -XX:+EnableJVMCI -XX:+UseJVMCICompiler -XX:-EnableJVMCI makes JVM crash
jcm
parents: 35872
diff changeset
   644
#endif
183
ba55c7f3fd45 6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents: 1
diff changeset
   645
  // Check for consistency in the selection of the garbage collector.
29696
01571dfab5be 8073944: Simplify ArgumentsExt and remove unneeded functionallity
sjohanss
parents: 29076
diff changeset
   646
  static bool check_gc_consistency();        // Check user-selected gc
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 20288
diff changeset
   647
  // Check consistency or otherwise of VM argument settings
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  static bool check_vm_args_consistency();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  // Used by os_solaris
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  static bool process_settings_file(const char* file_name, bool should_exist, jboolean ignore_unrecognized);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   652
  static size_t conservative_max_heap_alignment() { return _conservative_max_heap_alignment; }
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   653
  // Return the maximum size a heap with compressed oops can take
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   654
  static size_t max_heap_for_compressed_oops();
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 19732
diff changeset
   655
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  // return a char* array containing all options
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  static char** jvm_flags_array()          { return _jvm_flags_array; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  static char** jvm_args_array()           { return _jvm_args_array; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  static int num_jvm_flags()               { return _num_jvm_flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  static int num_jvm_args()                { return _num_jvm_args; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  // return the arguments passed to the Java application
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  static const char* java_command()        { return _java_command; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  // print jvm_flags, jvm_args and java_command
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  static void print_on(outputStream* st);
31963
641ed52732ec 8026324: hs_err improvement: Add summary section to hs_err file
coleenp
parents: 31853
diff changeset
   666
  static void print_summary_on(outputStream* st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
34125
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   668
  // convenient methods to get and set jvm_flags_file
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   669
  static const char* get_jvm_flags_file()  { return _jvm_flags_file; }
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   670
  static void set_jvm_flags_file(const char *value) {
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   671
    if (_jvm_flags_file != NULL) {
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   672
      os::free(_jvm_flags_file);
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   673
    }
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   674
    _jvm_flags_file = os::strdup_check_oom(value);
56c4a2d19ee1 8141068: refactor -XXFlags= code in preparation for removal
rdurbin
parents: 32823
diff changeset
   675
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  // convenient methods to obtain / print jvm_flags and jvm_args
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  static const char* jvm_flags()           { return build_resource_string(_jvm_flags_array, _num_jvm_flags); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  static const char* jvm_args()            { return build_resource_string(_jvm_args_array, _num_jvm_args); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  static void print_jvm_flags_on(outputStream* st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  static void print_jvm_args_on(outputStream* st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  // -Dkey=value flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  static SystemProperty*  system_properties()   { return _system_properties; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  static const char*    get_property(const char* key);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  // -Djava.vendor.url.bug
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  static const char* java_vendor_url_bug()  { return _java_vendor_url_bug; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  // -Dsun.java.launcher
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  static const char* sun_java_launcher()    { return _sun_java_launcher; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  // Was VM created by a Java launcher?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  static bool created_by_java_launcher();
22734
41757c1f3946 8027113: decouple the '-XXaltjvm=<path>' option from the gamma launcher
rdurbin
parents: 20288
diff changeset
   693
  // -Dsun.java.launcher.is_altjvm
41757c1f3946 8027113: decouple the '-XXaltjvm=<path>' option from the gamma launcher
rdurbin
parents: 20288
diff changeset
   694
  static bool sun_java_launcher_is_altjvm();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  // -Dsun.java.launcher.pid
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  static int sun_java_launcher_pid()        { return _sun_java_launcher_pid; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 20288
diff changeset
   698
  // -Xms
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29696
diff changeset
   699
  static size_t min_heap_size()             { return _min_heap_size; }
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 29696
diff changeset
   700
  static void  set_min_heap_size(size_t v)  { _min_heap_size = v;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  // -Xrun
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  static AgentLibrary* libraries()          { return _libraryList.first(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  static bool init_libraries_at_startup()   { return !_libraryList.is_empty(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  static void convert_library_to_agent(AgentLibrary* lib)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
                                            { _libraryList.remove(lib);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
                                              _agentList.add(lib); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  // -agentlib -agentpath
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  static AgentLibrary* agents()             { return _agentList.first(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  static bool init_agents_at_startup()      { return !_agentList.is_empty(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  // abort, exit, vfprintf hooks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  static abort_hook_t    abort_hook()       { return _abort_hook; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  static exit_hook_t     exit_hook()        { return _exit_hook; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  static vfprintf_hook_t vfprintf_hook()    { return _vfprintf_hook; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  static bool GetCheckCompileOnly ()        { return CheckCompileOnly; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  static const char* GetSharedArchivePath() { return SharedArchivePath; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  static bool CompileMethod(char* className, char* methodName) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
    return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
      methodExists(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
        className, methodName,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
        CompileOnlyClassesNum, CompileOnlyClasses, CompileOnlyAllMethods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
        CompileOnlyMethodsNum, CompileOnlyMethods, CompileOnlyAllClasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
      );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  // Java launcher properties
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  static void process_sun_java_launcher_properties(JavaVMInitArgs* args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  // System properties
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  static void init_system_properties();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
6961
a32b2fc66321 6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents: 6453
diff changeset
   737
  // Update/Initialize System properties after JDK version number is known
a32b2fc66321 6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents: 6453
diff changeset
   738
  static void init_version_specific_system_properties();
a32b2fc66321 6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents: 6453
diff changeset
   739
2358
7c8346929fc6 6819213: revive sun.boot.library.path
phh
parents: 2105
diff changeset
   740
  // Property List manipulation
28372
ce0aad4b8c44 8064457: Introduce compressed oops mode disjoint base and improve compressed heap handling.
goetz
parents: 27926
diff changeset
   741
  static void PropertyList_add(SystemProperty *element);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  static void PropertyList_add(SystemProperty** plist, SystemProperty *element);
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   743
  static void PropertyList_add(SystemProperty** plist, const char* k, const char* v, bool writeable, bool internal);
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   744
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   745
  static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v,
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   746
                                      PropertyAppendable append, PropertyWriteable writeable,
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   747
                                      PropertyInternal internal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  static const char* PropertyList_get_value(SystemProperty* plist, const char* key);
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   749
  static const char* PropertyList_get_readable_value(SystemProperty* plist, const char* key);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  static int  PropertyList_count(SystemProperty* pl);
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   751
  static int  PropertyList_readable_count(SystemProperty* pl);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  static const char* PropertyList_get_key_at(SystemProperty* pl,int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  static char* PropertyList_get_value_at(SystemProperty* pl,int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   755
  static bool is_internal_module_property(const char* option);
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   756
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  // Miscellaneous System property value getter and setters.
32595
8cde9aca5e9f 8132725: Memory leak in Arguments::add_property function
ddmitriev
parents: 32366
diff changeset
   758
  static void set_dll_dir(const char *value) { _sun_boot_library_path->set_value(value); }
8cde9aca5e9f 8132725: Memory leak in Arguments::add_property function
ddmitriev
parents: 32366
diff changeset
   759
  static void set_java_home(const char *value) { _java_home->set_value(value); }
8cde9aca5e9f 8132725: Memory leak in Arguments::add_property function
ddmitriev
parents: 32366
diff changeset
   760
  static void set_library_path(const char *value) { _java_library_path->set_value(value); }
27562
47f369e3c69c 8049367: Modular Run-Time Images
chegar
parents: 27148
diff changeset
   761
  static void set_ext_dirs(char *value)     { _ext_dirs = os::strdup_check_oom(value); }
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   762
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   763
  // Set up the underlying pieces of the system boot class path
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   764
  static void add_patch_mod_prefix(const char *module_name, const char *path, bool* patch_mod_javabase);
40013
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   765
  static void set_sysclasspath(const char *value, bool has_jimage) {
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   766
    // During start up, set by os::set_boot_path()
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   767
    assert(get_sysclasspath() == NULL, "System boot class path previously set");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   768
    _system_boot_class_path->set_value(value);
40013
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   769
    _has_jimage = has_jimage;
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   770
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   771
  static void append_sysclasspath(const char *value) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   772
    _system_boot_class_path->append_value(value);
40013
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   773
    _jdk_boot_class_path_append->append_value(value);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   774
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
40244
b3055c216762 8136930: Simplify use of module-system options by custom launchers
hseigel
parents: 40013
diff changeset
   776
  static GrowableArray<ModulePatchPath*>* get_patch_mod_prefix() { return _patch_mod_prefix; }
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   777
  static char* get_sysclasspath() { return _system_boot_class_path->value(); }
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   778
  static char* get_jdk_boot_class_path_append() { return _jdk_boot_class_path_append->value(); }
40013
943cf01a6b82 8154239: -Xbootclasspath/a breaks exploded build
lfoltan
parents: 38207
diff changeset
   779
  static bool has_jimage() { return _has_jimage; }
37773
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   780
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   781
  static char* get_java_home()    { return _java_home->value(); }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   782
  static char* get_dll_dir()      { return _sun_boot_library_path->value(); }
e5b3e9732c3c 8154956: Module system implementation refresh (4/2016)
alanb
parents: 37491
diff changeset
   783
  static char* get_ext_dirs()     { return _ext_dirs;  }
26135
82b516c550f7 8046070: Class Data Sharing clean up and refactoring
iklam
parents: 25468
diff changeset
   784
  static char* get_appclasspath() { return _java_class_path->value(); }
82b516c550f7 8046070: Class Data Sharing clean up and refactoring
iklam
parents: 25468
diff changeset
   785
  static void  fix_appclasspath();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
27562
47f369e3c69c 8049367: Modular Run-Time Images
chegar
parents: 27148
diff changeset
   787
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  // Operation modi
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   789
  static Mode mode()                        { return _mode; }
26585
2048b8d90c91 8058092: Test vm/mlvm/meth/stress/compiler/deoptimize. Assert in src/share/vm/classfile/systemDictionary.cpp: MH intrinsic invariant
iveresov
parents: 26135
diff changeset
   790
  static bool is_interpreter_only() { return mode() == _int; }
2048b8d90c91 8058092: Test vm/mlvm/meth/stress/compiler/deoptimize. Assert in src/share/vm/classfile/systemDictionary.cpp: MH intrinsic invariant
iveresov
parents: 26135
diff changeset
   791
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  // Utility: copies src into buf, replacing "%%" with "%" and "%p" with pid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  static bool copy_expand_pid(const char* src, size_t srclen, char* buf, size_t buflen);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   795
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36313
diff changeset
   796
  static void check_unsupported_dumping_properties() NOT_CDS_RETURN;
38195
d317aafcc87c 8153073: UL: Set filesize option with k/m/g
ysuenaga
parents: 37491
diff changeset
   797
d317aafcc87c 8153073: UL: Set filesize option with k/m/g
ysuenaga
parents: 37491
diff changeset
   798
  static bool atojulong(const char *s, julong* result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
   800
28838
da47c3cc5c98 8067460: G1: TestResourceManagementFlagWithCommercialBuild.java failed on embedded platform
aharlap
parents: 28650
diff changeset
   801
// Disable options not supported in this release, with a warning if they
da47c3cc5c98 8067460: G1: TestResourceManagementFlagWithCommercialBuild.java failed on embedded platform
aharlap
parents: 28650
diff changeset
   802
// were explicitly requested on the command-line
37253
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   803
#define UNSUPPORTED_OPTION(opt)                          \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   804
do {                                                     \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   805
  if (opt) {                                             \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   806
    if (FLAG_IS_CMDLINE(opt)) {                          \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   807
      warning("-XX:+" #opt " not supported in this VM"); \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   808
    }                                                    \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   809
    FLAG_SET_DEFAULT(opt, false);                        \
45e69c7b0bac 8152929: Remove UNSUPPORTED_GC_OPTION, use UNSUPPORTED_OPTION instead
pliden
parents: 37216
diff changeset
   810
  }                                                      \
28838
da47c3cc5c98 8067460: G1: TestResourceManagementFlagWithCommercialBuild.java failed on embedded platform
aharlap
parents: 28650
diff changeset
   811
} while(0)
da47c3cc5c98 8067460: G1: TestResourceManagementFlagWithCommercialBuild.java failed on embedded platform
aharlap
parents: 28650
diff changeset
   812
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6988
diff changeset
   813
#endif // SHARE_VM_RUNTIME_ARGUMENTS_HPP