org.graalvm.compiler.lir.gen

Class LIRGenerator

java.lang.Object

org.graalvm.compiler.lir.gen.LIRGenerator

All Implemented Interfaces:

DiagnosticLIRGeneratorTool, LIRGeneratorTool

Direct Known Subclasses:

AArch64LIRGenerator, AMD64LIRGenerator

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
static class	LIRGenerator.Options
static class	LIRGenerator.VariableProvider Hide LIRGenerator.VariableProvider.nextVariable() from other users.

Nested classes/interfaces inherited from interface org.graalvm.compiler.lir.gen.LIRGeneratorTool

LIRGeneratorTool.BlockScope, LIRGeneratorTool.CharsetName

Nested classes/interfaces inherited from interface org.graalvm.compiler.lir.gen.DiagnosticLIRGeneratorTool

DiagnosticLIRGeneratorTool.ZapRegistersAfterInstruction, DiagnosticLIRGeneratorTool.ZapStackArgumentSpaceBeforeInstruction

Field Summary

Fields

Modifier and Type	Field and Description
protected ArithmeticLIRGenerator	arithmeticLIRGen

Constructor Summary

Constructors

Constructor and Description
LIRGenerator(LIRKindTool lirKindTool, ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, CodeGenProviders providers, LIRGenerationResult res)

Method Summary

Modifier and Type	Method and Description
<I extends LIRInstruction> I	append(I op)
AllocatableValue	asAllocatable(Value value) Returns an AllocatableValue holding the value by moving it if necessary.
RegisterAttributes	attributes(Register register)
void	beforeRegisterAllocation() Called just before register allocation is performed on the LIR owned by this generator.
boolean	canInlineConstant(Constant constant)
LIRInstruction	createBenchmarkCounter(String name, String group, Value increment)
LIRInstruction	createMultiBenchmarkCounter(String[] names, String[] groups, Value[] increments)
abstract LIRInstruction	createZapArgumentSpace(StackSlot[] zappedStack, JavaConstant[] zapValues)
LIRInstruction	createZapRegisters() Creates an instruction that fills all allocatable registers with a known garbage value.
LIRInstruction	createZapRegisters(Register[] zappedRegisters) Creates an instruction that fills a given set of registers with a known garbage value.
abstract LIRInstruction	createZapRegisters(Register[] zappedRegisters, JavaConstant[] zapValues) Creates an instruction that fills a given set of registers with a known garbage value.
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)
Value	emitConstant(LIRKind kind, Constant constant)
Variable	emitForeignCall(ForeignCallLinkage linkage, LIRFrameState frameState, Value... args)
protected abstract void	emitForeignCallOp(ForeignCallLinkage linkage, Value targetAddress, Value result, Value[] arguments, Value[] temps, LIRFrameState info) Emits the single call operation at the heart of generating LIR for a foreign call.
protected abstract void	emitHashTableSwitch(JavaConstant[] keys, LabelRef defaultTarget, LabelRef[] targets, AllocatableValue value, Value hash)
void	emitIncomingValues(Value[] params)
protected Value	emitIndirectForeignCallAddress(ForeignCallLinkage linkage) Loads the target address for indirect foreign calls.
abstract void	emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueSuccessorProbability)
abstract Variable	emitIntegerTestMove(Value leftVal, Value right, Value trueValue, Value falseValue)
Value	emitJavaConstant(JavaConstant constant)
abstract void	emitJump(LabelRef label)
AllocatableValue	emitLoadConstant(<any> kind, Constant constant)
void	emitMove(AllocatableValue dst, Value src)
Variable	emitMove(Value input)
void	emitMoveConstant(AllocatableValue dst, Constant src)
abstract void	emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpKind, double overflowProbability)
protected abstract void	emitRangeTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, AllocatableValue key)
Variable	emitReadRegister(Register register, <any> kind)
void	emitStrategySwitch(JavaConstant[] keyConstants, double[] keyProbabilities, LabelRef[] keyTargets, LabelRef defaultTarget, AllocatableValue value)
abstract void	emitStrategySwitch(SwitchStrategy strategy, AllocatableValue key, LabelRef[] keyTargets, LabelRef defaultTarget)
void	emitWriteRegister(Register dst, Value src, <any> kind)
protected LIRKind	getAddressKind(Value base, long displacement, Value index)
ArithmeticLIRGeneratorTool	getArithmetic()
LIRGeneratorTool.BlockScope	getBlockScope(AbstractBlockBase<?> block)
CodeCacheProvider	getCodeCache()
AbstractBlockBase<?>	getCurrentBlock()
ForeignCallsProvider	getForeignCalls()
LIRKind	getLIRKind(Stamp stamp)
LIRKindTool	getLIRKindTool()
DebugCloseable	getMatchScope(AbstractBlockBase<?> block)
MetaAccessProvider	getMetaAccess()
MoveFactory	getMoveFactory()
CodeGenProviders	getProviders()
RegisterConfig	getRegisterConfig()
LIRGenerationResult	getResult()
MoveFactory	getSpillMoveFactory() Get a special MoveFactory for spill moves.
LIRKind	getValueKind(JavaKind javaKind)
boolean	hasBlockEnd(AbstractBlockBase<?> block)
boolean	mayEmbedConstantLoad(Constant constant)
boolean	needOnlyOopMaps() Determines if only oop maps are required for the code generated from the LIR.
Variable	newVariable(<any> valueKind) Create a new Variable.
AllocatableValue	resultOperandFor(JavaKind javaKind, <any> valueKind) Gets the ABI specific operand used to return a value of a given kind from a method.
void	setSourcePosition(NodeSourcePosition position)
TargetDescription	target()
LIRInstruction	zapArgumentSpace()
protected abstract JavaConstant	zapValueForKind(PlatformKind kind) Gets a garbage value for a given kind.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.graalvm.compiler.lir.gen.LIRGeneratorTool

