1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_RUNTIME_FLAGS_JVMFLAG_HPP
  26 #define SHARE_VM_RUNTIME_FLAGS_JVMFLAG_HPP
  27 
  28 #include "utilities/globalDefinitions.hpp"
  29 #include "utilities/macros.hpp"
  30 
  31 // function type that will construct default range string
  32 typedef const char* (*RangeStrFunc)(void);
  33 
  34 struct JVMFlag {
  35   enum Flags {
  36     // latest value origin
  37     DEFAULT          = 0,
  38     COMMAND_LINE     = 1,
  39     ENVIRON_VAR      = 2,
  40     CONFIG_FILE      = 3,
  41     MANAGEMENT       = 4,
  42     ERGONOMIC        = 5,
  43     ATTACH_ON_DEMAND = 6,
  44     INTERNAL         = 7,
  45 
  46     LAST_VALUE_ORIGIN = INTERNAL,
  47     VALUE_ORIGIN_BITS = 4,
  48     VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS),
  49 
  50     // flag kind
  51     KIND_PRODUCT            = 1 << 4,
  52     KIND_MANAGEABLE         = 1 << 5,
  53     KIND_DIAGNOSTIC         = 1 << 6,
  54     KIND_EXPERIMENTAL       = 1 << 7,
  55     KIND_NOT_PRODUCT        = 1 << 8,
  56     KIND_DEVELOP            = 1 << 9,
  57     KIND_PLATFORM_DEPENDENT = 1 << 10,
  58     KIND_READ_WRITE         = 1 << 11,
  59     KIND_C1                 = 1 << 12,
  60     KIND_C2                 = 1 << 13,
  61     KIND_ARCH               = 1 << 14,
  62     KIND_LP64_PRODUCT       = 1 << 15,
  63     KIND_COMMERCIAL         = 1 << 16,
  64     KIND_JVMCI              = 1 << 17,
  65 
  66     // set this bit if the flag was set on the command line
  67     ORIG_COMMAND_LINE       = 1 << 18,
  68 
  69     KIND_MASK = ~(VALUE_ORIGIN_MASK | ORIG_COMMAND_LINE)
  70   };
  71 
  72   enum Error {
  73     // no error
  74     SUCCESS = 0,
  75     // flag name is missing
  76     MISSING_NAME,
  77     // flag value is missing
  78     MISSING_VALUE,
  79     // error parsing the textual form of the value
  80     WRONG_FORMAT,
  81     // flag is not writable
  82     NON_WRITABLE,
  83     // flag value is outside of its bounds
  84     OUT_OF_BOUNDS,
  85     // flag value violates its constraint
  86     VIOLATES_CONSTRAINT,
  87     // there is no flag with the given name
  88     INVALID_FLAG,
  89     // the flag can only be set only on command line during invocation of the VM
  90     COMMAND_LINE_ONLY,
  91     // the flag may only be set once
  92     SET_ONLY_ONCE,
  93     // the flag is not writable in this combination of product/debug build
  94     CONSTANT,
  95     // other, unspecified error related to setting the flag
  96     ERR_OTHER
  97   };
  98 
  99   enum MsgType {
 100     NONE = 0,
 101     DIAGNOSTIC_FLAG_BUT_LOCKED,
 102     EXPERIMENTAL_FLAG_BUT_LOCKED,
 103     DEVELOPER_FLAG_BUT_PRODUCT_BUILD,
 104     NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD,
 105     COMMERCIAL_FLAG_BUT_DISABLED,
 106     COMMERCIAL_FLAG_BUT_LOCKED
 107   };
 108 
 109   const char* _type;
 110   const char* _name;
 111   void* _addr;
 112   NOT_PRODUCT(const char* _doc;)
 113   Flags _flags;
 114   size_t _name_len;
 115 
 116   // points to all Flags static array
 117   static JVMFlag* flags;
 118 
 119   // number of flags
 120   static size_t numFlags;
 121 
 122   static JVMFlag* find_flag(const char* name) { return find_flag(name, strlen(name), true, true); };
 123   static JVMFlag* find_flag(const char* name, size_t length, bool allow_locked = false, bool return_flag = false);
 124   static JVMFlag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);
 125 
 126   static const char* get_int_default_range_str();
 127   static const char* get_uint_default_range_str();
 128   static const char* get_intx_default_range_str();
 129   static const char* get_uintx_default_range_str();
 130   static const char* get_uint64_t_default_range_str();
 131   static const char* get_size_t_default_range_str();
 132   static const char* get_double_default_range_str();
 133 
 134   JVMFlag::Error check_writable(bool changed);
 135 
 136   bool is_bool() const;
 137   bool get_bool() const;
 138   JVMFlag::Error set_bool(bool value);
 139 
 140   bool is_int() const;
 141   int get_int() const;
 142   JVMFlag::Error set_int(int value);
 143 
 144   bool is_uint() const;
 145   uint get_uint() const;
 146   JVMFlag::Error set_uint(uint value);
 147 
 148   bool is_intx() const;
 149   intx get_intx() const;
 150   JVMFlag::Error set_intx(intx value);
 151 
 152   bool is_uintx() const;
 153   uintx get_uintx() const;
 154   JVMFlag::Error set_uintx(uintx value);
 155 
 156   bool is_uint64_t() const;
 157   uint64_t get_uint64_t() const;
 158   JVMFlag::Error set_uint64_t(uint64_t value);
 159 
 160   bool is_size_t() const;
 161   size_t get_size_t() const;
 162   JVMFlag::Error set_size_t(size_t value);
 163 
 164   bool is_double() const;
 165   double get_double() const;
 166   JVMFlag::Error set_double(double value);
 167 
 168   bool is_ccstr() const;
 169   bool ccstr_accumulates() const;
 170   ccstr get_ccstr() const;
 171   JVMFlag::Error set_ccstr(ccstr value);
 172 
 173   Flags get_origin();
 174   void set_origin(Flags origin);
 175 
 176   size_t get_name_length();
 177 
 178   bool is_default();
 179   bool is_ergonomic();
 180   bool is_command_line();
 181   void set_command_line();
 182 
 183   bool is_product() const;
 184   bool is_manageable() const;
 185   bool is_diagnostic() const;
 186   bool is_experimental() const;
 187   bool is_notproduct() const;
 188   bool is_develop() const;
 189   bool is_read_write() const;
 190   bool is_commercial() const;
 191 
 192   bool is_constant_in_binary() const;
 193 
 194   bool is_unlocker() const;
 195   bool is_unlocked() const;
 196   bool is_writeable() const;
 197   bool is_external() const;
 198 
 199   bool is_unlocker_ext() const;
 200   bool is_unlocked_ext() const;
 201   bool is_writeable_ext() const;
 202   bool is_external_ext() const;
 203 
 204   void clear_diagnostic();
 205 
 206   JVMFlag::MsgType get_locked_message(char*, int) const;
 207   JVMFlag::MsgType get_locked_message_ext(char*, int) const;
 208 
 209   // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
 210   void print_on(outputStream* st, bool withComments = false, bool printRanges = false);
 211   void print_kind(outputStream* st, unsigned int width);
 212   void print_origin(outputStream* st, unsigned int width);
 213   void print_as_flag(outputStream* st);
 214 
 215   static const char* flag_error_str(JVMFlag::Error error);
 216 
 217 public:
 218   static JVMFlag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);
 219   static JVMFlag::Error boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false)      { return boolAt(name, strlen(name), value, allow_locked, return_flag); }
 220   static JVMFlag::Error boolAtPut(JVMFlag* flag, bool* value, JVMFlag::Flags origin);
 221   static JVMFlag::Error boolAtPut(const char* name, size_t len, bool* value, JVMFlag::Flags origin);
 222   static JVMFlag::Error boolAtPut(const char* name, bool* value, JVMFlag::Flags origin)   { return boolAtPut(name, strlen(name), value, origin); }
 223 
 224   static JVMFlag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
 225   static JVMFlag::Error intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false)      { return intAt(name, strlen(name), value, allow_locked, return_flag); }
 226   static JVMFlag::Error intAtPut(JVMFlag* flag, int* value, JVMFlag::Flags origin);
 227   static JVMFlag::Error intAtPut(const char* name, size_t len, int* value, JVMFlag::Flags origin);
 228   static JVMFlag::Error intAtPut(const char* name, int* value, JVMFlag::Flags origin)   { return intAtPut(name, strlen(name), value, origin); }
 229 
 230   static JVMFlag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
 231   static JVMFlag::Error uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false)      { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
 232   static JVMFlag::Error uintAtPut(JVMFlag* flag, uint* value, JVMFlag::Flags origin);
 233   static JVMFlag::Error uintAtPut(const char* name, size_t len, uint* value, JVMFlag::Flags origin);
 234   static JVMFlag::Error uintAtPut(const char* name, uint* value, JVMFlag::Flags origin)   { return uintAtPut(name, strlen(name), value, origin); }
 235 
 236   static JVMFlag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
 237   static JVMFlag::Error intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false)      { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
 238   static JVMFlag::Error intxAtPut(JVMFlag* flag, intx* value, JVMFlag::Flags origin);
 239   static JVMFlag::Error intxAtPut(const char* name, size_t len, intx* value, JVMFlag::Flags origin);
 240   static JVMFlag::Error intxAtPut(const char* name, intx* value, JVMFlag::Flags origin)   { return intxAtPut(name, strlen(name), value, origin); }
 241 
 242   static JVMFlag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);
 243   static JVMFlag::Error uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false)    { return uintxAt(name, strlen(name), value, allow_locked, return_flag); }
 244   static JVMFlag::Error uintxAtPut(JVMFlag* flag, uintx* value, JVMFlag::Flags origin);
 245   static JVMFlag::Error uintxAtPut(const char* name, size_t len, uintx* value, JVMFlag::Flags origin);
 246   static JVMFlag::Error uintxAtPut(const char* name, uintx* value, JVMFlag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
 247 
 248   static JVMFlag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);
 249   static JVMFlag::Error size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false)    { return size_tAt(name, strlen(name), value, allow_locked, return_flag); }
 250   static JVMFlag::Error size_tAtPut(JVMFlag* flag, size_t* value, JVMFlag::Flags origin);
 251   static JVMFlag::Error size_tAtPut(const char* name, size_t len, size_t* value, JVMFlag::Flags origin);
 252   static JVMFlag::Error size_tAtPut(const char* name, size_t* value, JVMFlag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }
 253 
 254   static JVMFlag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);
 255   static JVMFlag::Error uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); }
 256   static JVMFlag::Error uint64_tAtPut(JVMFlag* flag, uint64_t* value, JVMFlag::Flags origin);
 257   static JVMFlag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, JVMFlag::Flags origin);
 258   static JVMFlag::Error uint64_tAtPut(const char* name, uint64_t* value, JVMFlag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
 259 
 260   static JVMFlag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);
 261   static JVMFlag::Error doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false)    { return doubleAt(name, strlen(name), value, allow_locked, return_flag); }
 262   static JVMFlag::Error doubleAtPut(JVMFlag* flag, double* value, JVMFlag::Flags origin);
 263   static JVMFlag::Error doubleAtPut(const char* name, size_t len, double* value, JVMFlag::Flags origin);
 264   static JVMFlag::Error doubleAtPut(const char* name, double* value, JVMFlag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }
 265 
 266   static JVMFlag::Error ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false);
 267   static JVMFlag::Error ccstrAt(const char* name, ccstr* value, bool allow_locked = false, bool return_flag = false)    { return ccstrAt(name, strlen(name), value, allow_locked, return_flag); }
 268   // Contract:  JVMFlag will make private copy of the incoming value.
 269   // Outgoing value is always malloc-ed, and caller MUST call free.
 270   static JVMFlag::Error ccstrAtPut(const char* name, size_t len, ccstr* value, JVMFlag::Flags origin);
 271   static JVMFlag::Error ccstrAtPut(const char* name, ccstr* value, JVMFlag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }
 272 
 273   // Returns false if name is not a command line flag.
 274   static bool wasSetOnCmdline(const char* name, bool* value);
 275   static void printSetFlags(outputStream* out);
 276 
 277   // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
 278   static void printFlags(outputStream* out, bool withComments, bool printRanges = false, bool skipDefaults = false);
 279   static void printError(bool verbose, const char* msg, ...) ATTRIBUTE_PRINTF(2, 3);
 280 
 281   static void verify() PRODUCT_RETURN;
 282 };
 283 
 284 #endif // SHARE_VM_RUNTIME_FLAGS_JVMFLAG_HPP