com.oracle.graal.lir.gen

Class LIRGenerator

java.lang.Object

com.oracle.graal.lir.gen.LIRGenerator

All Implemented Interfaces:

ArithmeticLIRGenerator, BenchmarkCounterFactory, LIRGeneratorTool

Direct Known Subclasses:

AMD64LIRGenerator, SPARCLIRGenerator

public abstract class LIRGenerator
extends Object
implements LIRGeneratorTool

This class traverses the HIR instructions and generates LIR instructions from them.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	LIRGenerator.BlockScopeImpl
static class	LIRGenerator.Options

Nested classes/interfaces inherited from interface com.oracle.graal.lir.gen.LIRGeneratorTool

LIRGeneratorTool.BlockScope, LIRGeneratorTool.SpillMoveFactory

Field Summary

Fields

Modifier and Type	Field and Description
private CallingConvention	cc
private AbstractBlockBase<?>	currentBlock
private LIRKindTool	lirKindTool
private CodeGenProviders	providers
private LIRGenerationResult	res

Constructor Summary

Constructors

Constructor and Description
LIRGenerator(LIRKindTool lirKindTool, CodeGenProviders providers, CallingConvention cc, LIRGenerationResult res)

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.
protected abstract boolean	canInlineConstant(JavaConstant c) Checks whether the supplied constant can be used without loading it into a register for most operations, i.e., for commonly used arithmetic, logical, and comparison operations.
LIRInstruction	createBenchmarkCounter(String name, String group, Value increment)
LIRInstruction	createMultiBenchmarkCounter(String[] names, String[] groups, Value[] increments)
protected abstract Variable	emitAdd(LIRKind resultKind, Value a, Value b, boolean setFlags)
Variable	emitAdd(Value aVal, Value bVal, boolean setFlags)
void	emitBlackhole(Value operand)
abstract void	emitCompareBranch(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability)
abstract Variable	emitConditionalMove(PlatformKind cmpKind, Value leftVal, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue)
Variable	emitForeignCall(ForeignCallLinkage linkage, LIRFrameState frameState, Value... args)
protected abstract void	emitForeignCallOp(ForeignCallLinkage linkage, Value result, Value[] arguments, Value[] temps, LIRFrameState info) Emits the single call operation at the heart of generating LIR for a foreign call.
void	emitIncomingValues(Value[] params)
abstract void	emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueSuccessorProbability)
abstract Variable	emitIntegerTestMove(Value leftVal, Value right, Value trueValue, Value falseValue)
abstract void	emitJump(LabelRef label)
Value	emitLoadConstant(LIRKind kind, Constant constant)
Variable	emitMove(Value input)
abstract void	emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpKind, double overflowProbability)
void	emitStrategySwitch(JavaConstant[] keyConstants, double[] keyProbabilities, LabelRef[] keyTargets, LabelRef defaultTarget, Variable value)
abstract void	emitStrategySwitch(SwitchStrategy strategy, Variable key, LabelRef[] keyTargets, LabelRef defaultTarget)
protected abstract Variable	emitSub(LIRKind resultKind, Value a, Value b, boolean setFlags)
Variable	emitSub(Value aVal, Value bVal, boolean setFlags)
protected abstract void	emitTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, Value key)
protected LIRKind	getAddressKind(Value base, long displacement, Value index)
LIRGeneratorTool.BlockScope	getBlockScope(AbstractBlockBase<?> block)
CallingConvention	getCallingConvention()
CodeCacheProvider	getCodeCache()
AbstractBlockBase<?>	getCurrentBlock()
ForeignCallsProvider	getForeignCalls()
LIRKind	getLIRKind(Stamp stamp)
protected LIRKindTool	getLIRKindTool()
MetaAccessProvider	getMetaAccess()
CodeGenProviders	getProviders()
LIRGenerationResult	getResult()
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 lirKind) 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()
static AllocatableValue	toStackKind(AllocatableValue value)
protected JavaConstant	zapValueForKind(PlatformKind kind) Gets a garbage value for a given kind.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

