GraalDirectives

java.lang.Object
- org.graalvm.compiler.api.directives.GraalDirectives

```
public final class GraalDirectives
extends Object
```
Directives that influence the compilation of methods by Graal. They don't influence the semantics of the code, but they are useful for unit testing and benchmarking. Any methods defined in this class should be intrinsified via invocation plugins.

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`FASTPATH_PROBABILITY`
`static double`	`LIKELY_PROBABILITY`
`static double`	`SLOWPATH_PROBABILITY`
`static double`	`UNLIKELY_PROBABILITY`

Constructor Summary

Constructors
Constructor and Description

GraalDirectives()

Constructors
Constructor and Description
`GraalDirectives()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> T`	`assumeStableDimension(T t, int i)` A call to this method will assume a stable dimension array if `t` is a constant array and `i` a constant integer.
`static void`	`bindToRegister(boolean value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(byte value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(char value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(double value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(float value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(int value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(long value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(Object value)` Forces a value to be kept in a register.
`static void`	`bindToRegister(short value)` Forces a value to be kept in a register.
`static void`	`blackhole(boolean value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(byte value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(char value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(double value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(float value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(int value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(long value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(Object value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(short value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`breakpoint()` Raise a SIGTRAP that can be used as a breakpoint for a native debugger such as gdb.
`static void`	`controlFlowAnchor()` A call to this method will never be duplicated by control flow optimizations in the compiler.
`static void`	`deoptimize()` Directive for the compiler to fall back to the bytecode interpreter at this point.
`static void`	`deoptimize(DeoptimizationAction action, DeoptimizationReason reason, boolean withSpeculation)` Directive for the compiler to fall back to the bytecode interpreter at this point.
`static void`	`deoptimize(DeoptimizationAction action, DeoptimizationReason reason, SpeculationReason speculation)` Directive for the compiler to fall back to the bytecode interpreter at this point.
`static void`	`deoptimizeAndInvalidate()` Directive for the compiler to fall back to the bytecode interpreter at this point.
`static void`	`ensureVirtualized(Object object)` Ensures that the given object will be virtual (escape analyzed) at all points that are dominated by the current position.
`static void`	`ensureVirtualizedHere(Object object)` Ensures that the given object will be virtual at the current position.
`static <T> T`	`guardingNonNull(T value)`
`static boolean`	`inCompiledCode()` Returns a boolean value indicating whether the method is executed in Graal-compiled code.
`static boolean`	`inIntrinsic()` Determines if the method is called within the scope of a Graal intrinsic.
`static boolean`	`injectBranchProbability(double probability, boolean condition)` Injects a probability for the given condition into the profiling information of a branch instruction.
`static boolean`	`injectIterationCount(double iterations, boolean condition)` Injects an average iteration count of a loop into the probability information of a loop exit condition.
`static boolean`	`isCompilationConstant(boolean value)`
`static boolean`	`isCompilationConstant(byte value)`
`static boolean`	`isCompilationConstant(char value)`
`static boolean`	`isCompilationConstant(double value)`
`static boolean`	`isCompilationConstant(float value)`
`static boolean`	`isCompilationConstant(int value)`
`static boolean`	`isCompilationConstant(long value)`
`static boolean`	`isCompilationConstant(Object value)` Returns a boolean indicating whether or not a given value is seen as constant in optimized code.
`static boolean`	`isCompilationConstant(short value)`
`static void`	`log(String value)` Prints a string to the log stream.
`static void`	`log(String format, long value)` Prints a formatted string to the log stream.
`static void`	`log(String format, long v1, long v2)` Prints a formatted string to the log stream.
`static void`	`log(String format, long v1, long v2, long v3)` Prints a formatted string to the log stream.
`static void`	`neverStripMine()` A call to this method will disable strip mining of the enclosing loop in the compiler.
`static boolean`	`opaque(boolean value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static byte`	`opaque(byte value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static char`	`opaque(char value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static double`	`opaque(double value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static float`	`opaque(float value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static int`	`opaque(int value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static long`	`opaque(long value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static short`	`opaque(short value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static <T> T`	`opaque(T value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static void`	`sideEffect()` A call to this method will force the compiler to assume this instruction has a visible memory effect killing all memory locations.
`static int`	`sideEffect(int a)` A call to this method will force the compiler to assume this instruction has a visible memory effect killing all memory locations.
`static long`	`sideEffect(long a)` A call to this method will force the compiler to assume this instruction has a visible memory effect killing all memory locations.
`static void`	`spillRegisters()` Spills all caller saved registers.
`static <P> P`	`trustedBox(P o)` Inject information into the compiler to assume that the input is an object created via a primitive boxing operation.

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

- Field Detail
  - LIKELY_PROBABILITY
```
public static final double LIKELY_PROBABILITY
```
    See Also:
    
    Constant Field Values
  - UNLIKELY_PROBABILITY
```
public static final double UNLIKELY_PROBABILITY
```
    See Also:
    
    Constant Field Values
  - SLOWPATH_PROBABILITY
```
public static final double SLOWPATH_PROBABILITY
```
    See Also:
    
    Constant Field Values
  - FASTPATH_PROBABILITY
```
public static final double FASTPATH_PROBABILITY
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - GraalDirectives
```
public GraalDirectives()
```
- Method Detail
  - deoptimize
```
public static void deoptimize(DeoptimizationAction action,
                              DeoptimizationReason reason,
                              SpeculationReason speculation)
```
    Directive for the compiler to fall back to the bytecode interpreter at this point. All arguments to this method must be compile-time constant.
    
    Parameters:
    
    action - the action to take with respect to the code being deoptimized
    
    reason - the reason to use for the deoptimization
    
    speculation - a speculation to be attached to the deoptimization
  - deoptimize
```
public static void deoptimize(DeoptimizationAction action,
                              DeoptimizationReason reason,
                              boolean withSpeculation)
```
    Directive for the compiler to fall back to the bytecode interpreter at this point. All arguments to this method must be compile-time constant.
    
    Parameters:
    
    action - the action to take with respect to the code being deoptimized
    
    reason - the reason to use for the deoptimization
    
    withSpeculation - if true, then a speculation will be attached to the deoptimization
  - deoptimize
```
public static void deoptimize()
```
    Directive for the compiler to fall back to the bytecode interpreter at this point. This is equivalent to calling GraalDirectives.deoptimize(DeoptimizationAction, DeoptimizationReason, boolean) with DeoptimizationAction.None, DeoptimizationReason.TransferToInterpreter and false as arguments.
  - deoptimizeAndInvalidate
```
public static void deoptimizeAndInvalidate()
```
    Directive for the compiler to fall back to the bytecode interpreter at this point. This is equivalent to calling GraalDirectives.deoptimize(DeoptimizationAction, DeoptimizationReason, boolean) with DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TransferToInterpreter and false as arguments.
  - inCompiledCode
```
public static boolean inCompiledCode()
```
    Returns a boolean value indicating whether the method is executed in Graal-compiled code.
  - inIntrinsic
```
public static boolean inIntrinsic()
```
    Determines if the method is called within the scope of a Graal intrinsic.
  - controlFlowAnchor
```
public static void controlFlowAnchor()
```
    A call to this method will never be duplicated by control flow optimizations in the compiler.
  - neverStripMine
```
public static void neverStripMine()
```
    A call to this method will disable strip mining of the enclosing loop in the compiler.
  - assumeStableDimension
```
public static <T> T assumeStableDimension(T t,
                                          int i)
```
    A call to this method will assume a stable dimension array if t is a constant array and i a constant integer.
  - sideEffect
```
public static void sideEffect()
```
    A call to this method will force the compiler to assume this instruction has a visible memory effect killing all memory locations.
  - trustedBox
```
public static <P> P trustedBox(P o)
```
    Inject information into the compiler to assume that the input is an object created via a primitive boxing operation.
  - sideEffect
```
public static int sideEffect(int a)
```
    A call to this method will force the compiler to assume this instruction has a visible memory effect killing all memory locations.
  - sideEffect
```
public static long sideEffect(long a)
```
    A call to this method will force the compiler to assume this instruction has a visible memory effect killing all memory locations.
  - injectBranchProbability
```
public static boolean injectBranchProbability(double probability,
                                              boolean condition)
```
    Injects a probability for the given condition into the profiling information of a branch instruction. The probability must be a value between 0.0 and 1.0 (inclusive). Example usage (it specifies that the likelihood for a to be greater than b is 90%): if (injectBranchProbability(0.9, a > b)) { // ... } There are predefined constants for commonly used probabilities (see GraalDirectives.LIKELY_PROBABILITY , GraalDirectives.UNLIKELY_PROBABILITY, GraalDirectives.SLOWPATH_PROBABILITY, GraalDirectives.FASTPATH_PROBABILITY ).
    
    Parameters:
    
    probability - the probability value between 0.0 and 1.0 that should be injected
  - injectIterationCount
```
public static boolean injectIterationCount(double iterations,
                                           boolean condition)
```
    Injects an average iteration count of a loop into the probability information of a loop exit condition. The iteration count specifies how often the condition is checked, i.e. in for and while loops it is one more than the body iteration count, and in do-while loops it is equal to the body iteration count. The iteration count must be >= 1.0. Example usage (it specifies that the expected iteration count of the loop condition is 500, so the iteration count of the loop body is 499): for (int i = 0; injectIterationCount(500, i < array.length); i++) { // ... }
    
    Parameters:
    
    iterations - the expected number of iterations that should be injected
  - blackhole
```
public static void blackhole(boolean value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(byte value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(short value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(char value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(int value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(long value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(float value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(double value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(Object value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - bindToRegister
```
public static void bindToRegister(boolean value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(byte value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(short value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(char value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(int value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(long value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(float value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(double value)
```
    Forces a value to be kept in a register.
  - bindToRegister
```
public static void bindToRegister(Object value)
```
    Forces a value to be kept in a register.
  - spillRegisters
```
public static void spillRegisters()
```
    Spills all caller saved registers.
  - opaque
```
public static boolean opaque(boolean value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static byte opaque(byte value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static short opaque(short value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static char opaque(char value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static int opaque(int value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static long opaque(long value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static float opaque(float value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static double opaque(double value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static <T> T opaque(T value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - guardingNonNull
```
public static <T> T guardingNonNull(T value)
```
  - ensureVirtualized
```
public static void ensureVirtualized(Object object)
```
    Ensures that the given object will be virtual (escape analyzed) at all points that are dominated by the current position.
  - ensureVirtualizedHere
```
public static void ensureVirtualizedHere(Object object)
```
    Ensures that the given object will be virtual at the current position.
  - breakpoint
```
public static void breakpoint()
```
    Raise a SIGTRAP that can be used as a breakpoint for a native debugger such as gdb.
  - isCompilationConstant
```
public static boolean isCompilationConstant(Object value)
```
    Returns a boolean indicating whether or not a given value is seen as constant in optimized code.
  - isCompilationConstant
```
public static boolean isCompilationConstant(boolean value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(byte value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(short value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(char value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(int value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(float value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(long value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - isCompilationConstant
```
public static boolean isCompilationConstant(double value)
```
    See Also:
    
    GraalDirectives.isCompilationConstant(Object)
  - log
```
public static void log(String value)
```
    Prints a string to the log stream.
  - log
```
public static void log(String format,
                       long value)
```
    Prints a formatted string to the log stream.
    
    Parameters:
    
    format - a C style printf format value that can contain at most one conversion specifier (i.e., a sequence of characters starting with '%').
    
    value - the value associated with the conversion specifier
  - log
```
public static void log(String format,
                       long v1,
                       long v2)
```
    Prints a formatted string to the log stream.
    
    Parameters:
    
    format - a C style printf format value that can contain at most two conversion specifiers (i.e., a sequence of characters starting with '%').
    
    v1 - the value associated with the first conversion specifier
    
    v2 - the value associated with the second conversion specifier
  - log
```
public static void log(String format,
                       long v1,
                       long v2,
                       long v3)
```
    Prints a formatted string to the log stream.
    
    Parameters:
    
    format - a C style printf format value that can contain at most three conversion specifiers (i.e., a sequence of characters starting with '%').
    
    v1 - the value associated with the first conversion specifier
    
    v2 - the value associated with the second conversion specifier
    
    v3 - the value associated with the third conversion specifier

Class GraalDirectives

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LIKELY_PROBABILITY

UNLIKELY_PROBABILITY

SLOWPATH_PROBABILITY

FASTPATH_PROBABILITY

Constructor Detail

GraalDirectives

Method Detail

deoptimize

deoptimize

deoptimize

deoptimizeAndInvalidate

inCompiledCode

inIntrinsic

controlFlowAnchor

neverStripMine

assumeStableDimension

sideEffect

trustedBox

sideEffect

sideEffect

injectBranchProbability

injectIterationCount

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

bindToRegister

bindToRegister

bindToRegister

bindToRegister

bindToRegister

bindToRegister

bindToRegister

bindToRegister

bindToRegister

spillRegisters

opaque

opaque

opaque

opaque

opaque

opaque

opaque

opaque

opaque

guardingNonNull

ensureVirtualized

ensureVirtualizedHere

breakpoint

isCompilationConstant

isCompilationConstant

isCompilationConstant

isCompilationConstant

isCompilationConstant

isCompilationConstant

isCompilationConstant

isCompilationConstant

isCompilationConstant

log

log

log

log