org.graalvm.compiler.core.amd64

Class AMD64LIRGenerator

java.lang.Object

org.graalvm.compiler.lir.gen.LIRGenerator

org.graalvm.compiler.core.amd64.AMD64LIRGenerator

All Implemented Interfaces:

DiagnosticLIRGeneratorTool, LIRGeneratorTool

Direct Known Subclasses:

AMD64HotSpotLIRGenerator

public abstract class AMD64LIRGenerator
extends LIRGenerator

This class implements the AMD64 specific portion of the LIR generator.

Nested Class Summary

Nested classes/interfaces inherited from class org.graalvm.compiler.lir.gen.LIRGenerator

LIRGenerator.Options, LIRGenerator.VariableProvider

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 inherited from class org.graalvm.compiler.lir.gen.LIRGenerator

arithmeticLIRGen

Constructor Summary

Constructors

Constructor and Description
AMD64LIRGenerator(LIRKindTool lirKindTool, AMD64ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, Providers providers, LIRGenerationResult lirGenRes)

Method Summary

Modifier and Type	Method and Description
AMD64AddressValue	asAddressValue(Value address)
protected AMD64ControlFlow.StrategySwitchOp	createStrategySwitchOp(SwitchStrategy strategy, LabelRef[] keyTargets, LabelRef defaultTarget, AllocatableValue key, AllocatableValue temp)
LIRInstruction	createZapArgumentSpace(StackSlot[] zappedStack, JavaConstant[] zapValues)
LIRInstruction	createZapRegisters(Register[] zappedRegisters, JavaConstant[] zapValues) Creates an instruction that fills a given set of registers with a known garbage value.
Variable	emitAddress(AllocatableValue stackslot)
Variable	emitArrayCompareTo(JavaKind kind1, JavaKind kind2, int array1BaseOffset, int array2BaseOffset, Value array1, Value array2, Value length1, Value length2)
void	emitArrayCopyWithConversion(JavaKind strideSrc, JavaKind strideDst, Value arraySrc, Value offsetSrc, Value arrayDst, Value offsetDst, Value length)
void	emitArrayCopyWithConversion(Value arraySrc, Value offsetSrc, Value arrayDst, Value offsetDst, Value length, Value stride)
Variable	emitArrayEquals(int baseOffsetA, int baseOffsetB, int baseOffsetMask, Value arrayA, Value offsetA, Value arrayB, Value offsetB, Value mask, Value length, Value stride)
Variable	emitArrayEquals(int baseOffsetA, int baseOffsetB, Value arrayA, Value offsetA, Value arrayB, Value offsetB, Value length, Value stride)
Variable	emitArrayEquals(JavaKind kind, int array1BaseOffset, int array2BaseOffset, Value array1, Value array2, Value length)
Variable	emitArrayEquals(JavaKind kind, int array1BaseOffset, int array2BaseOffset, Value array1, Value offset1, Value array2, Value offset2, Value length)
Variable	emitArrayEquals(JavaKind kind1, JavaKind kind2, int array1BaseOffset, int array2BaseOffset, Value array1, Value offset1, Value array2, Value offset2, Value length)
Variable	emitArrayEquals(JavaKind kind1, JavaKind kind2, JavaKind kindMask, int array1BaseOffset, int array2BaseOffset, int maskBaseOffset, Value array1, Value offset1, Value array2, Value offset2, Value mask, Value length)
Variable	emitArrayIndexOf(int arrayBaseOffset, JavaKind valueKind, boolean findTwoConsecutive, boolean withMask, Value arrayPointer, Value arrayOffset, Value arrayLength, Value fromIndex, Value... searchValues)
Variable	emitArrayRegionCompareTo(JavaKind strideA, JavaKind strideB, Value arrayA, Value offsetA, Value arrayB, Value offsetB, Value length)
Variable	emitArrayRegionCompareTo(Value arrayA, Value offsetA, Value arrayB, Value offsetB, Value length, Value stride)
Value	emitAtomicReadAndAdd(Value address, <any> kind, Value delta) Emit an atomic read-and-add instruction.
Value	emitAtomicReadAndWrite(Value address, <any> kind, Value newValue) Emit an atomic read-and-write instruction.
Variable	emitByteSwap(Value input)
void	emitCacheWriteback(Value address) Emits instruction(s) to flush an individual cache line that starts at address.
void	emitCacheWritebackSync(boolean isPreSync) Emits instruction(s) to serialize cache writeback operations relative to preceding (if isPreSync == true) or following (if isPreSync == false) memory writes.
Variable	emitCalcStringAttributes(Object opObj, Value array, Value offset, Value length, boolean isValid)
abstract void	emitCCall(long address, CallingConvention nativeCallingConvention, Value[] args, int numberOfFloatingPointArguments)
void	emitCompareAndSwapBranch(<any> kind, AMD64AddressValue address, Value expectedValue, Value newValue, Condition condition, LabelRef trueLabel, LabelRef falseLabel, double trueLabelProbability)
void	emitCompareBranch(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueLabel, LabelRef falseLabel, double trueLabelProbability)
void	emitCompareBranchMemory(AMD64Kind cmpKind, Value left, AMD64AddressValue right, LIRFrameState state, Condition cond, boolean unorderedIsTrue, LabelRef trueLabel, LabelRef falseLabel, double trueLabelProbability)
Variable	emitConditionalMove(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue)
Variable	emitEncodeArray(Value src, Value dst, Value length, LIRGeneratorTool.CharsetName charset)
protected 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 void	emitHashTableSwitch(JavaConstant[] keys, LabelRef defaultTarget, LabelRef[] targets, AllocatableValue value, Value hash)
Variable	emitHasNegatives(Value array, Value length)
void	emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability)
Variable	emitIntegerTestMove(Value left, Value right, Value trueValue, Value falseValue)
void	emitJump(LabelRef label)
Variable	emitLogicCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue, MemoryOrderMode memoryOrder)
void	emitMembar(int barriers)
void	emitNullCheck(Value address, LIRFrameState state)
void	emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpLIRKind, double overflowProbability)
void	emitPause()
protected void	emitRangeTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, AllocatableValue key)
void	emitSpeculationFence() Emits an instruction that prevents speculative execution from proceeding: no instruction after this fence will execute until all previous instructions have retired.
void	emitStrategySwitch(SwitchStrategy strategy, AllocatableValue key, LabelRef[] keyTargets, LabelRef defaultTarget)
void	emitStringLatin1Inflate(Value src, Value dst, Value len)
Variable	emitStringUTF16Compress(Value src, Value dst, Value len)
Value	emitValueCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue, MemoryOrderMode memoryOrder)
void	emitZeroMemory(Value address, Value length, boolean isAligned)
protected int	getAVX3Threshold() Return the minimal array size for using AVX3 instructions.
AVXKind.AVXSize	getMaxVectorSize() Return the maximum size of vector registers used in SSE/AVX instructions.
protected static AVXKind.AVXSize	getRegisterSize(Value a)
protected Value	loadNonInlinableConstant(Value value)
protected boolean	supports(CPUFeature feature)
boolean	supportsCPUFeature(AMD64.CPUFeature feature)
<K extends <any>> K	toRegisterKind(K kind) The AMD64 backend only uses DWORD and QWORD values in registers because of a performance penalty when accessing WORD or BYTE registers.
protected JavaConstant	zapValueForKind(PlatformKind kind) Gets a garbage value for a given kind.

