src/hotspot/share/gc/shared/gc_globals.hpp
changeset 49982 9042ffe5b7fe
parent 49741 0d8ed8b2ac4f
child 50523 7b7c75d87f9b
child 56533 28a4f284ad83
equal deleted inserted replaced
49981:bd0a95bec96b 49982:9042ffe5b7fe
    23  */
    23  */
    24 
    24 
    25 #ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
    25 #ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
    26 #define SHARE_GC_SHARED_GC_GLOBALS_HPP
    26 #define SHARE_GC_SHARED_GC_GLOBALS_HPP
    27 
    27 
       
    28 #include "utilities/macros.hpp"
       
    29 #if INCLUDE_CMSGC
       
    30 #include "gc/cms/cms_globals.hpp"
       
    31 #endif
       
    32 #if INCLUDE_G1GC
       
    33 #include "gc/g1/g1_globals.hpp"
       
    34 #endif
       
    35 #if INCLUDE_PARALLELGC
       
    36 #include "gc/parallel/parallel_globals.hpp"
       
    37 #endif
       
    38 #if INCLUDE_SERIALGC
    28 #include "gc/serial/serial_globals.hpp"
    39 #include "gc/serial/serial_globals.hpp"
    29 #include "utilities/macros.hpp"
       
    30 #if INCLUDE_ALL_GCS
       
    31 #include "gc/cms/cms_globals.hpp"
       
    32 #include "gc/g1/g1_globals.hpp"
       
    33 #include "gc/parallel/parallel_globals.hpp"
       
    34 #endif
    40 #endif
    35 
    41 
    36 #define GC_FLAGS(develop,                                                   \
    42 #define GC_FLAGS(develop,                                                   \
    37                  develop_pd,                                                \
    43                  develop_pd,                                                \
    38                  product,                                                   \
    44                  product,                                                   \
    46                  lp64_product,                                              \
    52                  lp64_product,                                              \
    47                  range,                                                     \
    53                  range,                                                     \
    48                  constraint,                                                \
    54                  constraint,                                                \
    49                  writeable)                                                 \
    55                  writeable)                                                 \
    50                                                                             \
    56                                                                             \
    51   ALL_GCS_ONLY(GC_CMS_FLAGS(                                                \
    57   CMSGC_ONLY(GC_CMS_FLAGS(                                                  \
    52     develop,                                                                \
    58     develop,                                                                \
    53     develop_pd,                                                             \
    59     develop_pd,                                                             \
    54     product,                                                                \
    60     product,                                                                \
    55     product_pd,                                                             \
    61     product_pd,                                                             \
    56     diagnostic,                                                             \
    62     diagnostic,                                                             \
    62     lp64_product,                                                           \
    68     lp64_product,                                                           \
    63     range,                                                                  \
    69     range,                                                                  \
    64     constraint,                                                             \
    70     constraint,                                                             \
    65     writeable))                                                             \
    71     writeable))                                                             \
    66                                                                             \
    72                                                                             \
    67   ALL_GCS_ONLY(GC_G1_FLAGS(                                                 \
    73   G1GC_ONLY(GC_G1_FLAGS(                                                    \
    68     develop,                                                                \
    74     develop,                                                                \
    69     develop_pd,                                                             \
    75     develop_pd,                                                             \
    70     product,                                                                \
    76     product,                                                                \
    71     product_pd,                                                             \
    77     product_pd,                                                             \
    72     diagnostic,                                                             \
    78     diagnostic,                                                             \
    78     lp64_product,                                                           \
    84     lp64_product,                                                           \
    79     range,                                                                  \
    85     range,                                                                  \
    80     constraint,                                                             \
    86     constraint,                                                             \
    81     writeable))                                                             \
    87     writeable))                                                             \
    82                                                                             \
    88                                                                             \
    83   ALL_GCS_ONLY(GC_PARALLEL_FLAGS(                                           \
    89   PARALLELGC_ONLY(GC_PARALLEL_FLAGS(                                        \
    84     develop,                                                                \
    90     develop,                                                                \
    85     develop_pd,                                                             \
    91     develop_pd,                                                             \
    86     product,                                                                \
    92     product,                                                                \
    87     product_pd,                                                             \
    93     product_pd,                                                             \
    88     diagnostic,                                                             \
    94     diagnostic,                                                             \
    94     lp64_product,                                                           \
   100     lp64_product,                                                           \
    95     range,                                                                  \
   101     range,                                                                  \
    96     constraint,                                                             \
   102     constraint,                                                             \
    97     writeable))                                                             \
   103     writeable))                                                             \
    98                                                                             \
   104                                                                             \
    99   GC_SERIAL_FLAGS(                                                          \
   105   SERIALGC_ONLY(GC_SERIAL_FLAGS(                                            \
   100     develop,                                                                \
   106     develop,                                                                \
   101     develop_pd,                                                             \
   107     develop_pd,                                                             \
   102     product,                                                                \
   108     product,                                                                \
   103     product_pd,                                                             \
   109     product_pd,                                                             \
   104     diagnostic,                                                             \
   110     diagnostic,                                                             \
   108     manageable,                                                             \
   114     manageable,                                                             \
   109     product_rw,                                                             \
   115     product_rw,                                                             \
   110     lp64_product,                                                           \
   116     lp64_product,                                                           \
   111     range,                                                                  \
   117     range,                                                                  \
   112     constraint,                                                             \
   118     constraint,                                                             \
   113     writeable)                                                              \
   119     writeable))                                                             \
   114                                                                             \
   120                                                                             \
   115   /* gc */                                                                  \
   121   /* gc */                                                                  \
   116                                                                             \
   122                                                                             \
   117   product(bool, UseConcMarkSweepGC, false,                                  \
   123   product(bool, UseConcMarkSweepGC, false,                                  \
   118           "Use Concurrent Mark-Sweep GC in the old generation")             \
   124           "Use Concurrent Mark-Sweep GC in the old generation")             \