Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/hotspot/share/runtime/flags/jvmFlag.hpp
branchdatagramsocketimpl-branch
changeset 58678 9cf78a70fa4f
parent 53244 9807daeb47c4
child 58679 9c3209ff7550
equal deleted inserted replaced
58677:13588c901957 58678:9cf78a70fa4f 
   116   static JVMFlag* flags;
 
   116   static JVMFlag* flags;
 
   117 
   117 
   118   // number of flags
 
   118   // number of flags
 
   119   static size_t numFlags;
 
   119   static size_t numFlags;
 
   120 
   120 
   121   static JVMFlag* find_flag(const char* name) { return find_flag(name, strlen(name), true, true); };
 
   121 private:
 
   122   static JVMFlag* find_flag(const char* name, size_t length, bool allow_locked = false, bool return_flag = false);
 
   122   static JVMFlag* find_flag(const char* name, size_t length, bool allow_locked, bool return_flag);
 
       
   123 
       
   124 public:
 
       
   125   static JVMFlag* find_flag(const char* name) {
 
       
   126     return find_flag(name, strlen(name), false, false);
 
       
   127   }
 
       
   128   static const JVMFlag* find_declared_flag(const char* name, size_t length) {
 
       
   129     return find_flag(name, length, true, true);
 
       
   130   }
 
       
   131   static const JVMFlag* find_declared_flag(const char* name) {
 
       
   132     return find_declared_flag(name, strlen(name));
 
       
   133   }
 
       
   134 
   123   static JVMFlag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);
 
   135   static JVMFlag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);
 
   124 
   136 
   125   static const char* get_int_default_range_str();
 
   137   static const char* get_int_default_range_str();
 
   126   static const char* get_uint_default_range_str();
 
   138   static const char* get_uint_default_range_str();
 
   127   static const char* get_intx_default_range_str();
 
   139   static const char* get_intx_default_range_str();
 
   192   bool is_unlocker() const;
 
   204   bool is_unlocker() const;
 
   193   bool is_unlocked() const;
 
   205   bool is_unlocked() const;
 
   194   bool is_writeable() const;
 
   206   bool is_writeable() const;
 
   195   bool is_external() const;
 
   207   bool is_external() const;
 
   196 
   208 
   197   bool is_unlocker_ext() const;
 
       
   198   bool is_unlocked_ext() const;
 
       
   199   bool is_writeable_ext() const;
 
       
   200   bool is_external_ext() const;
 
       
   201 
       
   202   void clear_diagnostic();
 
   209   void clear_diagnostic();
 
   203 
   210 
   204   JVMFlag::MsgType get_locked_message(char*, int) const;
 
   211   JVMFlag::MsgType get_locked_message(char*, int) const;
 
   205   JVMFlag::MsgType get_locked_message_ext(char*, int) const;
 
   212   JVMFlag::MsgType get_locked_message_ext(char*, int) const;
 
   206 
   213 
   211   void print_as_flag(outputStream* st);
 
   218   void print_as_flag(outputStream* st);
 
   212 
   219 
   213   static const char* flag_error_str(JVMFlag::Error error);
 
   220   static const char* flag_error_str(JVMFlag::Error error);
 
   214 
   221 
   215 public:
 
   222 public:
 
   216   static JVMFlag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);
 
   223   static JVMFlag::Error boolAt(const JVMFlag* flag, bool* value);
 
   217   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); }
 
       
   218   static JVMFlag::Error boolAtPut(JVMFlag* flag, bool* value, JVMFlag::Flags origin);
 
   224   static JVMFlag::Error boolAtPut(JVMFlag* flag, bool* value, JVMFlag::Flags origin);
 
   219   static JVMFlag::Error boolAtPut(const char* name, size_t len, bool* value, JVMFlag::Flags origin);
 
   225 
   220   static JVMFlag::Error boolAtPut(const char* name, bool* value, JVMFlag::Flags origin)   { return boolAtPut(name, strlen(name), value, origin); }
 
   226   static JVMFlag::Error intAt(const JVMFlag* flag, int* value);
 
   221 
       
   222   static JVMFlag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
 
       
   223   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); }
 
       
   224   static JVMFlag::Error intAtPut(JVMFlag* flag, int* value, JVMFlag::Flags origin);
 
   227   static JVMFlag::Error intAtPut(JVMFlag* flag, int* value, JVMFlag::Flags origin);
 
   225   static JVMFlag::Error intAtPut(const char* name, size_t len, int* value, JVMFlag::Flags origin);
 
   228 
   226   static JVMFlag::Error intAtPut(const char* name, int* value, JVMFlag::Flags origin)   { return intAtPut(name, strlen(name), value, origin); }
 
   229   static JVMFlag::Error uintAt(const JVMFlag* flag, uint* value);
 
   227 
       
   228   static JVMFlag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
 
       
   229   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); }
 
       
   230   static JVMFlag::Error uintAtPut(JVMFlag* flag, uint* value, JVMFlag::Flags origin);
 
   230   static JVMFlag::Error uintAtPut(JVMFlag* flag, uint* value, JVMFlag::Flags origin);
 
   231   static JVMFlag::Error uintAtPut(const char* name, size_t len, uint* value, JVMFlag::Flags origin);
 
   231 
   232   static JVMFlag::Error uintAtPut(const char* name, uint* value, JVMFlag::Flags origin)   { return uintAtPut(name, strlen(name), value, origin); }
 
   232   static JVMFlag::Error intxAt(const JVMFlag* flag, intx* value);
 
   233 
       
   234   static JVMFlag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
 
       
   235   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); }
 
       
   236   static JVMFlag::Error intxAtPut(JVMFlag* flag, intx* value, JVMFlag::Flags origin);
 
   233   static JVMFlag::Error intxAtPut(JVMFlag* flag, intx* value, JVMFlag::Flags origin);
 
   237   static JVMFlag::Error intxAtPut(const char* name, size_t len, intx* value, JVMFlag::Flags origin);
 
   234 
   238   static JVMFlag::Error intxAtPut(const char* name, intx* value, JVMFlag::Flags origin)   { return intxAtPut(name, strlen(name), value, origin); }
 
   235   static JVMFlag::Error uintxAt(const JVMFlag* flag, uintx* value);
 
   239 
       
   240   static JVMFlag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);
 
       
   241   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); }
 
       
   242   static JVMFlag::Error uintxAtPut(JVMFlag* flag, uintx* value, JVMFlag::Flags origin);
 
   236   static JVMFlag::Error uintxAtPut(JVMFlag* flag, uintx* value, JVMFlag::Flags origin);
 
   243   static JVMFlag::Error uintxAtPut(const char* name, size_t len, uintx* value, JVMFlag::Flags origin);
 
   237 
   244   static JVMFlag::Error uintxAtPut(const char* name, uintx* value, JVMFlag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
 
   238   static JVMFlag::Error size_tAt(const JVMFlag* flag, size_t* value);
 
   245 
       
   246   static JVMFlag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);
 
       
   247   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); }
 
       
   248   static JVMFlag::Error size_tAtPut(JVMFlag* flag, size_t* value, JVMFlag::Flags origin);
 
   239   static JVMFlag::Error size_tAtPut(JVMFlag* flag, size_t* value, JVMFlag::Flags origin);
 
   249   static JVMFlag::Error size_tAtPut(const char* name, size_t len, size_t* value, JVMFlag::Flags origin);
 
   240 
   250   static JVMFlag::Error size_tAtPut(const char* name, size_t* value, JVMFlag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }
 
   241   static JVMFlag::Error uint64_tAt(const JVMFlag* flag, uint64_t* value);
 
   251 
       
   252   static JVMFlag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);
 
       
   253   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); }
 
       
   254   static JVMFlag::Error uint64_tAtPut(JVMFlag* flag, uint64_t* value, JVMFlag::Flags origin);
 
   242   static JVMFlag::Error uint64_tAtPut(JVMFlag* flag, uint64_t* value, JVMFlag::Flags origin);
 
   255   static JVMFlag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, JVMFlag::Flags origin);
 
   243 
   256   static JVMFlag::Error uint64_tAtPut(const char* name, uint64_t* value, JVMFlag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
 
   244   static JVMFlag::Error doubleAt(const JVMFlag* flag, double* value);
 
   257 
       
   258   static JVMFlag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);
 
       
   259   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); }
 
       
   260   static JVMFlag::Error doubleAtPut(JVMFlag* flag, double* value, JVMFlag::Flags origin);
 
   245   static JVMFlag::Error doubleAtPut(JVMFlag* flag, double* value, JVMFlag::Flags origin);
 
   261   static JVMFlag::Error doubleAtPut(const char* name, size_t len, double* value, JVMFlag::Flags origin);
 
   246 
   262   static JVMFlag::Error doubleAtPut(const char* name, double* value, JVMFlag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }
 
   247   static JVMFlag::Error ccstrAt(const JVMFlag* flag, ccstr* value);
 
   263 
       
   264   static JVMFlag::Error ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false);
 
       
   265   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); }
 
       
   266   // Contract:  JVMFlag will make private copy of the incoming value.
 
   248   // Contract:  JVMFlag will make private copy of the incoming value.
 
   267   // Outgoing value is always malloc-ed, and caller MUST call free.
 
   249   // Outgoing value is always malloc-ed, and caller MUST call free.
 
   268   static JVMFlag::Error ccstrAtPut(const char* name, size_t len, ccstr* value, JVMFlag::Flags origin);
 
   250   static JVMFlag::Error ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlag::Flags origin);
 
   269   static JVMFlag::Error ccstrAtPut(const char* name, ccstr* value, JVMFlag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }
 
   251 
   270 
       
   271   // Returns false if name is not a command line flag.
 
       
   272   static bool wasSetOnCmdline(const char* name, bool* value);
 
       
   273   static void printSetFlags(outputStream* out);
 
   252   static void printSetFlags(outputStream* out);
 
   274 
   253 
   275   // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
 
   254   // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
 
   276   static void printFlags(outputStream* out, bool withComments, bool printRanges = false, bool skipDefaults = false);
 
   255   static void printFlags(outputStream* out, bool withComments, bool printRanges = false, bool skipDefaults = false);
 
   277   static void printError(bool verbose, const char* msg, ...) ATTRIBUTE_PRINTF(2, 3);
 
   256   static void printError(bool verbose, const char* msg, ...) ATTRIBUTE_PRINTF(2, 3);
jdk-sandbox