Methods inherited from class org.graalvm.compiler.lir.gen.LIRGenerator

append, asAllocatable, attributes, beforeRegisterAllocation, canInlineConstant, createBenchmarkCounter, createMultiBenchmarkCounter, createZapRegisters, createZapRegisters, emitBlackhole, emitConstant, emitForeignCall, emitIncomingValues, emitIndirectForeignCallAddress, emitJavaConstant, emitLoadConstant, emitMove, emitMove, emitMoveConstant, emitReadRegister, emitStrategySwitch, emitWriteRegister, getAddressKind, getArithmetic, getBlockScope, getCodeCache, getCurrentBlock, getForeignCalls, getLIRKind, getLIRKindTool, getMatchScope, getMetaAccess, getMoveFactory, getProviders, getRegisterConfig, getResult, getSpillMoveFactory, getValueKind, hasBlockEnd, mayEmbedConstantLoad, needOnlyOopMaps, newVariable, resultOperandFor, setSourcePosition, target, zapArgumentSpace

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, emitCompress, emitConvertNullToZero, emitConvertNullToZero, emitConvertZeroToNull, emitDeoptimize, emitPrefetchAllocate, emitReadCallerStackPointer, emitReadReturnAddress, emitReturn, emitTimeStampWithProcid, emitUncompress, emitUnwind