emitAddress, emitArrayEquals, emitAtomicReadAndAdd, emitAtomicReadAndWrite, emitBitCount, emitBitScanForward, emitBitScanReverse, emitByteSwap, emitCompareAndSwap, emitCountLeadingZeros, emitCountTrailingZeros, emitData, emitDeoptimize, emitLoad, emitMembar, emitMove, emitNullCheck, emitReturn, emitStore, emitUnwind, getSpillMoveFactory

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

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

Field Detail

lirKindTool

private final LIRKindTool lirKindTool

providers

private final CodeGenProviders providers

cc

private final CallingConvention cc

currentBlock

private AbstractBlockBase<?> currentBlock

res

private LIRGenerationResult res

Constructor Detail

LIRGenerator

public LIRGenerator(LIRKindTool lirKindTool,
                    CodeGenProviders providers,
                    CallingConvention cc,
                    LIRGenerationResult res)

Method Detail

target

public TargetDescription target()

Specified by:

target in interface LIRGeneratorTool

getProviders

public CodeGenProviders getProviders()

Specified by:

getProviders in interface LIRGeneratorTool

getMetaAccess

public MetaAccessProvider getMetaAccess()

Specified by:

getMetaAccess in interface LIRGeneratorTool

getCodeCache

public CodeCacheProvider getCodeCache()

Specified by:

getCodeCache in interface LIRGeneratorTool

getForeignCalls

public ForeignCallsProvider getForeignCalls()

Specified by:

getForeignCalls in interface LIRGeneratorTool

getLIRKindTool

protected LIRKindTool getLIRKindTool()

newVariable

public Variable newVariable(LIRKind lirKind)

Description copied from interface: LIRGeneratorTool

Create a new Variable.

Specified by:

newVariable in interface LIRGeneratorTool

Parameters:

lirKind - 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.

attributes

public RegisterAttributes attributes(Register register)

Specified by:

attributes in interface LIRGeneratorTool

emitMove

public Variable emitMove(Value input)

Specified by:

emitMove in interface LIRGeneratorTool

emitLoadConstant

public Value emitLoadConstant(LIRKind kind,
                              Constant constant)

Specified by:

emitLoadConstant in interface LIRGeneratorTool

asAllocatable

public AllocatableValue asAllocatable(Value value)

Specified by:

asAllocatable in interface LIRGeneratorTool

load

public Variable load(Value value)

Specified by:

load in interface LIRGeneratorTool

canInlineConstant

protected abstract boolean canInlineConstant(JavaConstant c)

Checks whether the supplied constant can be used without loading it into a register for most operations, i.e., for commonly used arithmetic, logical, and comparison operations.

Parameters:

c - The constant to check.

Returns:

True if the constant can be used directly, false if the constant needs to be in a register.

loadNonConst

public Value loadNonConst(Value value)

Specified by:

loadNonConst in interface LIRGeneratorTool

needOnlyOopMaps

public boolean needOnlyOopMaps()

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

Specified by:

needOnlyOopMaps in interface LIRGeneratorTool

resultOperandFor

public AllocatableValue resultOperandFor(LIRKind kind)

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

Specified by:

resultOperandFor in interface LIRGeneratorTool

Parameters:

kind - the kind of value being returned

Returns:

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

append

public <I extends LIRInstruction> I append(I op)

Specified by:

append in interface LIRGeneratorTool

hasBlockEnd

public boolean hasBlockEnd(AbstractBlockBase<?> block)

Specified by:

hasBlockEnd in interface LIRGeneratorTool

getBlockScope

public final LIRGeneratorTool.BlockScope getBlockScope(AbstractBlockBase<?> block)

Specified by:

getBlockScope in interface LIRGeneratorTool

emitIncomingValues

public void emitIncomingValues(Value[] params)

