org.graalvm.compiler.core.aarch64

Class AArch64LIRGenerator

java.lang.Object

org.graalvm.compiler.lir.gen.LIRGenerator

org.graalvm.compiler.core.aarch64.AArch64LIRGenerator

All Implemented Interfaces:

DiagnosticLIRGeneratorTool, LIRGeneratorTool

Direct Known Subclasses:

AArch64HotSpotLIRGenerator

public abstract class AArch64LIRGenerator
extends LIRGenerator

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
AArch64LIRGenerator(LIRKindTool lirKindTool, AArch64ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, Providers providers, LIRGenerationResult lirGenRes)

Method Summary

Modifier and Type	Method and Description
AArch64AddressValue	asAddressValue(Value address, int bitTransferSize)
protected AArch64ControlFlow.StrategySwitchOp	createStrategySwitchOp(SwitchStrategy strategy, LabelRef[] keyTargets, LabelRef defaultTarget, AllocatableValue key, Function<Condition,AArch64Assembler.ConditionFlag> converter)
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)
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	emitArrayIndexOf(int arrayBaseOffset, JavaKind valueKind, boolean findTwoConsecutive, boolean withMask, Value arrayPointer, Value arrayOffset, Value arrayLength, Value fromIndex, Value... searchValues)
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.
abstract void	emitCCall(long address, CallingConvention nativeCallingConvention, Value[] args)
protected boolean	emitCompare(PlatformKind cmpKind, Value a, Value b, Condition condition, boolean unorderedIsTrue) This method emits the compare instruction, and may mirror (switch) the operands.
void	emitCompareBranch(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability)
Variable	emitConditionalMove(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue) Conditionally move trueValue into new variable if cond + unorderedIsTrue is true, else falseValue.
Variable	emitEncodeArray(Value src, Value dst, Value length, LIRGeneratorTool.CharsetName charset)
protected void	emitHashTableSwitch(JavaConstant[] keys, LabelRef defaultTarget, LabelRef[] targets, AllocatableValue value, Value hash)
void	emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueSuccessorProbability) Branches to label if (left & right) == 0.
Variable	emitIntegerTestMove(Value left, Value right, Value trueValue, Value falseValue) Moves trueValue into result if (left & right) == 0, else 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 cmpKind, 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)
Variable	emitValueCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue, MemoryOrderMode memoryOrder)
void	emitZeroMemory(Value address, Value length, boolean isAligned)
protected void	emitZeroMemory(Value address, Value length, boolean isAligned, boolean useDcZva, int zvaLength)
protected Value	getCompareValueForConstantPointer(Value v) Returns the appropriate value to use within a comparison if the value is a pointer constant; if not, returns the original value.
AllocatableValue	moveSp(AllocatableValue val) If val denotes the stackpointer, move it to another location.
<K extends <any>> K	toRegisterKind(K kind) AArch64 cannot use anything smaller than a word in any instruction other than load and store.
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, emitForeignCallOp, 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, emitArrayCopyWithConversion, emitArrayCopyWithConversion, emitArrayEquals, emitArrayEquals, emitArrayEquals, emitArrayRegionCompareTo, emitArrayRegionCompareTo, emitCalcStringAttributes, emitCompress, emitConvertNullToZero, emitConvertNullToZero, emitConvertZeroToNull, emitDeoptimize, emitHasNegatives, emitPrefetchAllocate, emitReadCallerStackPointer, emitReadReturnAddress, emitReturn, emitTimeStampWithProcid, emitUncompress, emitUnwind, getMaxVectorSize

Constructor Detail

AArch64LIRGenerator

public AArch64LIRGenerator(LIRKindTool lirKindTool,
                           AArch64ArithmeticLIRGenerator arithmeticLIRGen,
                           MoveFactory moveFactory,
                           Providers providers,
                           LIRGenerationResult lirGenRes)

Method Detail

moveSp

public AllocatableValue moveSp(AllocatableValue val)

If val denotes the stackpointer, move it to another location. This is necessary since most ops cannot handle the stackpointer as input or output.

toRegisterKind

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