Constructor Detail

AMD64LIRGenerator

public AMD64LIRGenerator(LIRKindTool lirKindTool,
                         AMD64ArithmeticLIRGenerator arithmeticLIRGen,
                         MoveFactory moveFactory,
                         Providers providers,
                         LIRGenerationResult lirGenRes)

Method Detail

zapValueForKind

protected JavaConstant zapValueForKind(PlatformKind kind)

Description copied from class: LIRGenerator

Gets a garbage value for a given kind.

Specified by:

zapValueForKind in class LIRGenerator

asAddressValue

public AMD64AddressValue asAddressValue(Value address)

emitAddress

public Variable emitAddress(AllocatableValue stackslot)

toRegisterKind

public <K extends <any>> K toRegisterKind(K kind)

The AMD64 backend only uses DWORD and QWORD values in registers because of a performance penalty when accessing WORD or BYTE registers. This function converts small integer kinds to DWORD.

loadNonInlinableConstant

protected Value loadNonInlinableConstant(Value value)

emitLogicCompareAndSwap

public Variable emitLogicCompareAndSwap(LIRKind accessKind,
                                        Value address,
                                        Value expectedValue,
                                        Value newValue,
                                        Value trueValue,
                                        Value falseValue,
                                        MemoryOrderMode memoryOrder)

emitValueCompareAndSwap

public Value emitValueCompareAndSwap(LIRKind accessKind,
                                     Value address,
                                     Value expectedValue,
                                     Value newValue,
                                     MemoryOrderMode memoryOrder)

emitCompareAndSwapBranch

public void emitCompareAndSwapBranch(<any> kind,
                                     AMD64AddressValue address,
                                     Value expectedValue,
                                     Value newValue,
                                     Condition condition,
                                     LabelRef trueLabel,
                                     LabelRef falseLabel,
                                     double trueLabelProbability)

emitAtomicReadAndAdd

public Value emitAtomicReadAndAdd(Value address,
                                  <any> kind,
                                  Value delta)

Description copied from interface: LIRGeneratorTool

Emit an atomic read-and-add instruction.

Parameters:

address - address of the value to be read and written

kind - the access kind for the value to be written

delta - the value to be added

emitAtomicReadAndWrite

public Value emitAtomicReadAndWrite(Value address,
                                    <any> kind,
                                    Value newValue)

Description copied from interface: LIRGeneratorTool

Emit an atomic read-and-write instruction.

Parameters:

address - address of the value to be read and written

kind - the access kind for the value to be written

newValue - the new value to be written

emitNullCheck

public void emitNullCheck(Value address,
                          LIRFrameState state)

emitJump

public void emitJump(LabelRef label)

Specified by:

emitJump in interface LIRGeneratorTool

Specified by:

emitJump in class LIRGenerator

emitCompareBranch

public void emitCompareBranch(PlatformKind cmpKind,
                              Value left,
                              Value right,
                              Condition cond,
                              boolean unorderedIsTrue,
                              LabelRef trueLabel,
                              LabelRef falseLabel,
                              double trueLabelProbability)

