src/hotspot/share/runtime/flags/jvmFlagWriteableList.cpp
changeset 54982 b18c8301b8c2
parent 50708 bd3a8f48597e
child 58044 3277a7454dc5
equal deleted inserted replaced
54981:0b56fc0448ec 54982:b18c8301b8c2
    23  */
    23  */
    24 
    24 
    25 #include "precompiled.hpp"
    25 #include "precompiled.hpp"
    26 #include "runtime/flags/jvmFlagWriteableList.hpp"
    26 #include "runtime/flags/jvmFlagWriteableList.hpp"
    27 #include "runtime/os.hpp"
    27 #include "runtime/os.hpp"
    28 #ifdef COMPILER1
       
    29 #include "c1/c1_globals.hpp"
       
    30 #endif // COMPILER1
       
    31 #ifdef COMPILER2
       
    32 #include "opto/c2_globals.hpp"
       
    33 #endif // COMPILER2
       
    34 #if INCLUDE_JVMCI
       
    35 #include "jvmci/jvmci_globals.hpp"
       
    36 #endif
       
    37 
    28 
    38 bool JVMFlagWriteable::is_writeable(void) {
    29 bool JVMFlagWriteable::is_writeable(void) {
    39   return _writeable;
    30   return _writeable;
    40 }
    31 }
    41 
    32 
    91 void emit_writeable_double(const char* name, JVMFlagWriteable::WriteableType type) {
    82 void emit_writeable_double(const char* name, JVMFlagWriteable::WriteableType type) {
    92   JVMFlagWriteableList::add(new JVMFlagWriteable(name, type));
    83   JVMFlagWriteableList::add(new JVMFlagWriteable(name, type));
    93 }
    84 }
    94 
    85 
    95 // Generate code to call emit_writeable_xxx function
    86 // Generate code to call emit_writeable_xxx function
    96 #define EMIT_WRITEABLE_PRODUCT_FLAG(type, name, value, doc)      ); emit_writeable_##type(#name
    87 #define EMIT_WRITEABLE_START       (void)(0
    97 #define EMIT_WRITEABLE_DIAGNOSTIC_FLAG(type, name, value, doc)   ); emit_writeable_##type(#name
    88 #define EMIT_WRITEABLE(type, name) ); emit_writeable_##type(#name
    98 #define EMIT_WRITEABLE_EXPERIMENTAL_FLAG(type, name, value, doc) ); emit_writeable_##type(#name
    89 #define EMIT_WRITEABLE_PRODUCT_FLAG(type, name, value, doc)      EMIT_WRITEABLE(type, name)
    99 #define EMIT_WRITEABLE_MANAGEABLE_FLAG(type, name, value, doc)   ); emit_writeable_##type(#name
    90 #define EMIT_WRITEABLE_DIAGNOSTIC_FLAG(type, name, value, doc)   EMIT_WRITEABLE(type, name)
   100 #define EMIT_WRITEABLE_PRODUCT_RW_FLAG(type, name, value, doc)   ); emit_writeable_##type(#name
    91 #define EMIT_WRITEABLE_EXPERIMENTAL_FLAG(type, name, value, doc) EMIT_WRITEABLE(type, name)
   101 #define EMIT_WRITEABLE_PD_PRODUCT_FLAG(type, name, doc)          ); emit_writeable_##type(#name
    92 #define EMIT_WRITEABLE_MANAGEABLE_FLAG(type, name, value, doc)   EMIT_WRITEABLE(type, name)
   102 #define EMIT_WRITEABLE_DEVELOPER_FLAG(type, name, value, doc)    ); emit_writeable_##type(#name
    93 #define EMIT_WRITEABLE_PRODUCT_RW_FLAG(type, name, value, doc)   EMIT_WRITEABLE(type, name)
   103 #define EMIT_WRITEABLE_PD_DEVELOPER_FLAG(type, name, doc)        ); emit_writeable_##type(#name
    94 #define EMIT_WRITEABLE_PD_PRODUCT_FLAG(type, name, doc)          EMIT_WRITEABLE(type, name)
   104 #define EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG(type, name, doc)       ); emit_writeable_##type(#name
    95 #define EMIT_WRITEABLE_DEVELOPER_FLAG(type, name, value, doc)    EMIT_WRITEABLE(type, name)
   105 #define EMIT_WRITEABLE_NOTPRODUCT_FLAG(type, name, value, doc)   ); emit_writeable_##type(#name
    96 #define EMIT_WRITEABLE_PD_DEVELOPER_FLAG(type, name, doc)        EMIT_WRITEABLE(type, name)
   106 #define EMIT_WRITEABLE_LP64_PRODUCT_FLAG(type, name, value, doc) ); emit_writeable_##type(#name
    97 #define EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG(type, name, doc)       EMIT_WRITEABLE(type, name)
       
    98 #define EMIT_WRITEABLE_NOTPRODUCT_FLAG(type, name, value, doc)   EMIT_WRITEABLE(type, name)
       
    99 #define EMIT_WRITEABLE_LP64_PRODUCT_FLAG(type, name, value, doc) EMIT_WRITEABLE(type, name)
       
   100 #define EMIT_WRITEABLE_END         );
   107 
   101 
   108 // Generate type argument to pass into emit_writeable_xxx functions
   102 // Generate type argument to pass into emit_writeable_xxx functions
   109 #define EMIT_WRITEABLE(a)                                      , JVMFlagWriteable::a
   103 #define EMIT_WRITEABLE_CHECK(a)                                  , JVMFlagWriteable::a
   110 
   104 
   111 #define INITIAL_WRITEABLES_SIZE 2
   105 #define INITIAL_WRITEABLES_SIZE 2
   112 GrowableArray<JVMFlagWriteable*>* JVMFlagWriteableList::_controls = NULL;
   106 GrowableArray<JVMFlagWriteable*>* JVMFlagWriteableList::_controls = NULL;
   113 
   107 
   114 void JVMFlagWriteableList::init(void) {
   108 void JVMFlagWriteableList::init(void) {
   115 
   109 
   116   _controls = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<JVMFlagWriteable*>(INITIAL_WRITEABLES_SIZE, true);
   110   _controls = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<JVMFlagWriteable*>(INITIAL_WRITEABLES_SIZE, true);
   117 
   111 
   118   emit_writeable_no(NULL VM_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
   112   EMIT_WRITEABLE_START
   119                                   EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
   113 
   120                                   EMIT_WRITEABLE_PRODUCT_FLAG,
   114   ALL_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
   121                                   EMIT_WRITEABLE_PD_PRODUCT_FLAG,
   115             EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
   122                                   EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
   116             EMIT_WRITEABLE_PRODUCT_FLAG,
   123                                   EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
   117             EMIT_WRITEABLE_PD_PRODUCT_FLAG,
   124                                   EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
   118             EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
   125                                   EMIT_WRITEABLE_NOTPRODUCT_FLAG,
   119             EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
   126                                   EMIT_WRITEABLE_MANAGEABLE_FLAG,
   120             EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
   127                                   EMIT_WRITEABLE_PRODUCT_RW_FLAG,
   121             EMIT_WRITEABLE_NOTPRODUCT_FLAG,
   128                                   EMIT_WRITEABLE_LP64_PRODUCT_FLAG,
   122             EMIT_WRITEABLE_MANAGEABLE_FLAG,
   129                                   IGNORE_RANGE,
   123             EMIT_WRITEABLE_PRODUCT_RW_FLAG,
   130                                   IGNORE_CONSTRAINT,
   124             EMIT_WRITEABLE_LP64_PRODUCT_FLAG,
   131                                   EMIT_WRITEABLE));
   125             IGNORE_RANGE,
       
   126             IGNORE_CONSTRAINT,
       
   127             EMIT_WRITEABLE_CHECK)
   132 
   128 
   133   EMIT_WRITEABLES_FOR_GLOBALS_EXT
   129   EMIT_WRITEABLES_FOR_GLOBALS_EXT
   134 
   130 
   135   emit_writeable_no(NULL ARCH_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
   131   EMIT_WRITEABLE_END
   136                                 EMIT_WRITEABLE_PRODUCT_FLAG,
       
   137                                 EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
       
   138                                 EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
       
   139                                 EMIT_WRITEABLE_NOTPRODUCT_FLAG,
       
   140                                 IGNORE_RANGE,
       
   141                                 IGNORE_CONSTRAINT,
       
   142                                 EMIT_WRITEABLE));
       
   143 
       
   144 #if INCLUDE_JVMCI
       
   145   emit_writeable_no(NULL JVMCI_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
       
   146                                  EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
       
   147                                  EMIT_WRITEABLE_PRODUCT_FLAG,
       
   148                                  EMIT_WRITEABLE_PD_PRODUCT_FLAG,
       
   149                                  EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
       
   150                                  EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
       
   151                                  EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
       
   152                                  EMIT_WRITEABLE_NOTPRODUCT_FLAG,
       
   153                                  IGNORE_RANGE,
       
   154                                  IGNORE_CONSTRAINT,
       
   155                                  EMIT_WRITEABLE));
       
   156 #endif // INCLUDE_JVMCI
       
   157 
       
   158 #ifdef COMPILER1
       
   159   emit_writeable_no(NULL C1_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
       
   160                               EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
       
   161                               EMIT_WRITEABLE_PRODUCT_FLAG,
       
   162                               EMIT_WRITEABLE_PD_PRODUCT_FLAG,
       
   163                               EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
       
   164                               EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
       
   165                               EMIT_WRITEABLE_NOTPRODUCT_FLAG,
       
   166                               IGNORE_RANGE,
       
   167                               IGNORE_CONSTRAINT,
       
   168                               EMIT_WRITEABLE));
       
   169 #endif // COMPILER1
       
   170 
       
   171 #ifdef COMPILER2
       
   172   emit_writeable_no(NULL C2_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
       
   173                               EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
       
   174                               EMIT_WRITEABLE_PRODUCT_FLAG,
       
   175                               EMIT_WRITEABLE_PD_PRODUCT_FLAG,
       
   176                               EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
       
   177                               EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
       
   178                               EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
       
   179                               EMIT_WRITEABLE_NOTPRODUCT_FLAG,
       
   180                               IGNORE_RANGE,
       
   181                               IGNORE_CONSTRAINT,
       
   182                               EMIT_WRITEABLE));
       
   183 #endif // COMPILER2
       
   184 }
   132 }
   185 
   133 
   186 JVMFlagWriteable* JVMFlagWriteableList::find(const char* name) {
   134 JVMFlagWriteable* JVMFlagWriteableList::find(const char* name) {
   187   JVMFlagWriteable* found = NULL;
   135   JVMFlagWriteable* found = NULL;
   188   for (int i=0; i<length(); i++) {
   136   for (int i=0; i<length(); i++) {