addressAsAllocatableInteger, allocateStackMemory, emitAddress, emitArrayCompareTo, emitArrayCopyWithConversion, emitArrayCopyWithConversion, emitArrayEquals, emitArrayEquals, emitArrayEquals, emitArrayEquals, emitArrayEquals, emitArrayEquals, emitArrayIndexOf, emitArrayRegionCompareTo, emitArrayRegionCompareTo, emitAtomicReadAndAdd, emitAtomicReadAndWrite, emitByteSwap, emitCacheWriteback, emitCacheWritebackSync, emitCalcStringAttributes, emitCompress, emitConvertNullToZero, emitConvertNullToZero, emitConvertZeroToNull, emitDeoptimize, emitEncodeArray, emitHasNegatives, emitLogicCompareAndSwap, emitMembar, emitNullCheck, emitPause, emitPrefetchAllocate, emitReadCallerStackPointer, emitReadReturnAddress, emitReturn, emitSpeculationFence, emitStringLatin1Inflate, emitStringUTF16Compress, emitTimeStampWithProcid, emitUncompress, emitUnwind, emitValueCompareAndSwap, emitZeroMemory, getMaxVectorSize, toRegisterKind

Field Detail

arithmeticLIRGen

protected final ArithmeticLIRGenerator arithmeticLIRGen

Constructor Detail

LIRGenerator

public LIRGenerator(LIRKindTool lirKindTool,
                    ArithmeticLIRGenerator arithmeticLIRGen,
                    MoveFactory moveFactory,
                    CodeGenProviders providers,
                    LIRGenerationResult res)

Method Detail

getArithmetic

public ArithmeticLIRGeneratorTool getArithmetic()

Specified by:

getArithmetic in interface LIRGeneratorTool

getMoveFactory

public MoveFactory getMoveFactory()

Specified by:

getMoveFactory in interface LIRGeneratorTool

getSpillMoveFactory

public MoveFactory getSpillMoveFactory()

Description copied from interface: LIRGeneratorTool

Get a special MoveFactory for spill moves. The instructions returned by this factory must only depend on the input values. References to values that require interaction with register allocation are strictly forbidden.

Specified by:

getSpillMoveFactory in interface LIRGeneratorTool

getValueKind

public LIRKind getValueKind(JavaKind javaKind)

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

public LIRKindTool getLIRKindTool()

newVariable

public Variable newVariable(<any> valueKind)

Description copied from interface: LIRGeneratorTool

Create a new Variable.

Specified by:

newVariable in interface LIRGeneratorTool

Parameters:

valueKind - 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.getValueKind() is wrong.

Returns:

A new Variable.

getRegisterConfig

public RegisterConfig getRegisterConfig()

Specified by:

getRegisterConfig in interface LIRGeneratorTool

attributes

public RegisterAttributes attributes(Register register)

emitMove

public Variable emitMove(Value input)

Specified by:

emitMove in interface LIRGeneratorTool

emitMove

public void emitMove(AllocatableValue dst,
                     Value src)

Specified by:

emitMove in interface LIRGeneratorTool

emitReadRegister

public Variable emitReadRegister(Register register,
                                 <any> kind)

Specified by:

emitReadRegister in interface LIRGeneratorTool

emitWriteRegister

public void emitWriteRegister(Register dst,
                              Value src,
                              <any> kind)

Specified by:

emitWriteRegister in interface LIRGeneratorTool

emitMoveConstant

public void emitMoveConstant(AllocatableValue dst,
                             Constant src)

Specified by:

emitMoveConstant in interface LIRGeneratorTool

canInlineConstant

public boolean canInlineConstant(Constant constant)