Specified by:

emitCompareBranch in class LIRGenerator

emitCompareBranchMemory

public void emitCompareBranchMemory(AMD64Kind cmpKind,
                                    Value left,
                                    AMD64AddressValue right,
                                    LIRFrameState state,
                                    Condition cond,
                                    boolean unorderedIsTrue,
                                    LabelRef trueLabel,
                                    LabelRef falseLabel,
                                    double trueLabelProbability)

emitOverflowCheckBranch

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

Specified by:

emitOverflowCheckBranch in class LIRGenerator

emitIntegerTestBranch

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

Specified by:

emitIntegerTestBranch in class LIRGenerator

emitConditionalMove

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

Specified by:

emitConditionalMove in interface LIRGeneratorTool

Specified by:

emitConditionalMove in class LIRGenerator

emitIntegerTestMove

public Variable emitIntegerTestMove(Value left,
                                    Value right,
                                    Value trueValue,
                                    Value falseValue)

Specified by:

emitIntegerTestMove in interface LIRGeneratorTool

Specified by:

emitIntegerTestMove in class LIRGenerator

getRegisterSize

protected static AVXKind.AVXSize getRegisterSize(Value a)

emitMembar

public void emitMembar(int barriers)

emitCCall

public abstract void emitCCall(long address,
                               CallingConvention nativeCallingConvention,
                               Value[] args,
                               int numberOfFloatingPointArguments)

emitForeignCallOp

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

Description copied from class: LIRGenerator

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

Specified by:

emitForeignCallOp in class LIRGenerator

emitByteSwap

public Variable emitByteSwap(Value input)

emitArrayCompareTo

public Variable emitArrayCompareTo(JavaKind kind1,
                                   JavaKind kind2,
                                   int array1BaseOffset,
                                   int array2BaseOffset,
                                   Value array1,
                                   Value array2,
                                   Value length1,
                                   Value length2)

emitArrayRegionCompareTo

public Variable emitArrayRegionCompareTo(Value arrayA,
                                         Value offsetA,
                                         Value arrayB,
                                         Value offsetB,
                                         Value length,
                                         Value stride)

emitArrayRegionCompareTo

public Variable emitArrayRegionCompareTo(JavaKind strideA,
                                         JavaKind strideB,
                                         Value arrayA,
                                         Value offsetA,
                                         Value arrayB,
                                         Value offsetB,
                                         Value length)

emitArrayEquals

public Variable emitArrayEquals(JavaKind kind,
                                int array1BaseOffset,
                                int array2BaseOffset,
                                Value array1,
                                Value array2,
                                Value length)

emitArrayEquals

public Variable emitArrayEquals(int baseOffsetA,
                                int baseOffsetB,
                                Value arrayA,
                                Value offsetA,
                                Value arrayB,
                                Value offsetB,
                                Value length,
                                Value stride)

emitArrayEquals

public Variable emitArrayEquals(JavaKind kind,
                                int array1BaseOffset,
                                int array2BaseOffset,
                                Value array1,
                                Value offset1,
                                Value array2,
                                Value offset2,
                                Value length)

emitArrayEquals

public Variable emitArrayEquals(JavaKind kind1,
                                JavaKind kind2,
                                int array1BaseOffset,
                                int array2BaseOffset,
                                Value array1,
                                Value offset1,
                                Value array2,
                                Value offset2,
                                Value length)

emitArrayEquals

public Variable emitArrayEquals(int baseOffsetA,
                                int baseOffsetB,
                                int baseOffsetMask,
                                Value arrayA,
                                Value offsetA,
                                Value arrayB,
                                Value offsetB,
                                Value mask,
                                Value length,
                                Value stride)

emitArrayEquals

public Variable emitArrayEquals(JavaKind kind1,
                                JavaKind kind2,
                                JavaKind kindMask,
                                int array1BaseOffset,
                                int array2BaseOffset,
                                int maskBaseOffset,
                                Value array1,
                                Value offset1,
                                Value array2,
                                Value offset2,
                                Value mask,
                                Value length)