AArch64 cannot use anything smaller than a word in any instruction other than load and store.

emitNullCheck

public void emitNullCheck(Value address,
                          LIRFrameState state)

emitAddress

public Variable emitAddress(AllocatableValue stackslot)

asAddressValue

public AArch64AddressValue asAddressValue(Value address,
                                          int bitTransferSize)

getCompareValueForConstantPointer

protected Value getCompareValueForConstantPointer(Value v)

Returns the appropriate value to use within a comparison if the value is a pointer constant; if not, returns the original value.

emitLogicCompareAndSwap

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

emitValueCompareAndSwap

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

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

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

emitMembar

public void emitMembar(int barriers)

emitJump

public void emitJump(LabelRef label)

Specified by:

emitJump in interface LIRGeneratorTool

Specified by:

emitJump in class LIRGenerator

emitOverflowCheckBranch

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

Specified by:

emitOverflowCheckBranch in class LIRGenerator

emitIntegerTestBranch

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

Branches to label if (left & right) == 0. If negated is true branchse on non-zero instead.

Specified by:

emitIntegerTestBranch in class LIRGenerator

Parameters:

left - Integer kind. Non null.

right - Integer kind. Non null.

trueDestination - destination if left & right == 0. Non null.

falseDestination - destination if left & right != 0. Non null

trueSuccessorProbability - hoistoric probability that comparison is true

emitConditionalMove

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

Conditionally move trueValue into new variable if cond + unorderedIsTrue is true, else falseValue.

Specified by:

emitConditionalMove in interface LIRGeneratorTool

Specified by:

emitConditionalMove in class LIRGenerator

Parameters:

left - Arbitrary value. Has to have same type as right. Non null.

right - Arbitrary value. Has to have same type as left. Non null.

cond - condition that decides whether to move trueValue or falseValue into result. Non null.

unorderedIsTrue - defines whether floating-point comparisons consider unordered true or not. Ignored for integer comparisons.

trueValue - arbitrary value same type as falseValue. Non null.

falseValue - arbitrary value same type as trueValue. Non null.

Returns:

value containing trueValue if cond + unorderedIsTrue is true, else falseValue. Non null.

emitCompareBranch

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

Specified by:

emitCompareBranch in class LIRGenerator

emitCompare

protected boolean emitCompare(PlatformKind cmpKind,
                              Value a,
                              Value b,
                              Condition condition,
                              boolean unorderedIsTrue)

This method emits the compare instruction, and may mirror (switch) the operands. It returns true if it did so.

Parameters:

a - the left operand of the comparison. Has to have same type as b. Non null.

b - the right operand of the comparison. Has to have same type as a. Non null.

Returns:

true if mirrored (i.e. "b cmp a" instead of "a cmp b" was done).

emitIntegerTestMove

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

Moves trueValue into result if (left & right) == 0, else falseValue.

Specified by:

emitIntegerTestMove in interface LIRGeneratorTool

Specified by:

emitIntegerTestMove in class LIRGenerator

Parameters:

left - Integer kind. Non null.

right - Integer kind. Non null.

trueValue - Arbitrary value, same type as falseValue. Non null.

falseValue - Arbitrary value, same type as trueValue. Non null.

Returns:

virtual register containing trueValue if (left & right) == 0, else falseValue.

emitStrategySwitch

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

Specified by:

emitStrategySwitch in class LIRGenerator

createStrategySwitchOp

protected AArch64ControlFlow.StrategySwitchOp createStrategySwitchOp(SwitchStrategy strategy,
                                                                     LabelRef[] keyTargets,
                                                                     LabelRef defaultTarget,
                                                                     AllocatableValue key,
                                                                     Function<Condition,AArch64Assembler.ConditionFlag> converter)

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

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)

emitArrayEquals

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

emitArrayEquals

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

emitArrayIndexOf

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

emitEncodeArray

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

emitStringLatin1Inflate

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

emitStringUTF16Compress

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

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

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

emitCCall

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

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)

emitZeroMemory

protected final void emitZeroMemory(Value address,
                                    Value length,
                                    boolean isAligned,
                                    boolean useDcZva,
                                    int zvaLength)