com.oracle.graal.lir.gen

Interface LIRGeneratorTool

All Superinterfaces:

ArithmeticLIRGenerator, BenchmarkCounterFactory

All Known Subinterfaces:

HotSpotLIRGenerator

All Known Implementing Classes:

AMD64HotSpotLIRGenerator, AMD64LIRGenerator, LIRGenerator, SPARCHotSpotLIRGenerator, SPARCLIRGenerator

public interface LIRGeneratorTool
extends ArithmeticLIRGenerator, BenchmarkCounterFactory

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LIRGeneratorTool.BlockScope
static interface	LIRGeneratorTool.SpillMoveFactory Factory for creating spill moves.

Method Summary

Modifier and Type	Method and Description
<I extends LIRInstruction> I	append(I op)
AllocatableValue	asAllocatable(Value value)
RegisterAttributes	attributes(Register register)
void	beforeRegisterAllocation() Called just before register allocation is performed on the LIR owned by this generator.
Variable	emitAddress(StackSlotValue slot)
Variable	emitArrayEquals(Kind kind, Value array1, Value array2, Value length)
default Value	emitAtomicReadAndAdd(Value address, Value delta) Emit an atomic read-and-add instruction.
default Value	emitAtomicReadAndWrite(Value address, Value newValue) Emit an atomic read-and-write instruction.
Variable	emitBitCount(Value operand)
Variable	emitBitScanForward(Value operand)
Variable	emitBitScanReverse(Value operand)
void	emitBlackhole(Value operand)
Variable	emitByteSwap(Value operand)
Variable	emitCompareAndSwap(Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue)
void	emitCompareBranch(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability)
Variable	emitConditionalMove(PlatformKind cmpKind, Value leftVal, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue)
default Value	emitCountLeadingZeros(Value value)
default Value	emitCountTrailingZeros(Value value)
void	emitData(AllocatableValue dst, byte[] data) Emits an op that loads the address of some raw data.
void	emitDeoptimize(Value actionAndReason, Value failedSpeculation, LIRFrameState state)
Variable	emitForeignCall(ForeignCallLinkage linkage, LIRFrameState state, Value... args)
void	emitIncomingValues(Value[] params)
void	emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueSuccessorProbability)
Variable	emitIntegerTestMove(Value leftVal, Value right, Value trueValue, Value falseValue)
void	emitJump(LabelRef label)
Variable	emitLoad(LIRKind kind, Value address, LIRFrameState state)
Value	emitLoadConstant(LIRKind kind, Constant constant)
void	emitMembar(int barriers)
void	emitMove(AllocatableValue dst, Value src)
Variable	emitMove(Value input)
void	emitNullCheck(Value address, LIRFrameState state)
void	emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpKind, double overflowProbability)
void	emitReturn(Value input) Emits a return instruction.
void	emitStore(LIRKind kind, Value address, Value input, LIRFrameState state)
void	emitStrategySwitch(JavaConstant[] keyConstants, double[] keyProbabilities, LabelRef[] keyTargets, LabelRef defaultTarget, Variable value)
void	emitStrategySwitch(SwitchStrategy strategy, Variable key, LabelRef[] keyTargets, LabelRef defaultTarget)
void	emitUnwind(Value operand)
LIRGeneratorTool.BlockScope	getBlockScope(AbstractBlockBase<?> block)
CallingConvention	getCallingConvention()
CodeCacheProvider	getCodeCache()
AbstractBlockBase<?>	getCurrentBlock()
ForeignCallsProvider	getForeignCalls()
MetaAccessProvider	getMetaAccess()
CodeGenProviders	getProviders()
LIRGenerationResult	getResult()
LIRGeneratorTool.SpillMoveFactory	getSpillMoveFactory()
boolean	hasBlockEnd(AbstractBlockBase<?> block)
Variable	load(Value value)
Value	loadNonConst(Value value)
boolean	needOnlyOopMaps() Determines if only oop maps are required for the code generated from the LIR.
Variable	newVariable(LIRKind kind) Create a new Variable.
AllocatableValue	resultOperandFor(LIRKind kind) Gets the ABI specific operand used to return a value of a given kind from a method.
TargetDescription	target()

Methods inherited from interface com.oracle.graal.lir.gen.ArithmeticLIRGenerator

emitAdd, emitAnd, emitDiv, emitFloatConvert, emitMathAbs, emitMathSqrt, emitMul, emitMulHigh, emitNarrow, emitNegate, emitNot, emitOr, emitReinterpret, emitRem, emitShl, emitShr, emitSignExtend, emitSub, emitUDiv, emitUMulHigh, emitURem, emitUShr, emitXor, emitZeroExtend, getLIRKind

Methods inherited from interface com.oracle.graal.lir.gen.BenchmarkCounterFactory

createBenchmarkCounter, createMultiBenchmarkCounter

Method Detail

getProviders

CodeGenProviders getProviders()

target

TargetDescription target()

getMetaAccess

MetaAccessProvider getMetaAccess()

getCodeCache

CodeCacheProvider getCodeCache()

getForeignCalls

ForeignCallsProvider getForeignCalls()

getCurrentBlock

AbstractBlockBase<?> getCurrentBlock()

getResult

LIRGenerationResult getResult()

hasBlockEnd

boolean hasBlockEnd(AbstractBlockBase<?> block)

getSpillMoveFactory