emitArrayCopyWithConversion

public void emitArrayCopyWithConversion(JavaKind strideSrc,
                                        JavaKind strideDst,
                                        Value arraySrc,
                                        Value offsetSrc,
                                        Value arrayDst,
                                        Value offsetDst,
                                        Value length)

emitArrayCopyWithConversion

public void emitArrayCopyWithConversion(Value arraySrc,
                                        Value offsetSrc,
                                        Value arrayDst,
                                        Value offsetDst,
                                        Value length,
                                        Value stride)

emitCalcStringAttributes

public Variable emitCalcStringAttributes(Object opObj,
                                         Value array,
                                         Value offset,
                                         Value length,
                                         boolean isValid)

emitEncodeArray

public Variable emitEncodeArray(Value src,
                                Value dst,
                                Value length,
                                LIRGeneratorTool.CharsetName charset)

emitHasNegatives

public Variable emitHasNegatives(Value array,
                                 Value length)

supports

protected boolean supports(CPUFeature feature)

getMaxVectorSize

public AVXKind.AVXSize getMaxVectorSize()

Return the maximum size of vector registers used in SSE/AVX instructions.

getAVX3Threshold

protected int getAVX3Threshold()

Return the minimal array size for using AVX3 instructions.

emitArrayIndexOf

public Variable emitArrayIndexOf(int arrayBaseOffset,
                                 JavaKind valueKind,
                                 boolean findTwoConsecutive,
                                 boolean withMask,
                                 Value arrayPointer,
                                 Value arrayOffset,
                                 Value arrayLength,
                                 Value fromIndex,
                                 Value... searchValues)

emitStringLatin1Inflate

public void emitStringLatin1Inflate(Value src,
                                    Value dst,
                                    Value len)

emitStringUTF16Compress

public Variable emitStringUTF16Compress(Value src,
                                        Value dst,
                                        Value len)

createStrategySwitchOp

protected AMD64ControlFlow.StrategySwitchOp createStrategySwitchOp(SwitchStrategy strategy,
                                                                   LabelRef[] keyTargets,
                                                                   LabelRef defaultTarget,
                                                                   AllocatableValue key,
                                                                   AllocatableValue temp)

emitStrategySwitch

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

Specified by:

emitStrategySwitch in class LIRGenerator

emitRangeTableSwitch

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

Specified by:

emitRangeTableSwitch in class LIRGenerator

emitHashTableSwitch

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

Specified by:

emitHashTableSwitch in class LIRGenerator

emitPause

public void emitPause()

emitCacheWriteback

public void emitCacheWriteback(Value address)

Description copied from interface: LIRGeneratorTool

Emits instruction(s) to flush an individual cache line that starts at address.

emitCacheWritebackSync

public void emitCacheWritebackSync(boolean isPreSync)

Description copied from interface: LIRGeneratorTool

Emits instruction(s) to serialize cache writeback operations relative to preceding (if isPreSync == true) or following (if isPreSync == false) memory writes.

createZapRegisters

public 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

Specified by:

createZapRegisters in class LIRGenerator

Parameters:

zappedRegisters - registers to be zapped

zapValues - values used for zapping

See Also:

DiagnosticLIRGeneratorTool.createZapRegisters()

createZapArgumentSpace

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

Specified by:

createZapArgumentSpace in interface DiagnosticLIRGeneratorTool

Specified by:

createZapArgumentSpace in class LIRGenerator

emitSpeculationFence

public void emitSpeculationFence()

Description copied from interface: LIRGeneratorTool

Emits an instruction that prevents speculative execution from proceeding: no instruction after this fence will execute until all previous instructions have retired.

emitZeroMemory

public void emitZeroMemory(Value address,
                           Value length,
                           boolean isAligned)

supportsCPUFeature

public boolean supportsCPUFeature(AMD64.CPUFeature feature)