src/share/vm/opto/c2_globals.hpp

Print this page




  44 #ifdef TARGET_OS_FAMILY_linux
  45 # include "c2_globals_linux.hpp"
  46 #endif
  47 #ifdef TARGET_OS_FAMILY_solaris
  48 # include "c2_globals_solaris.hpp"
  49 #endif
  50 #ifdef TARGET_OS_FAMILY_windows
  51 # include "c2_globals_windows.hpp"
  52 #endif
  53 #ifdef TARGET_OS_FAMILY_aix
  54 # include "c2_globals_aix.hpp"
  55 #endif
  56 #ifdef TARGET_OS_FAMILY_bsd
  57 # include "c2_globals_bsd.hpp"
  58 #endif
  59 
  60 //
  61 // Defines all globals flags used by the server compiler.
  62 //
  63 
  64 #define C2_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, range, constraint) \
  65                                                                             \
  66   develop(bool, StressLCM, false,                                           \
  67           "Randomize instruction scheduling in LCM")                        \
  68                                                                             \
  69   develop(bool, StressGCM, false,                                           \
  70           "Randomize instruction scheduling in GCM")                        \
  71                                                                             \
  72   develop(intx, OptoPrologueNops, 0,                                        \
  73           "Insert this many extra nop instructions "                        \
  74           "in the prologue of every nmethod")                               \
  75           range(0, 128)                                                     \
  76                                                                             \
  77   product_pd(intx, InteriorEntryAlignment,                                  \
  78           "Code alignment for interior entry points "                       \
  79           "in generated code (in bytes)")                                   \
  80           constraint(InteriorEntryAlignmentConstraintFunc, AfterErgo)       \
  81                                                                             \
  82   product(intx, MaxLoopPad, (OptoLoopAlignment-1),                          \
  83           "Align a loop if padding size in bytes is less or equal to this " \
  84           "value")                                                          \


 177                                                                             \
 178   develop(bool, TraceOptoParse, false,                                      \
 179           "Trace bytecode parse and control-flow merge")                    \
 180                                                                             \
 181   product_pd(intx,  LoopUnrollLimit,                                        \
 182           "Unroll loop bodies with node count less than this")              \
 183           range(0, max_jint / 4)                                            \
 184                                                                             \
 185   product_pd(intx, LoopPercentProfileLimit,                                 \
 186              "Unroll loop bodies with % node count of profile limit")       \
 187              range(10, 100)                                                 \
 188                                                                             \
 189   product(intx,  LoopMaxUnroll, 16,                                         \
 190           "Maximum number of unrolls for main loop")                        \
 191           range(0, max_jint)                                                \
 192                                                                             \
 193   product_pd(bool,  SuperWordLoopUnrollAnalysis,                            \
 194            "Map number of unrolls for main loop via "                       \
 195            "Superword Level Parallelism analysis")                          \
 196                                                                             \
 197   product_pd(bool, PostLoopMultiversioning,                                 \
 198            "Multi versioned post loops to eliminate range checks")          \
 199                                                                             \
 200   notproduct(bool, TraceSuperWordLoopUnrollAnalysis, false,                 \
 201           "Trace what Superword Level Parallelism analysis applies")        \
 202                                                                             \
 203   product(intx,  LoopUnrollMin, 4,                                          \
 204           "Minimum number of unroll loop bodies before checking progress"   \
 205           "of rounds of unroll,optimize,..")                                \
 206           range(0, max_jint)                                                \
 207                                                                             \
 208   develop(intx, UnrollLimitForProfileCheck, 1,                              \
 209           "Don't use profile_trip_cnt() to restrict unrolling until "       \
 210           "unrolling would push the number of unrolled iterations above "   \
 211           "UnrollLimitForProfileCheck. A higher value allows more "         \
 212           "unrolling. Zero acts as a very large value." )                   \
 213           range(0, max_intx)                                                \
 214                                                                             \
 215   product(intx, MultiArrayExpandLimit, 6,                                   \
 216           "Maximum number of individual allocations in an inline-expanded " \
 217           "multianewarray instruction")                                     \


 738   product_pd(bool, TrapBasedRangeChecks,                                    \
 739           "Generate code for range checks that uses a cmp and trap "        \
 740           "instruction raising SIGTRAP. Used on PPC64.")                    \
 741                                                                             \
 742   product(intx, ArrayCopyLoadStoreMaxElem, 8,                               \
 743           "Maximum number of arraycopy elements inlined as a sequence of"   \
 744           "loads/stores")                                                   \
 745           range(0, max_intx)                                                \
 746                                                                             \
 747   develop(bool, StressArrayCopyMacroNode, false,                            \
 748           "Perform ArrayCopy load/store replacement during IGVN only")      \
 749                                                                             \
 750   develop(bool, RenumberLiveNodes, true,                                    \
 751           "Renumber live nodes")                                            \
 752 
 753 C2_FLAGS(DECLARE_DEVELOPER_FLAG, \
 754          DECLARE_PD_DEVELOPER_FLAG, \
 755          DECLARE_PRODUCT_FLAG, \
 756          DECLARE_PD_PRODUCT_FLAG, \
 757          DECLARE_DIAGNOSTIC_FLAG, \

 758          DECLARE_EXPERIMENTAL_FLAG, \
 759          DECLARE_NOTPRODUCT_FLAG, \
 760          IGNORE_RANGE, \
 761          IGNORE_CONSTRAINT)
 762 
 763 #endif // SHARE_VM_OPTO_C2_GLOBALS_HPP


  44 #ifdef TARGET_OS_FAMILY_linux
  45 # include "c2_globals_linux.hpp"
  46 #endif
  47 #ifdef TARGET_OS_FAMILY_solaris
  48 # include "c2_globals_solaris.hpp"
  49 #endif
  50 #ifdef TARGET_OS_FAMILY_windows
  51 # include "c2_globals_windows.hpp"
  52 #endif
  53 #ifdef TARGET_OS_FAMILY_aix
  54 # include "c2_globals_aix.hpp"
  55 #endif
  56 #ifdef TARGET_OS_FAMILY_bsd
  57 # include "c2_globals_bsd.hpp"
  58 #endif
  59 
  60 //
  61 // Defines all globals flags used by the server compiler.
  62 //
  63 
  64 #define C2_FLAGS(develop, develop_pd, product, product_pd, diagnostic, diagnostic_pd, experimental, notproduct, range, constraint) \
  65                                                                             \
  66   develop(bool, StressLCM, false,                                           \
  67           "Randomize instruction scheduling in LCM")                        \
  68                                                                             \
  69   develop(bool, StressGCM, false,                                           \
  70           "Randomize instruction scheduling in GCM")                        \
  71                                                                             \
  72   develop(intx, OptoPrologueNops, 0,                                        \
  73           "Insert this many extra nop instructions "                        \
  74           "in the prologue of every nmethod")                               \
  75           range(0, 128)                                                     \
  76                                                                             \
  77   product_pd(intx, InteriorEntryAlignment,                                  \
  78           "Code alignment for interior entry points "                       \
  79           "in generated code (in bytes)")                                   \
  80           constraint(InteriorEntryAlignmentConstraintFunc, AfterErgo)       \
  81                                                                             \
  82   product(intx, MaxLoopPad, (OptoLoopAlignment-1),                          \
  83           "Align a loop if padding size in bytes is less or equal to this " \
  84           "value")                                                          \


 177                                                                             \
 178   develop(bool, TraceOptoParse, false,                                      \
 179           "Trace bytecode parse and control-flow merge")                    \
 180                                                                             \
 181   product_pd(intx,  LoopUnrollLimit,                                        \
 182           "Unroll loop bodies with node count less than this")              \
 183           range(0, max_jint / 4)                                            \
 184                                                                             \
 185   product_pd(intx, LoopPercentProfileLimit,                                 \
 186              "Unroll loop bodies with % node count of profile limit")       \
 187              range(10, 100)                                                 \
 188                                                                             \
 189   product(intx,  LoopMaxUnroll, 16,                                         \
 190           "Maximum number of unrolls for main loop")                        \
 191           range(0, max_jint)                                                \
 192                                                                             \
 193   product_pd(bool,  SuperWordLoopUnrollAnalysis,                            \
 194            "Map number of unrolls for main loop via "                       \
 195            "Superword Level Parallelism analysis")                          \
 196                                                                             \
 197   diagnostic_pd(bool, PostLoopMultiversioning,                              \
 198            "Multi versioned post loops to eliminate range checks")          \
 199                                                                             \
 200   notproduct(bool, TraceSuperWordLoopUnrollAnalysis, false,                 \
 201           "Trace what Superword Level Parallelism analysis applies")        \
 202                                                                             \
 203   product(intx,  LoopUnrollMin, 4,                                          \
 204           "Minimum number of unroll loop bodies before checking progress"   \
 205           "of rounds of unroll,optimize,..")                                \
 206           range(0, max_jint)                                                \
 207                                                                             \
 208   develop(intx, UnrollLimitForProfileCheck, 1,                              \
 209           "Don't use profile_trip_cnt() to restrict unrolling until "       \
 210           "unrolling would push the number of unrolled iterations above "   \
 211           "UnrollLimitForProfileCheck. A higher value allows more "         \
 212           "unrolling. Zero acts as a very large value." )                   \
 213           range(0, max_intx)                                                \
 214                                                                             \
 215   product(intx, MultiArrayExpandLimit, 6,                                   \
 216           "Maximum number of individual allocations in an inline-expanded " \
 217           "multianewarray instruction")                                     \


 738   product_pd(bool, TrapBasedRangeChecks,                                    \
 739           "Generate code for range checks that uses a cmp and trap "        \
 740           "instruction raising SIGTRAP. Used on PPC64.")                    \
 741                                                                             \
 742   product(intx, ArrayCopyLoadStoreMaxElem, 8,                               \
 743           "Maximum number of arraycopy elements inlined as a sequence of"   \
 744           "loads/stores")                                                   \
 745           range(0, max_intx)                                                \
 746                                                                             \
 747   develop(bool, StressArrayCopyMacroNode, false,                            \
 748           "Perform ArrayCopy load/store replacement during IGVN only")      \
 749                                                                             \
 750   develop(bool, RenumberLiveNodes, true,                                    \
 751           "Renumber live nodes")                                            \
 752 
 753 C2_FLAGS(DECLARE_DEVELOPER_FLAG, \
 754          DECLARE_PD_DEVELOPER_FLAG, \
 755          DECLARE_PRODUCT_FLAG, \
 756          DECLARE_PD_PRODUCT_FLAG, \
 757          DECLARE_DIAGNOSTIC_FLAG, \
 758          DECLARE_PD_DIAGNOSTIC_FLAG, \
 759          DECLARE_EXPERIMENTAL_FLAG, \
 760          DECLARE_NOTPRODUCT_FLAG, \
 761          IGNORE_RANGE, \
 762          IGNORE_CONSTRAINT)
 763 
 764 #endif // SHARE_VM_OPTO_C2_GLOBALS_HPP