OptOptions (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.opt.OptOptions

All Implemented Interfaces:

Cloneable
```
public class OptOptions
extends Object
implements Cloneable
```
Class to handle command-line arguments and options for the optimizng compiler.
Note: This file is mechanically generated from OptOptions.template and MasterOptions.template
Note: Boolean options are defined in /home/vagrant/rvm-trunk/rvm/src-generated/options/BooleanOptions.opt.dat /home/vagrant/rvm-trunk/rvm/src-generated/options/SharedBooleanOptions.dat All other options are defined in /home/vagrant/rvm-trunk/rvm/src-generated/options/ValueOptions.opt.dat /home/vagrant/rvm-trunk/rvm/src-generated/options/SharedValueOptions.dat (value, enumeration, bitmask)

Field Summary

Fields
Modifier and Type	Field and Description
`boolean`	`ADAPTIVE_INSTRUMENTATION_SAMPLING` Perform code transformation to sample instrumentation code.
`boolean`	`ADAPTIVE_NO_DUPLICATION` When performing inst. sampling, should it be done without duplicating code?
`boolean`	`ADAPTIVE_PROCESSOR_SPECIFIC_COUNTER` Should there be one CBS counter per processor for SMP performance?
`boolean`	`ADAPTIVE_REMOVE_YP_FROM_CHECKING` Should yieldpoints be removed from the checking code (requires finite sample interval)
`int`	`CONTROL_COND_MOVE_CUTOFF` How many extra instructions will we insert in order to remove a conditional branch?
`boolean`	`CONTROL_STATIC_SPLITTING` CFG splitting to create hot traces based on static heuristics
`int`	`CONTROL_STATIC_SPLITTING_MAX_COST` Upper bound on the number of instructions duplicated per block when trying to create hot traces with static splitting
`int`	`CONTROL_TABLESWITCH_CUTOFF` If a tableswitch comprises this many or fewer comparisons convert it into multiple if-then-else style branches
`boolean`	`CONTROL_TURN_WHILES_INTO_UNTILS` Turn whiles into untils
`int`	`CONTROL_UNROLL_LOG` Unroll loops.
`double`	`CONTROL_WELL_PREDICTED_CUTOFF` Don't replace branches with conditional moves if they are outside of the range of 0.5 +- this value
`boolean`	`DEBUG_CODEGEN` Enable debugging support for final assembly
`boolean`	`DEBUG_GCP` Perform noisy global code placement
`boolean`	`DEBUG_INSTRU_SAMPLING` Enable debugging statements for instrumentation sampling
`boolean`	`DEBUG_INSTRU_SAMPLING_DETAIL` Enable detailed debugging statements for instrumentation sampling
`private HashSet<String>`	`DRIVER_EXCLUDE` Exclude methods from being opt compiled
`boolean`	`ESCAPE_INVOKEE_THREAD_LOCAL` Compile the method assuming the invokee is thread-local.
`int`	`ESCAPE_MAX_ARRAY_SIZE` Maximum size of array to replaced with registers by simple escape analysis
`boolean`	`ESCAPE_MONITOR_REMOVAL` Try to remove unnecessary monitor operations
`boolean`	`ESCAPE_SCALAR_REPLACE_AGGREGATES` If possible turn aggregates (objects) into variable definition/uses
`boolean`	`ESCAPE_SIMPLE_IPA` Eagerly compute method summaries for simple escape analysis
`boolean`	`FIELD_ANALYSIS` Eagerly compute method summaries for flow-insensitive field analysis
`boolean`	`FREQ_FOCUS_EFFORT` Focus compilation effort based on frequency profile data
`boolean`	`H2L_CALL_VIA_JTOC` Plant virtual calls via the JTOC rather than from the tib of anobject when possible
`boolean`	`H2L_INLINE_NEW` Inline allocation of scalars and arrays
`boolean`	`H2L_INLINE_PRIMITIVE_WRITE_BARRIER` Inline primitive write barriers for certain collectors
`boolean`	`H2L_INLINE_WRITE_BARRIER` Inline write barriers for generational collectors
`boolean`	`H2L_NO_CALLEE_EXCEPTIONS` Assert that any callee of this compiled method will not throw exceptions.
`boolean`	`INLINE` Inline statically resolvable calls
`int`	`INLINE_AI_MAX_TARGET_SIZE` Adaptive inlining heuristic: Upper bound on callee size
`double`	`INLINE_AI_MIN_CALLSITE_FRACTION` Adaptive inlining heuristc: Minimum fraction of callsite distribution for guarded inlining of a callee
`double`	`INLINE_CALL_DEPTH_COST` As we inline deeper nested methods what cost (or bonus) do we wish to give to deter (or encourage) nesting of deeper methods?
`double`	`INLINE_DECLARED_AASTORED_ARRAY_ARG_BONUS` Bonus given when there's potential to optimize checkstore portion of aastore bytecode on parameter
`double`	`INLINE_EXTANT_REG_CLASS_ARG_BONUS` Bonus given to inlining methods that are passed a register that's known not to be null.
`static byte`	`INLINE_GUARD_CLASS_TEST`
`static byte`	`INLINE_GUARD_CODE_PATCH`
`byte`	`INLINE_GUARD_KIND` Selection of guard mechanism for inlined virtual calls that cannot be statically bound
`static byte`	`INLINE_GUARD_METHOD_TEST`
`boolean`	`INLINE_GUARDED` Guarded inlining of non-final virtual calls
`boolean`	`INLINE_GUARDED_INTERFACES` Speculatively inline non-final interface calls
`double`	`INLINE_INT_CONST_ARG_BONUS` Bonus given to inlining methods that are passed an int constant argument
`int`	`INLINE_MASSIVE_METHOD_SIZE` Static inlining heuristic: If root method is already this big, then only inline trivial methods
`int`	`INLINE_MAX_ALWAYS_INLINE_TARGET_SIZE` Static inlining heuristic: Always inline callees of this size or smaller
`double`	`INLINE_MAX_ARG_BONUS` Maximum bonus for reducing the perceived size of a method during inlining.
`int`	`INLINE_MAX_INLINE_DEPTH` Static inlining heuristic: Upper bound on depth of inlining
`int`	`INLINE_MAX_TARGET_SIZE` Static inlining heuristic: Upper bound on callee size
`double`	`INLINE_NULL_CONST_ARG_BONUS` Bonus given to inlining methods that are passed a null constant argument
`double`	`INLINE_OBJECT_CONST_ARG_BONUS` Bonus given to inlining methods that are passed an object constant argument
`double`	`INLINE_PRECISE_REG_ARRAY_ARG_BONUS` Bonus given to inlining methods that are passed a register of a known precise type.
`double`	`INLINE_PRECISE_REG_CLASS_ARG_BONUS` Bonus given to inlining methods that are passed a register of a known precise type.
`boolean`	`INLINE_PREEX` Pre-existence based inlining
`boolean`	`L2M_HANDLER_LIVENESS` Store liveness for handlers to improve dependence graph at PEIs
`int`	`L2M_MAX_BLOCK_SIZE` Maximum size of block for BURS in real instructions, larger blocks are split.
`boolean`	`LOCAL_CONSTANT_PROP` Perform local constant propagation
`boolean`	`LOCAL_COPY_PROP` Perform local copy propagation
`boolean`	`LOCAL_CSE` Perform local common subexpression elimination
`boolean`	`LOCAL_EXPRESSION_FOLDING` Should we try to fold expressions with constants locally?
`private HashSet<String>`	`METHOD_TO_PRINT` Only apply print options against methods whose name contains this string
`private int`	`OPTIMIZATION_LEVEL`
`boolean`	`OSR_GUARDED_INLINING` Insert OSR point at off branch of guarded inlining?
`boolean`	`OSR_INLINE_POLICY` Use OSR knowledge to drive more aggressive inlining?
`boolean`	`PRINT_ALL_IR` Dump the IR after each compiler phase
`boolean`	`PRINT_CALLING_CONVENTIONS` Print IR after expanding calling conventions
`boolean`	`PRINT_CFG` Print control flow graph too when IR is printed
`boolean`	`PRINT_DETAILED_INLINE_REPORT` Print detailed report of compile-time inlining decisions
`boolean`	`PRINT_DG_BURS` Print dependence graph before burs
`boolean`	`PRINT_DOMINATORS` Print dominators
`boolean`	`PRINT_FINAL_HIR` Print IR just before conversion to LIR
`boolean`	`PRINT_FINAL_LIR` Print IR just before conversion to MIR
`boolean`	`PRINT_FINAL_MIR` Print IR just before conversion to machine code
`boolean`	`PRINT_GC_MAPS` Print the garbage collection maps
`boolean`	`PRINT_HIGH` Print IR after initial generation
`boolean`	`PRINT_INLINE_REPORT` Print detailed report of compile-time inlining decisions
`int`	`PRINT_IR_LEVEL` Only print IR compiled above this level
`boolean`	`PRINT_LOW` Print IR after conversion to LIR
`boolean`	`PRINT_MACHINECODE` Print final machine code
`boolean`	`PRINT_METHOD` Print method name at start of compilation
`boolean`	`PRINT_MIR` Print IR after conversion to MIR
`boolean`	`PRINT_PHASES` Print short message for each compilation phase
`boolean`	`PRINT_POST_DOMINATORS` Print post-dominators
`boolean`	`PRINT_REGALLOC` Print IR before and after register allocation
`boolean`	`PRINT_SSA` Print SSA form
`boolean`	`PRINT_STATIC_STATS` Print out compile-time statistics for basic blocks?
`boolean`	`PRINT_VISUALIZATION` When dumping the IR, generate a visualization in a file instead
`double`	`PROFILE_CBS_HOTNESS` Threshold at which a conditional branch is considered to be skewed
`static byte`	`PROFILE_COUNTERS_FREQ`
`static byte`	`PROFILE_DUMB_FREQ`
`String`	`PROFILE_EDGE_COUNT_INPUT_FILE` Input file of edge counter profile data
`byte`	`PROFILE_FREQUENCY_STRATEGY` How to compute block and edge frequencies?
`float`	`PROFILE_INFREQUENT_THRESHOLD` Cumulative threshold which defines the set of infrequent basic blocks
`static byte`	`PROFILE_INVERSE_COUNTERS_FREQ`
`static byte`	`PROFILE_STATIC_FREQ`
`boolean`	`READS_KILL` Should we constrain optimizations by enforcing reads-kill?
`static byte`	`REGALLOC_BLOCK_COUNT_SPILL_COST`
`static byte`	`REGALLOC_BRAINDEAD_SPILL_COST`
`boolean`	`REGALLOC_COALESCE_MOVES` Attempt to coalesce to eliminate register moves?
`boolean`	`REGALLOC_COALESCE_SPILLS` Attempt to coalesce stack locations?
`static byte`	`REGALLOC_SIMPLE_SPILL_COST`
`double`	`REGALLOC_SIMPLE_SPILL_COST_MEMORY_OPERAND_FACTOR` spill penalty for registers used in memory operands
`double`	`REGALLOC_SIMPLE_SPILL_COST_MOVE_FACTOR` spill penalty for move instructions
`byte`	`REGALLOC_SPILL_COST_ESTIMATE` Selection of spilling heuristic
`boolean`	`REORDER_CODE` Reorder basic blocks for improved locality and branch prediction
`boolean`	`REORDER_CODE_PH` Reorder basic blocks using Pettis and Hansen Algo2
`boolean`	`SIMPLIFY_CHASE_FINAL_FIELDS` Chase final fields avoiding loads at runtime
`boolean`	`SIMPLIFY_DOUBLE_OPS` Simplify operations on floats
`boolean`	`SIMPLIFY_FIELD_OPS` Simplify operations on fields
`boolean`	`SIMPLIFY_FLOAT_OPS` Simplify operations on floats
`boolean`	`SIMPLIFY_INTEGER_OPS` Simplify operations on integers
`boolean`	`SIMPLIFY_LONG_OPS` Simplify operations on longs
`boolean`	`SIMPLIFY_REF_OPS` Simplify operations on references
`boolean`	`SIMPLIFY_TIB_OPS` Simplify operations on TIBs
`boolean`	`SSA` Should SSA form be constructed on the HIR?
`boolean`	`SSA_COALESCE_AFTER` Should we coalesce move instructions after leaving SSA?
`boolean`	`SSA_EXPRESSION_FOLDING` Should we try to fold expressions with constants in SSA form?
`boolean`	`SSA_GCP` Perform global code placement
`boolean`	`SSA_GCSE` Perform global code placement
`boolean`	`SSA_LICM_IGNORE_PEI` Assume PEIs do not throw or state is not observable
`boolean`	`SSA_LIVE_RANGE_SPLITTING` Split live ranges using LIR SSA pass?
`boolean`	`SSA_LOAD_ELIMINATION` Should we perform redundant load elimination during SSA pass?
`int`	`SSA_LOAD_ELIMINATION_ROUNDS` How many rounds of redundant load elimination will we attempt?
`boolean`	`SSA_LOOP_VERSIONING` Create copies of loops where runtime exceptions are checked prior to entry
`boolean`	`SSA_REDUNDANT_BRANCH_ELIMINATION` Eliminate redundant conditional branches
`boolean`	`SSA_SPLITBLOCK_FOR_LOCAL_LIVE` When leaving SSA create blocks for local liveness
`boolean`	`SSA_SPLITBLOCK_INTO_INFREQUENT` When leaving SSA create blocks to avoid adding code to frequently executed blocks
`boolean`	`SSA_SPLITBLOCK_TO_AVOID_RENAME` When leaving SSA create blocks to avoid renaming variables
`String`	`VISUALIZE_IR_DIRECTORY` If visualization is enabled, the directory to write visualization files to

Constructor Summary

Constructors
Constructor and Description

OptOptions()

Constructors
Constructor and Description
`OptOptions()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`blockCountSpillCost()` Is REGALLOC_SPILL_COST_ESTIMATE set to REGALLOC_BLOCK_COUNT_SPILL_COST?
`boolean`	`brainDeadSpillCost()` Is REGALLOC_SPILL_COST_ESTIMATE set to REGALLOC_BRAINDEAD_SPILL_COST?
`Object`	`clone()`
`boolean`	`dumbFrequency()` Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_DUMB_FREQ?
`OptOptions`	`dup()`
`boolean`	`frequencyCounters()` Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_COUNTERS_FREQ?
`boolean`	`fuzzyMatchDRIVER_EXCLUDE(String q)` Does the given parameter appear within a set the String of one of the options?
`boolean`	`fuzzyMatchMETHOD_TO_PRINT(String q)` Does the given parameter appear within a set the String of one of the options?
`Iterator<String>`	`getDRIVER_EXCLUDEs()` Return an iterator over the items in DRIVER_EXCLUDE
`Iterator<String>`	`getMETHOD_TO_PRINTs()` Return an iterator over the items in METHOD_TO_PRINT
`int`	`getOptLevel()` Gets the current opt level.
`boolean`	`guardWithClassTest()` Is INLINE_GUARD_KIND set to INLINE_GUARD_CLASS_TEST?
`boolean`	`guardWithCodePatch()` Is INLINE_GUARD_KIND set to INLINE_GUARD_CODE_PATCH?
`boolean`	`guardWithMethodTest()` Is INLINE_GUARD_KIND set to INLINE_GUARD_METHOD_TEST?
`boolean`	`hasDRIVER_EXCLUDE()` Have any items been placed in the set DRIVER_EXCLUDE?
`boolean`	`hasMETHOD_TO_PRINT()` Have any items been placed in the set METHOD_TO_PRINT?
`private static void`	`instancePrintHelpFooter(String prefix)`
`private static void`	`instancePrintHelpHeader(String prefix)`
`private boolean`	`instanceProcessAsOption(String arg)`
`boolean`	`inverseFrequencyCounters()` Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_INVERSE_COUNTERS_FREQ?
`boolean`	`isDRIVER_EXCLUDE(String q)` Has the given parameter been added to DRIVER_EXCLUDE set of options?
`boolean`	`isMETHOD_TO_PRINT(String q)` Has the given parameter been added to METHOD_TO_PRINT set of options?
`static void`	`printHelp(String prefix)` Prints a short description of every option
`void`	`printOptions()` print a String value of this options object
`private void`	`printOptionsHeader()`
`boolean`	`processAsOption(String prefix, String arg)` Take a string (most likely a command-line argument) and try to proccess it as an option command.
`void`	`setOptLevel(int level)` Set the options to encode the optimizations enabled at the given opt label and disabled all optimizations that are not enabled at the given opt label
`boolean`	`simpleSpillCost()` Is REGALLOC_SPILL_COST_ESTIMATE set to REGALLOC_SIMPLE_SPILL_COST?
`boolean`	`staticFrequencyEstimates()` Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_STATIC_FREQ?
`String`	`toString()`

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - OPTIMIZATION_LEVEL
```
private int OPTIMIZATION_LEVEL
```
  - FREQ_FOCUS_EFFORT
```
public boolean FREQ_FOCUS_EFFORT
```
    Focus compilation effort based on frequency profile data
  - READS_KILL
```
public boolean READS_KILL
```
    Should we constrain optimizations by enforcing reads-kill?
  - FIELD_ANALYSIS
```
public boolean FIELD_ANALYSIS
```
    Eagerly compute method summaries for flow-insensitive field analysis
  - INLINE
```
public boolean INLINE
```
    Inline statically resolvable calls
  - INLINE_GUARDED
```
public boolean INLINE_GUARDED
```
    Guarded inlining of non-final virtual calls
  - INLINE_GUARDED_INTERFACES
```
public boolean INLINE_GUARDED_INTERFACES
```
    Speculatively inline non-final interface calls
  - INLINE_PREEX
```
public boolean INLINE_PREEX
```
    Pre-existence based inlining
  - SIMPLIFY_INTEGER_OPS
```
public boolean SIMPLIFY_INTEGER_OPS
```
    Simplify operations on integers
  - SIMPLIFY_LONG_OPS
```
public boolean SIMPLIFY_LONG_OPS
```
    Simplify operations on longs
  - SIMPLIFY_FLOAT_OPS
```
public boolean SIMPLIFY_FLOAT_OPS
```
    Simplify operations on floats
  - SIMPLIFY_DOUBLE_OPS
```
public boolean SIMPLIFY_DOUBLE_OPS
```
    Simplify operations on floats
  - SIMPLIFY_REF_OPS
```
public boolean SIMPLIFY_REF_OPS
```
    Simplify operations on references
  - SIMPLIFY_TIB_OPS
```
public boolean SIMPLIFY_TIB_OPS
```
    Simplify operations on TIBs
  - SIMPLIFY_FIELD_OPS
```
public boolean SIMPLIFY_FIELD_OPS
```
    Simplify operations on fields
  - SIMPLIFY_CHASE_FINAL_FIELDS
```
public boolean SIMPLIFY_CHASE_FINAL_FIELDS
```
    Chase final fields avoiding loads at runtime
  - LOCAL_CONSTANT_PROP
```
public boolean LOCAL_CONSTANT_PROP
```
    Perform local constant propagation
  - LOCAL_COPY_PROP
```
public boolean LOCAL_COPY_PROP
```
    Perform local copy propagation
  - LOCAL_CSE
```
public boolean LOCAL_CSE
```
    Perform local common subexpression elimination
  - LOCAL_EXPRESSION_FOLDING
```
public boolean LOCAL_EXPRESSION_FOLDING
```
    Should we try to fold expressions with constants locally?
  - CONTROL_STATIC_SPLITTING
```
public boolean CONTROL_STATIC_SPLITTING
```
    CFG splitting to create hot traces based on static heuristics
  - CONTROL_TURN_WHILES_INTO_UNTILS
```
public boolean CONTROL_TURN_WHILES_INTO_UNTILS
```
    Turn whiles into untils
  - ESCAPE_SIMPLE_IPA
```
public boolean ESCAPE_SIMPLE_IPA
```
    Eagerly compute method summaries for simple escape analysis
  - ESCAPE_SCALAR_REPLACE_AGGREGATES
```
public boolean ESCAPE_SCALAR_REPLACE_AGGREGATES
```
    If possible turn aggregates (objects) into variable definition/uses
  - ESCAPE_MONITOR_REMOVAL
```
public boolean ESCAPE_MONITOR_REMOVAL
```
    Try to remove unnecessary monitor operations
  - ESCAPE_INVOKEE_THREAD_LOCAL
```
public boolean ESCAPE_INVOKEE_THREAD_LOCAL
```
    Compile the method assuming the invokee is thread-local. Cannot be properly set on command line.
  - SSA
```
public boolean SSA
```
    Should SSA form be constructed on the HIR?
  - SSA_EXPRESSION_FOLDING
```
public boolean SSA_EXPRESSION_FOLDING
```
    Should we try to fold expressions with constants in SSA form?
  - SSA_REDUNDANT_BRANCH_ELIMINATION
```
public boolean SSA_REDUNDANT_BRANCH_ELIMINATION
```
    Eliminate redundant conditional branches
  - SSA_LICM_IGNORE_PEI
```
public boolean SSA_LICM_IGNORE_PEI
```
    Assume PEIs do not throw or state is not observable
  - SSA_LOAD_ELIMINATION
```
public boolean SSA_LOAD_ELIMINATION
```
    Should we perform redundant load elimination during SSA pass?
  - SSA_COALESCE_AFTER
```
public boolean SSA_COALESCE_AFTER
```
    Should we coalesce move instructions after leaving SSA?
  - SSA_LOOP_VERSIONING
```
public boolean SSA_LOOP_VERSIONING
```
    Create copies of loops where runtime exceptions are checked prior to entry
  - SSA_LIVE_RANGE_SPLITTING
```
public boolean SSA_LIVE_RANGE_SPLITTING
```
    Split live ranges using LIR SSA pass?
  - SSA_GCP
```
public boolean SSA_GCP
```
    Perform global code placement
  - SSA_GCSE
```
public boolean SSA_GCSE
```
    Perform global code placement
  - SSA_SPLITBLOCK_TO_AVOID_RENAME
```
public boolean SSA_SPLITBLOCK_TO_AVOID_RENAME
```
    When leaving SSA create blocks to avoid renaming variables
  - SSA_SPLITBLOCK_FOR_LOCAL_LIVE
```
public boolean SSA_SPLITBLOCK_FOR_LOCAL_LIVE
```
    When leaving SSA create blocks for local liveness
  - SSA_SPLITBLOCK_INTO_INFREQUENT
```
public boolean SSA_SPLITBLOCK_INTO_INFREQUENT
```
    When leaving SSA create blocks to avoid adding code to frequently executed blocks
  - REORDER_CODE
```
public boolean REORDER_CODE
```
    Reorder basic blocks for improved locality and branch prediction
  - REORDER_CODE_PH
```
public boolean REORDER_CODE_PH
```
    Reorder basic blocks using Pettis and Hansen Algo2
  - H2L_INLINE_NEW
```
public boolean H2L_INLINE_NEW
```
    Inline allocation of scalars and arrays
  - H2L_INLINE_WRITE_BARRIER
```
public boolean H2L_INLINE_WRITE_BARRIER
```
    Inline write barriers for generational collectors
  - H2L_INLINE_PRIMITIVE_WRITE_BARRIER
```
public boolean H2L_INLINE_PRIMITIVE_WRITE_BARRIER
```
    Inline primitive write barriers for certain collectors
  - H2L_NO_CALLEE_EXCEPTIONS
```
public boolean H2L_NO_CALLEE_EXCEPTIONS
```
    Assert that any callee of this compiled method will not throw exceptions. Cannot be properly set on command line.
  - H2L_CALL_VIA_JTOC
```
public boolean H2L_CALL_VIA_JTOC
```
    Plant virtual calls via the JTOC rather than from the tib of anobject when possible
  - L2M_HANDLER_LIVENESS
```
public boolean L2M_HANDLER_LIVENESS
```
    Store liveness for handlers to improve dependence graph at PEIs
  - REGALLOC_COALESCE_MOVES
```
public boolean REGALLOC_COALESCE_MOVES
```
    Attempt to coalesce to eliminate register moves?
  - REGALLOC_COALESCE_SPILLS
```
public boolean REGALLOC_COALESCE_SPILLS
```
    Attempt to coalesce stack locations?
  - ADAPTIVE_INSTRUMENTATION_SAMPLING
```
public boolean ADAPTIVE_INSTRUMENTATION_SAMPLING
```
    Perform code transformation to sample instrumentation code.
  - ADAPTIVE_NO_DUPLICATION
```
public boolean ADAPTIVE_NO_DUPLICATION
```
    When performing inst. sampling, should it be done without duplicating code?
  - ADAPTIVE_PROCESSOR_SPECIFIC_COUNTER
```
public boolean ADAPTIVE_PROCESSOR_SPECIFIC_COUNTER
```
    Should there be one CBS counter per processor for SMP performance?
  - ADAPTIVE_REMOVE_YP_FROM_CHECKING
```
public boolean ADAPTIVE_REMOVE_YP_FROM_CHECKING
```
    Should yieldpoints be removed from the checking code (requires finite sample interval)
  - OSR_GUARDED_INLINING
```
public boolean OSR_GUARDED_INLINING
```
    Insert OSR point at off branch of guarded inlining?
  - OSR_INLINE_POLICY
```
public boolean OSR_INLINE_POLICY
```
    Use OSR knowledge to drive more aggressive inlining?
  - PRINT_STATIC_STATS
```
public boolean PRINT_STATIC_STATS
```
    Print out compile-time statistics for basic blocks?
  - PRINT_PHASES
```
public boolean PRINT_PHASES
```
    Print short message for each compilation phase
  - PRINT_ALL_IR
```
public boolean PRINT_ALL_IR
```
    Dump the IR after each compiler phase
  - PRINT_DETAILED_INLINE_REPORT
```
public boolean PRINT_DETAILED_INLINE_REPORT
```
    Print detailed report of compile-time inlining decisions
  - PRINT_INLINE_REPORT
```
public boolean PRINT_INLINE_REPORT
```
    Print detailed report of compile-time inlining decisions
  - PRINT_DOMINATORS
```
public boolean PRINT_DOMINATORS
```
    Print dominators
  - PRINT_POST_DOMINATORS
```
public boolean PRINT_POST_DOMINATORS
```
    Print post-dominators
  - PRINT_SSA
```
public boolean PRINT_SSA
```
    Print SSA form
  - PRINT_DG_BURS
```
public boolean PRINT_DG_BURS
```
    Print dependence graph before burs
  - PRINT_VISUALIZATION
```
public boolean PRINT_VISUALIZATION
```
    When dumping the IR, generate a visualization in a file instead
  - PRINT_HIGH
```
public boolean PRINT_HIGH
```
    Print IR after initial generation
  - PRINT_FINAL_HIR
```
public boolean PRINT_FINAL_HIR
```
    Print IR just before conversion to LIR
  - PRINT_LOW
```
public boolean PRINT_LOW
```
    Print IR after conversion to LIR
  - PRINT_FINAL_LIR
```
public boolean PRINT_FINAL_LIR
```
    Print IR just before conversion to MIR
  - PRINT_MIR
```
public boolean PRINT_MIR
```
    Print IR after conversion to MIR
  - PRINT_FINAL_MIR
```
public boolean PRINT_FINAL_MIR
```
    Print IR just before conversion to machine code
  - PRINT_CFG
```
public boolean PRINT_CFG
```
    Print control flow graph too when IR is printed
  - PRINT_REGALLOC
```
public boolean PRINT_REGALLOC
```
    Print IR before and after register allocation
  - PRINT_CALLING_CONVENTIONS
```
public boolean PRINT_CALLING_CONVENTIONS
```
    Print IR after expanding calling conventions
  - PRINT_GC_MAPS
```
public boolean PRINT_GC_MAPS
```
    Print the garbage collection maps
  - DEBUG_CODEGEN
```
public boolean DEBUG_CODEGEN
```
    Enable debugging support for final assembly
  - DEBUG_INSTRU_SAMPLING
```
public boolean DEBUG_INSTRU_SAMPLING
```
    Enable debugging statements for instrumentation sampling
  - DEBUG_INSTRU_SAMPLING_DETAIL
```
public boolean DEBUG_INSTRU_SAMPLING_DETAIL
```
    Enable detailed debugging statements for instrumentation sampling
  - DEBUG_GCP
```
public boolean DEBUG_GCP
```
    Perform noisy global code placement
  - PRINT_METHOD
```
public boolean PRINT_METHOD
```
    Print method name at start of compilation
  - PRINT_MACHINECODE
```
public boolean PRINT_MACHINECODE
```
    Print final machine code
  - DRIVER_EXCLUDE
```
private HashSet<String> DRIVER_EXCLUDE
```
    Exclude methods from being opt compiled
  - PRINT_IR_LEVEL
```
public int PRINT_IR_LEVEL
```
    Only print IR compiled above this level
  - VISUALIZE_IR_DIRECTORY
```
public String VISUALIZE_IR_DIRECTORY
```
    If visualization is enabled, the directory to write visualization files to
  - PROFILE_EDGE_COUNT_INPUT_FILE
```
public String PROFILE_EDGE_COUNT_INPUT_FILE
```
    Input file of edge counter profile data
  - PROFILE_FREQUENCY_STRATEGY
```
public byte PROFILE_FREQUENCY_STRATEGY
```
    How to compute block and edge frequencies?
  - PROFILE_INFREQUENT_THRESHOLD
```
public float PROFILE_INFREQUENT_THRESHOLD
```
    Cumulative threshold which defines the set of infrequent basic blocks
  - PROFILE_CBS_HOTNESS
```
public double PROFILE_CBS_HOTNESS
```
    Threshold at which a conditional branch is considered to be skewed
  - ESCAPE_MAX_ARRAY_SIZE
```
public int ESCAPE_MAX_ARRAY_SIZE
```
    Maximum size of array to replaced with registers by simple escape analysis
  - SSA_LOAD_ELIMINATION_ROUNDS
```
public int SSA_LOAD_ELIMINATION_ROUNDS
```
    How many rounds of redundant load elimination will we attempt?
  - L2M_MAX_BLOCK_SIZE
```
public int L2M_MAX_BLOCK_SIZE
```
    Maximum size of block for BURS in real instructions, larger blocks are split.
  - REGALLOC_SPILL_COST_ESTIMATE
```
public byte REGALLOC_SPILL_COST_ESTIMATE
```
    Selection of spilling heuristic
  - REGALLOC_SIMPLE_SPILL_COST_MOVE_FACTOR
```
public double REGALLOC_SIMPLE_SPILL_COST_MOVE_FACTOR
```
    spill penalty for move instructions
  - REGALLOC_SIMPLE_SPILL_COST_MEMORY_OPERAND_FACTOR
```
public double REGALLOC_SIMPLE_SPILL_COST_MEMORY_OPERAND_FACTOR
```
    spill penalty for registers used in memory operands
  - CONTROL_TABLESWITCH_CUTOFF
```
public int CONTROL_TABLESWITCH_CUTOFF
```
    If a tableswitch comprises this many or fewer comparisons convert it into multiple if-then-else style branches
  - CONTROL_COND_MOVE_CUTOFF
```
public int CONTROL_COND_MOVE_CUTOFF
```
    How many extra instructions will we insert in order to remove a conditional branch?
  - CONTROL_UNROLL_LOG
```
public int CONTROL_UNROLL_LOG
```
    Unroll loops. Duplicates the loop body 2^n times.
  - CONTROL_STATIC_SPLITTING_MAX_COST
```
public int CONTROL_STATIC_SPLITTING_MAX_COST
```
    Upper bound on the number of instructions duplicated per block when trying to create hot traces with static splitting
  - CONTROL_WELL_PREDICTED_CUTOFF
```
public double CONTROL_WELL_PREDICTED_CUTOFF
```
    Don't replace branches with conditional moves if they are outside of the range of 0.5 +- this value
  - INLINE_MAX_TARGET_SIZE
```
public int INLINE_MAX_TARGET_SIZE
```
    Static inlining heuristic: Upper bound on callee size
  - INLINE_MAX_INLINE_DEPTH
```
public int INLINE_MAX_INLINE_DEPTH
```
    Static inlining heuristic: Upper bound on depth of inlining
  - INLINE_MAX_ALWAYS_INLINE_TARGET_SIZE
```
public int INLINE_MAX_ALWAYS_INLINE_TARGET_SIZE
```
    Static inlining heuristic: Always inline callees of this size or smaller
  - INLINE_MASSIVE_METHOD_SIZE
```
public int INLINE_MASSIVE_METHOD_SIZE
```
    Static inlining heuristic: If root method is already this big, then only inline trivial methods
  - INLINE_MAX_ARG_BONUS
```
public double INLINE_MAX_ARG_BONUS
```
    Maximum bonus for reducing the perceived size of a method during inlining.
  - INLINE_PRECISE_REG_ARRAY_ARG_BONUS
```
public double INLINE_PRECISE_REG_ARRAY_ARG_BONUS
```
    Bonus given to inlining methods that are passed a register of a known precise type.
  - INLINE_DECLARED_AASTORED_ARRAY_ARG_BONUS
```
public double INLINE_DECLARED_AASTORED_ARRAY_ARG_BONUS
```
    Bonus given when there's potential to optimize checkstore portion of aastore bytecode on parameter
  - INLINE_PRECISE_REG_CLASS_ARG_BONUS
```
public double INLINE_PRECISE_REG_CLASS_ARG_BONUS
```
    Bonus given to inlining methods that are passed a register of a known precise type.
  - INLINE_EXTANT_REG_CLASS_ARG_BONUS
```
public double INLINE_EXTANT_REG_CLASS_ARG_BONUS
```
    Bonus given to inlining methods that are passed a register that's known not to be null.
  - INLINE_INT_CONST_ARG_BONUS
```
public double INLINE_INT_CONST_ARG_BONUS
```
    Bonus given to inlining methods that are passed an int constant argument
  - INLINE_NULL_CONST_ARG_BONUS
```
public double INLINE_NULL_CONST_ARG_BONUS
```
    Bonus given to inlining methods that are passed a null constant argument
  - INLINE_OBJECT_CONST_ARG_BONUS
```
public double INLINE_OBJECT_CONST_ARG_BONUS
```
    Bonus given to inlining methods that are passed an object constant argument
  - INLINE_CALL_DEPTH_COST
```
public double INLINE_CALL_DEPTH_COST
```
    As we inline deeper nested methods what cost (or bonus) do we wish to give to deter (or encourage) nesting of deeper methods?
  - INLINE_AI_MAX_TARGET_SIZE
```
public int INLINE_AI_MAX_TARGET_SIZE
```
    Adaptive inlining heuristic: Upper bound on callee size
  - INLINE_AI_MIN_CALLSITE_FRACTION
```
public double INLINE_AI_MIN_CALLSITE_FRACTION
```
    Adaptive inlining heuristc: Minimum fraction of callsite distribution for guarded inlining of a callee
  - INLINE_GUARD_KIND
```
public byte INLINE_GUARD_KIND
```
    Selection of guard mechanism for inlined virtual calls that cannot be statically bound
  - METHOD_TO_PRINT
```
private HashSet<String> METHOD_TO_PRINT
```
    Only apply print options against methods whose name contains this string
  - PROFILE_COUNTERS_FREQ
```
public static final byte PROFILE_COUNTERS_FREQ
```
    See Also:
    
    Constant Field Values
  - PROFILE_STATIC_FREQ
```
public static final byte PROFILE_STATIC_FREQ
```
    See Also:
    
    Constant Field Values
  - PROFILE_DUMB_FREQ
```
public static final byte PROFILE_DUMB_FREQ
```
    See Also:
    
    Constant Field Values
  - PROFILE_INVERSE_COUNTERS_FREQ
```
public static final byte PROFILE_INVERSE_COUNTERS_FREQ
```
    See Also:
    
    Constant Field Values
  - REGALLOC_SIMPLE_SPILL_COST
```
public static final byte REGALLOC_SIMPLE_SPILL_COST
```
    See Also:
    
    Constant Field Values
  - REGALLOC_BRAINDEAD_SPILL_COST
```
public static final byte REGALLOC_BRAINDEAD_SPILL_COST
```
    See Also:
    
    Constant Field Values
  - REGALLOC_BLOCK_COUNT_SPILL_COST
```
public static final byte REGALLOC_BLOCK_COUNT_SPILL_COST
```
    See Also:
    
    Constant Field Values
  - INLINE_GUARD_METHOD_TEST
```
public static final byte INLINE_GUARD_METHOD_TEST
```
    See Also:
    
    Constant Field Values
  - INLINE_GUARD_CLASS_TEST
```
public static final byte INLINE_GUARD_CLASS_TEST
```
    See Also:
    
    Constant Field Values
  - INLINE_GUARD_CODE_PATCH
```
public static final byte INLINE_GUARD_CODE_PATCH
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - OptOptions
```
public OptOptions()
```
- Method Detail
  - printOptionsHeader
```
private void printOptionsHeader()
```
  - frequencyCounters
```
public final boolean frequencyCounters()
```
    Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_COUNTERS_FREQ?
    
    Returns:
    
    true when PROFILE_COUNTERS_FREQ is set to PROFILE_FREQUENCY_STRATEGY, false otherwise
  - staticFrequencyEstimates
```
public final boolean staticFrequencyEstimates()
```
    Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_STATIC_FREQ?
    
    Returns:
    
    true when PROFILE_STATIC_FREQ is set to PROFILE_FREQUENCY_STRATEGY, false otherwise
  - dumbFrequency
```
public final boolean dumbFrequency()
```
    Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_DUMB_FREQ?
    
    Returns:
    
    true when PROFILE_DUMB_FREQ is set to PROFILE_FREQUENCY_STRATEGY, false otherwise
  - inverseFrequencyCounters
```
public final boolean inverseFrequencyCounters()
```
    Is PROFILE_FREQUENCY_STRATEGY set to PROFILE_INVERSE_COUNTERS_FREQ?
    
    Returns:
    
    true when PROFILE_INVERSE_COUNTERS_FREQ is set to PROFILE_FREQUENCY_STRATEGY, false otherwise
  - simpleSpillCost
```
public final boolean simpleSpillCost()
```
    Is REGALLOC_SPILL_COST_ESTIMATE set to REGALLOC_SIMPLE_SPILL_COST?
    
    Returns:
    
    true when REGALLOC_SIMPLE_SPILL_COST is set to REGALLOC_SPILL_COST_ESTIMATE, false otherwise
  - brainDeadSpillCost
```
public final boolean brainDeadSpillCost()
```
    Is REGALLOC_SPILL_COST_ESTIMATE set to REGALLOC_BRAINDEAD_SPILL_COST?
    
    Returns:
    
    true when REGALLOC_BRAINDEAD_SPILL_COST is set to REGALLOC_SPILL_COST_ESTIMATE, false otherwise
  - blockCountSpillCost
```
public final boolean blockCountSpillCost()
```
    Is REGALLOC_SPILL_COST_ESTIMATE set to REGALLOC_BLOCK_COUNT_SPILL_COST?
    
    Returns:
    
    true when REGALLOC_BLOCK_COUNT_SPILL_COST is set to REGALLOC_SPILL_COST_ESTIMATE, false otherwise
  - guardWithMethodTest
```
public final boolean guardWithMethodTest()
```
    Is INLINE_GUARD_KIND set to INLINE_GUARD_METHOD_TEST?
    
    Returns:
    
    true when INLINE_GUARD_METHOD_TEST is set to INLINE_GUARD_KIND, false otherwise
  - guardWithClassTest
```
public final boolean guardWithClassTest()
```
    Is INLINE_GUARD_KIND set to INLINE_GUARD_CLASS_TEST?
    
    Returns:
    
    true when INLINE_GUARD_CLASS_TEST is set to INLINE_GUARD_KIND, false otherwise
  - guardWithCodePatch
```
public final boolean guardWithCodePatch()
```
    Is INLINE_GUARD_KIND set to INLINE_GUARD_CODE_PATCH?
    
    Returns:
    
    true when INLINE_GUARD_CODE_PATCH is set to INLINE_GUARD_KIND, false otherwise
  - isDRIVER_EXCLUDE
```
public boolean isDRIVER_EXCLUDE(String q)
```
    Has the given parameter been added to DRIVER_EXCLUDE set of options?
    
    Parameters:
    
    q - the parameter
    
    Returns:
    
    true when the parameter has been added, false otherwise
  - fuzzyMatchDRIVER_EXCLUDE
```
public boolean fuzzyMatchDRIVER_EXCLUDE(String q)
```
    Does the given parameter appear within a set the String of one of the options?
    
    Parameters:
    
    q - the parameter to search for
    
    Returns:
    
    true when it does appear, false otherwise
  - hasDRIVER_EXCLUDE
```
public boolean hasDRIVER_EXCLUDE()
```
    Have any items been placed in the set DRIVER_EXCLUDE?
    
    Returns:
    
    true if the set exists and is not empty
  - getDRIVER_EXCLUDEs
```
public Iterator<String> getDRIVER_EXCLUDEs()
```
    Return an iterator over the items in DRIVER_EXCLUDE
    
    Returns:
    
    an iterator over the items in DRIVER_EXCLUDE. The iterator may be empty.
  - isMETHOD_TO_PRINT
```
public boolean isMETHOD_TO_PRINT(String q)
```
    Has the given parameter been added to METHOD_TO_PRINT set of options?
    
    Parameters:
    
    q - the parameter
    
    Returns:
    
    true when the parameter has been added, false otherwise
  - fuzzyMatchMETHOD_TO_PRINT
```
public boolean fuzzyMatchMETHOD_TO_PRINT(String q)
```
    Does the given parameter appear within a set the String of one of the options?
    
    Parameters:
    
    q - the parameter to search for
    
    Returns:
    
    true when it does appear, false otherwise
  - hasMETHOD_TO_PRINT
```
public boolean hasMETHOD_TO_PRINT()
```
    Have any items been placed in the set METHOD_TO_PRINT?
    
    Returns:
    
    true if the set exists and is not empty
  - getMETHOD_TO_PRINTs
```
public Iterator<String> getMETHOD_TO_PRINTs()
```
    Return an iterator over the items in METHOD_TO_PRINT
    
    Returns:
    
    an iterator over the items in METHOD_TO_PRINT. The iterator may be empty.
  - clone
```
public Object clone()
             throws CloneNotSupportedException
```
    Overrides:
    
    clone in class Object
    
    Throws:
    
    CloneNotSupportedException
  - dup
```
public OptOptions dup()
```
  - processAsOption
```
public boolean processAsOption(String prefix,
                               String arg)
```
    Take a string (most likely a command-line argument) and try to proccess it as an option command. Return true if the string was understood, false otherwise.
    
    Parameters:
    
    prefix - a Sring to use as a command prefix when printing help.
    
    arg - a String to try to process as an option command
    
    Returns:
    
    true if successful, false otherwise
  - printHelp
```
public static void printHelp(String prefix)
```
    Prints a short description of every option
    
    Parameters:
    
    prefix - the prefix for the option
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a String representing the options values
  - printOptions
```
public void printOptions()
```
    print a String value of this options object
  - instanceProcessAsOption
```
private boolean instanceProcessAsOption(String arg)
```
  - instancePrintHelpHeader
```
private static void instancePrintHelpHeader(String prefix)
```
  - instancePrintHelpFooter
```
private static void instancePrintHelpFooter(String prefix)
```
  - getOptLevel
```
public int getOptLevel()
```
    Gets the current opt level.
    
    Returns:
    
    the current opt level
  - setOptLevel
```
public void setOptLevel(int level)
```
    Set the options to encode the optimizations enabled at the given opt label and disabled all optimizations that are not enabled at the given opt label
    
    Parameters:
    
    level - optimization level, must be at least 0

Class OptOptions

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

OPTIMIZATION_LEVEL

FREQ_FOCUS_EFFORT

READS_KILL

FIELD_ANALYSIS

INLINE

INLINE_GUARDED

INLINE_GUARDED_INTERFACES

INLINE_PREEX

SIMPLIFY_INTEGER_OPS

SIMPLIFY_LONG_OPS

SIMPLIFY_FLOAT_OPS

SIMPLIFY_DOUBLE_OPS

SIMPLIFY_REF_OPS

SIMPLIFY_TIB_OPS

SIMPLIFY_FIELD_OPS

SIMPLIFY_CHASE_FINAL_FIELDS

LOCAL_CONSTANT_PROP

LOCAL_COPY_PROP

LOCAL_CSE

LOCAL_EXPRESSION_FOLDING

CONTROL_STATIC_SPLITTING

CONTROL_TURN_WHILES_INTO_UNTILS

ESCAPE_SIMPLE_IPA

ESCAPE_SCALAR_REPLACE_AGGREGATES

ESCAPE_MONITOR_REMOVAL

ESCAPE_INVOKEE_THREAD_LOCAL

SSA

SSA_EXPRESSION_FOLDING

SSA_REDUNDANT_BRANCH_ELIMINATION

SSA_LICM_IGNORE_PEI

SSA_LOAD_ELIMINATION

SSA_COALESCE_AFTER

SSA_LOOP_VERSIONING

SSA_LIVE_RANGE_SPLITTING

SSA_GCP

SSA_GCSE

SSA_SPLITBLOCK_TO_AVOID_RENAME

SSA_SPLITBLOCK_FOR_LOCAL_LIVE

SSA_SPLITBLOCK_INTO_INFREQUENT

REORDER_CODE

REORDER_CODE_PH

H2L_INLINE_NEW

H2L_INLINE_WRITE_BARRIER

H2L_INLINE_PRIMITIVE_WRITE_BARRIER

H2L_NO_CALLEE_EXCEPTIONS

H2L_CALL_VIA_JTOC

L2M_HANDLER_LIVENESS

REGALLOC_COALESCE_MOVES

REGALLOC_COALESCE_SPILLS

ADAPTIVE_INSTRUMENTATION_SAMPLING

ADAPTIVE_NO_DUPLICATION

ADAPTIVE_PROCESSOR_SPECIFIC_COUNTER

ADAPTIVE_REMOVE_YP_FROM_CHECKING

OSR_GUARDED_INLINING

OSR_INLINE_POLICY

PRINT_STATIC_STATS

PRINT_PHASES

PRINT_ALL_IR

PRINT_DETAILED_INLINE_REPORT

PRINT_INLINE_REPORT

PRINT_DOMINATORS

PRINT_POST_DOMINATORS

PRINT_SSA

PRINT_DG_BURS

PRINT_VISUALIZATION

PRINT_HIGH

PRINT_FINAL_HIR

PRINT_LOW

PRINT_FINAL_LIR

PRINT_MIR

PRINT_FINAL_MIR

PRINT_CFG

PRINT_REGALLOC

PRINT_CALLING_CONVENTIONS