LIRGeneratorTool.SpillMoveFactory getSpillMoveFactory()

getBlockScope

LIRGeneratorTool.BlockScope getBlockScope(AbstractBlockBase<?> block)

emitLoadConstant

Value emitLoadConstant(LIRKind kind,
                       Constant constant)

emitLoad

Variable emitLoad(LIRKind kind,
                  Value address,
                  LIRFrameState state)

emitStore

void emitStore(LIRKind kind,
               Value address,
               Value input,
               LIRFrameState state)

emitNullCheck

void emitNullCheck(Value address,
                   LIRFrameState state)

emitCompareAndSwap

Variable emitCompareAndSwap(Value address,
                            Value expectedValue,
                            Value newValue,
                            Value trueValue,
                            Value falseValue)

emitAtomicReadAndAdd

default Value emitAtomicReadAndAdd(Value address,
                                   Value delta)

Emit an atomic read-and-add instruction.

Parameters:

address - address of the value to be read and written

delta - the value to be added

emitAtomicReadAndWrite

default Value emitAtomicReadAndWrite(Value address,
                                     Value newValue)

Emit an atomic read-and-write instruction.

Parameters:

address - address of the value to be read and written

newValue - the new value to be written

emitDeoptimize

void emitDeoptimize(Value actionAndReason,
                    Value failedSpeculation,
                    LIRFrameState state)

emitForeignCall

Variable emitForeignCall(ForeignCallLinkage linkage,
                         LIRFrameState state,
                         Value... args)

attributes

RegisterAttributes attributes(Register register)

newVariable

Variable newVariable(LIRKind kind)

Create a new Variable.

Parameters:

kind - The type of the value that will be stored in this Variable. See LIRKind for documentation on what to pass here. Note that in most cases, simply passing Value.getLIRKind() is wrong.

Returns:

A new Variable.

emitMove

Variable emitMove(Value input)

emitMove

void emitMove(AllocatableValue dst,
              Value src)

emitData

void emitData(AllocatableValue dst,
              byte[] data)

Emits an op that loads the address of some raw data.

Parameters:

dst - the variable into which the address is loaded

data - the data to be installed with the generated code

emitAddress

Variable emitAddress(StackSlotValue slot)

emitMembar

void emitMembar(int barriers)

emitUnwind

void emitUnwind(Value operand)

beforeRegisterAllocation

void beforeRegisterAllocation()

Called just before register allocation is performed on the LIR owned by this generator. Overriding implementations of this method must call the overridden method.

emitIncomingValues

void emitIncomingValues(Value[] params)

emitReturn

void emitReturn(Value input)

Emits a return instruction. Implementations need to insert a move if the input is not in the correct location.

asAllocatable

AllocatableValue asAllocatable(Value value)

load

Variable load(Value value)

loadNonConst

Value loadNonConst(Value value)

needOnlyOopMaps

boolean needOnlyOopMaps()

Determines if only oop maps are required for the code generated from the LIR.

resultOperandFor

AllocatableValue resultOperandFor(LIRKind kind)

Gets the ABI specific operand used to return a value of a given kind from a method.

Parameters:

kind - the kind of value being returned

Returns:

the operand representing the ABI defined location used return a value of kind kind

append

<I extends LIRInstruction> I append(I op)

emitJump

void emitJump(LabelRef label)

emitCompareBranch

void emitCompareBranch(PlatformKind cmpKind,
                       Value left,
                       Value right,
                       Condition cond,
                       boolean unorderedIsTrue,
                       LabelRef trueDestination,
                       LabelRef falseDestination,
                       double trueDestinationProbability)

emitOverflowCheckBranch

void emitOverflowCheckBranch(LabelRef overflow,
                             LabelRef noOverflow,
                             LIRKind cmpKind,
                             double overflowProbability)

emitIntegerTestBranch

void emitIntegerTestBranch(Value left,
                           Value right,
                           LabelRef trueDestination,
                           LabelRef falseDestination,
                           double trueSuccessorProbability)

emitConditionalMove

Variable emitConditionalMove(PlatformKind cmpKind,
                             Value leftVal,
                             Value right,
                             Condition cond,
                             boolean unorderedIsTrue,
                             Value trueValue,
                             Value falseValue)

emitIntegerTestMove

Variable emitIntegerTestMove(Value leftVal,
                             Value right,
                             Value trueValue,
                             Value falseValue)

emitStrategySwitch

void emitStrategySwitch(JavaConstant[] keyConstants,
                        double[] keyProbabilities,
                        LabelRef[] keyTargets,
                        LabelRef defaultTarget,
                        Variable value)

emitStrategySwitch

void emitStrategySwitch(SwitchStrategy strategy,
                        Variable key,
                        LabelRef[] keyTargets,
                        LabelRef defaultTarget)

getCallingConvention

CallingConvention getCallingConvention()

emitBitCount

Variable emitBitCount(Value operand)

emitBitScanForward

Variable emitBitScanForward(Value operand)

emitBitScanReverse

Variable emitBitScanReverse(Value operand)

emitByteSwap

Variable emitByteSwap(Value operand)

emitArrayEquals

Variable emitArrayEquals(Kind kind,
                         Value array1,
                         Value array2,
                         Value length)

emitBlackhole

void emitBlackhole(Value operand)

emitCountLeadingZeros

default Value emitCountLeadingZeros(Value value)

emitCountTrailingZeros

default Value emitCountTrailingZeros(Value value)