Specified by:

canInlineConstant in interface LIRGeneratorTool

mayEmbedConstantLoad

public boolean mayEmbedConstantLoad(Constant constant)

Specified by:

mayEmbedConstantLoad in interface LIRGeneratorTool

emitConstant

public Value emitConstant(LIRKind kind,
                          Constant constant)

Specified by:

emitConstant in interface LIRGeneratorTool

emitJavaConstant

public Value emitJavaConstant(JavaConstant constant)

Specified by:

emitJavaConstant in interface LIRGeneratorTool

emitLoadConstant

public AllocatableValue emitLoadConstant(<any> kind,
                                         Constant constant)

Specified by:

emitLoadConstant in interface LIRGeneratorTool

asAllocatable

public AllocatableValue asAllocatable(Value value)

Description copied from interface: LIRGeneratorTool

Returns an AllocatableValue holding the value by moving it if necessary. If value is already an AllocatableValue, returns it unchanged.

Specified by:

asAllocatable in interface LIRGeneratorTool

needOnlyOopMaps

public boolean needOnlyOopMaps()

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

resultOperandFor

public AllocatableValue resultOperandFor(JavaKind javaKind,
                                         <any> valueKind)

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

Parameters:

javaKind - the kind of value being returned

valueKind - the backend type of the value being returned

Returns:

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

setSourcePosition

public void setSourcePosition(NodeSourcePosition position)

append

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

Specified by:

append in interface LIRGeneratorTool

hasBlockEnd

public boolean hasBlockEnd(AbstractBlockBase<?> block)

getBlockScope

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

getMatchScope

public final DebugCloseable getMatchScope(AbstractBlockBase<?> block)

emitIncomingValues

public void emitIncomingValues(Value[] params)

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)

emitOverflowCheckBranch

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

emitIntegerTestBranch

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

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

emitIndirectForeignCallAddress

protected Value emitIndirectForeignCallAddress(ForeignCallLinkage linkage)

Loads the target address for indirect foreign calls.

emitForeignCallOp

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

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

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,
                               AllocatableValue value)

emitStrategySwitch

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

emitRangeTableSwitch

protected abstract void emitRangeTableSwitch(int lowKey,
                                             LabelRef defaultTarget,
                                             LabelRef[] targets,
                                             AllocatableValue key)

emitHashTableSwitch

protected abstract void emitHashTableSwitch(JavaConstant[] keys,
                                            LabelRef defaultTarget,
                                            LabelRef[] targets,
                                            AllocatableValue value,
                                            Value hash)

beforeRegisterAllocation

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

zapValueForKind

protected abstract JavaConstant zapValueForKind(PlatformKind kind)

Gets a garbage value for a given kind.

getLIRKind

public LIRKind getLIRKind(Stamp stamp)

Specified by:

getLIRKind in interface LIRGeneratorTool

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 DiagnosticLIRGeneratorTool

createMultiBenchmarkCounter

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

Specified by:

createMultiBenchmarkCounter in interface DiagnosticLIRGeneratorTool

createZapRegisters

public abstract LIRInstruction createZapRegisters(Register[] zappedRegisters,
                                                  JavaConstant[] zapValues)

Description copied from interface: DiagnosticLIRGeneratorTool

Creates an instruction that fills a given set of registers with a known garbage value.

Specified by:

createZapRegisters in interface DiagnosticLIRGeneratorTool

Parameters:

zappedRegisters - registers to be zapped

zapValues - values used for zapping

See Also:

DiagnosticLIRGeneratorTool.createZapRegisters()

createZapRegisters

public LIRInstruction createZapRegisters()

Description copied from interface: DiagnosticLIRGeneratorTool

Creates an instruction that fills all allocatable registers with a known garbage value.

Specified by:

createZapRegisters in interface DiagnosticLIRGeneratorTool

See Also:

DiagnosticLIRGeneratorTool.createZapRegisters(Register[], JavaConstant[])

createZapRegisters

public LIRInstruction createZapRegisters(Register[] zappedRegisters)

Description copied from interface: DiagnosticLIRGeneratorTool

Creates an instruction that fills a given set of registers with a known garbage value.

Specified by:

createZapRegisters in interface DiagnosticLIRGeneratorTool

Parameters:

zappedRegisters - registers to be zapped

See Also:

DiagnosticLIRGeneratorTool.createZapRegisters()

createZapArgumentSpace

public abstract LIRInstruction createZapArgumentSpace(StackSlot[] zappedStack,
                                                      JavaConstant[] zapValues)

Specified by:

createZapArgumentSpace in interface DiagnosticLIRGeneratorTool

zapArgumentSpace

public LIRInstruction zapArgumentSpace()

Specified by:

zapArgumentSpace in interface DiagnosticLIRGeneratorTool