Specified by:

emitIncomingValues in interface LIRGeneratorTool

emitJump

public abstract void emitJump(LabelRef label)

Specified by:

emitJump in interface LIRGeneratorTool

emitCompareBranch

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

Specified by:

emitCompareBranch in interface LIRGeneratorTool

emitOverflowCheckBranch

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

Specified by:

emitOverflowCheckBranch in interface LIRGeneratorTool

emitIntegerTestBranch

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

Specified by:

emitIntegerTestBranch in interface LIRGeneratorTool

emitConditionalMove

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

Specified by:

emitConditionalMove in interface LIRGeneratorTool

emitIntegerTestMove

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

Specified by:

emitIntegerTestMove in interface LIRGeneratorTool

emitForeignCallOp

protected abstract void emitForeignCallOp(ForeignCallLinkage linkage,
                                          Value result,
                                          Value[] arguments,
                                          Value[] temps,
                                          LIRFrameState info)

Emits the single call operation at the heart of generating LIR for a foreign call.

toStackKind

public static AllocatableValue toStackKind(AllocatableValue value)

emitForeignCall

public Variable emitForeignCall(ForeignCallLinkage linkage,
                                LIRFrameState frameState,
                                Value... args)

Specified by:

emitForeignCall in interface LIRGeneratorTool

emitStrategySwitch

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

Specified by:

emitStrategySwitch in interface LIRGeneratorTool

emitStrategySwitch

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

Specified by:

emitStrategySwitch in interface LIRGeneratorTool

emitTableSwitch

protected abstract void emitTableSwitch(int lowKey,
                                        LabelRef defaultTarget,
                                        LabelRef[] targets,
                                        Value key)

getCallingConvention

public CallingConvention getCallingConvention()

Specified by:

getCallingConvention in interface LIRGeneratorTool

beforeRegisterAllocation

public void beforeRegisterAllocation()

Description copied from interface: LIRGeneratorTool

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

Specified by:

beforeRegisterAllocation in interface LIRGeneratorTool

zapValueForKind

protected JavaConstant zapValueForKind(PlatformKind kind)

Gets a garbage value for a given kind.

getLIRKind

public LIRKind getLIRKind(Stamp stamp)

Specified by:

getLIRKind in interface ArithmeticLIRGenerator

getAddressKind

protected LIRKind getAddressKind(Value base,
                                 long displacement,
                                 Value index)

getCurrentBlock

public AbstractBlockBase<?> getCurrentBlock()

Specified by:

getCurrentBlock in interface LIRGeneratorTool

getResult

public LIRGenerationResult getResult()

Specified by:

getResult in interface LIRGeneratorTool

emitBlackhole

public void emitBlackhole(Value operand)

Specified by:

emitBlackhole in interface LIRGeneratorTool

createBenchmarkCounter

public LIRInstruction createBenchmarkCounter(String name,
                                             String group,
                                             Value increment)

Specified by:

createBenchmarkCounter in interface BenchmarkCounterFactory

createMultiBenchmarkCounter

public LIRInstruction createMultiBenchmarkCounter(String[] names,
                                                  String[] groups,
                                                  Value[] increments)

Specified by:

createMultiBenchmarkCounter in interface BenchmarkCounterFactory

emitAdd

protected abstract Variable emitAdd(LIRKind resultKind,
                                    Value a,
                                    Value b,
                                    boolean setFlags)

emitAdd

public final Variable emitAdd(Value aVal,
                              Value bVal,
                              boolean setFlags)

Specified by:

emitAdd in interface ArithmeticLIRGenerator

emitSub

protected abstract Variable emitSub(LIRKind resultKind,
                                    Value a,
                                    Value b,
                                    boolean setFlags)

emitSub

public final Variable emitSub(Value aVal,
                              Value bVal,
                              boolean setFlags)

Specified by:

emitSub in interface ArithmeticLIRGenerator