org.graalvm.compiler.core.aarch64

Class AArch64NodeMatchRules

java.lang.Object

org.graalvm.compiler.core.gen.NodeMatchRules

org.graalvm.compiler.core.aarch64.AArch64NodeMatchRules

public class AArch64NodeMatchRules
extends NodeMatchRules

Field Summary

Fields inherited from class org.graalvm.compiler.core.gen.NodeMatchRules

gen

Constructor Summary

Constructors

Constructor and Description
AArch64NodeMatchRules(LIRGeneratorTool gen)

Method Summary

Modifier and Type	Method and Description
ComplexMatchResult	addSubShift(BinaryNode binary, ValueNode a, BinaryNode shift) Goal: Use AArch64 binary shift add/sub ops to fold shift.
ComplexMatchResult	bitFieldMove(BinaryNode rshift, LeftShiftNode lshift, ValueNode value) Goal: Use AArch64's bit field insert/extract instructions to copy over desired bits.
ComplexMatchResult	bitwiseLogicNot(BinaryNode logic, NotNode not) Goal: use AArch64's and not (bic) & or not (orn) instructions.
ComplexMatchResult	bitwiseNotXor(ValueNode value1, ValueNode value2) Goal: Use AArch64's bitwise exclusive or not (eon) instruction.
ComplexMatchResult	checkNegativeAndBranch(IfNode root, IntegerLessThanNode lessNode, ValueNode x, ConstantNode y) Goal: Transform (if x < 0) -> (tbz x, sizeOfBits(x) - 1, label).
protected ComplexMatchResult	emitBinaryShift(AArch64ArithmeticOp op, ValueNode value, ShiftNode<?> shift)
ComplexMatchResult	extendedPointerAddShift(AArch64PointerAddNode addP) Goal: Fold zero extend and (optional) shift into AArch64 add/sub (extended register) instruction.
ComplexMatchResult	floatSqrt(FloatConvertNode a, FloatConvertNode b, ValueNode c) Goal: Use directly AArch64's single-precision fsqrt op.
protected AArch64ArithmeticLIRGenerator	getArithmeticLIRGenerator()
AArch64LIRGenerator	getLIRGeneratorTool()
protected AArch64Kind	getMemoryKind(MemoryAccess access)
protected LIRFrameState	getState(MemoryAccess access)
protected boolean	isNumericFloat(ValueNode... values) Checks whether all arguments are numeric floats.
protected boolean	isNumericInteger(ValueNode... values) Checks whether all arguments are numeric integers.
ComplexMatchResult	logicShift(BinaryNode binary, ValueNode a, BinaryNode shift) Goal: Use AArch64 binary shift logic ops to fold shift.
ComplexMatchResult	mergeDowncastIntoAddSub(BinaryNode op, ValueNode x, ValueNode y, ConstantNode constant) Goal: Use AArch64's add/sub (extended register) instructions to fold in and operand.
ComplexMatchResult	mergePairShiftIntoAddSub(BinaryNode op, RightShiftNode signExt, ValueNode x, ValueNode y) Goal: Switch ((x << amt) >> amt) into a sign extend and fold into AArch64 add/sub (extended register) instruction.
ComplexMatchResult	mergeShiftDowncastIntoAddSub(BinaryNode op, LeftShiftNode lshift, ConstantNode constant, ValueNode x, ValueNode y) Goal: Use AArch64's add/sub (extended register) instructions to fold away the and operation (into a zero extend) and shift of left operand.
ComplexMatchResult	mergeShiftedPairShiftIntoAddSub(BinaryNode op, LeftShiftNode outerShift, RightShiftNode signExt, ValueNode x, ValueNode y) Goal: Fold ((x << amt) >> amt) << [0,4] into AArch64 add/sub (extended register) instruction with a sign extend and a shift.
ComplexMatchResult	mergeSignExtendByShiftIntoAddSub(BinaryNode op, LeftShiftNode lshift, ValueNode ext, ValueNode x, ValueNode y) Goal: Use AArch64's add/sub (extended register) instructions to fold away extend and shift of left operand.
ComplexMatchResult	mergeSignExtendIntoAddSub(BinaryNode op, UnaryNode ext, ValueNode x, ValueNode y) Goal: Use AArch64's add/sub (extended register) instruction.
ComplexMatchResult	multiplyAddSub(BinaryNode binary, ValueNode a, ValueNode b, ValueNode c) Goal: Use AArch64's multiply-add (madd) and multiply-subtract (msub) instructions.
ComplexMatchResult	multiplyNegate(ValueNode a, ValueNode b) Goal: Use AArch64's multiple-negate (mneg) instruction.
ComplexMatchResult	negShift(BinaryNode shift, ValueNode a, ConstantNode b) Goal: fold shift into negate operation using AArch64's sub (shifted register) instruction.
ComplexMatchResult	rotationConstant(ValueNode op, ValueNode x, ValueNode y, ValueNode src) Goal: Use AArch64's ror instruction for rotations.
ComplexMatchResult	rotationExpander(ValueNode src, ValueNode shiftAmount, ValueNode x, ValueNode y) Goal: Use AArch64's ror instruction for rotations.
ComplexMatchResult	signedBitField(LeftShiftNode shift, ValueNode value) Goal: Use AArch64's signed bitfield insert in zeros (sbfiz) instruction to extract desired bits while folding away sign extend.
ComplexMatchResult	signedMultiplyAddSubLong(BinaryNode binary, MulNode mul, ValueNode a, ValueNode b, ValueNode c) Goal: use AArch64's (i32,i32) -> i64 multiply instructions to fold away sign extensions.
ComplexMatchResult	signedMultiplyLong(MulNode mul, ValueNode a, ValueNode b) Goal: use AArch64's (i32,i32) -> i64 multiply instructions to fold away sign extensions.
ComplexMatchResult	signedMultiplyNegLong(MulNode mul, SignExtendNode ext1, SignExtendNode ext2, ValueNode a, ValueNode b) Goal: use AArch64's (i32,i32) -> i64 multiply instructions to fold away sign extensions.
ComplexMatchResult	testBitAndBranch(IfNode root, ValueNode value, ConstantNode a) Goal: Transform ((x & (1 << n)) == 0) -> (tbz/tbnz n label).
ComplexMatchResult	unsignedBitField(BinaryNode shift, ValueNode value, ConstantNode a) Goal: Use AArch64's bit unsigned field insert/extract (UBFIZ/UBFX) instructions to copy over desired bits.
ComplexMatchResult	unsignedExtBitField(ZeroExtendNode extend, BinaryNode shift, ValueNode value, ConstantNode a) Goal: Use AArch64's bit unsigned field insert/extract (UBFIZ/UBFX) instructions to copy over desired bits.

Methods inherited from class org.graalvm.compiler.core.gen.NodeMatchRules

append, getLIRBlock, operand, state

Methods inherited from class java.lang.Object

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

Constructor Detail

AArch64NodeMatchRules

public AArch64NodeMatchRules(LIRGeneratorTool gen)

Method Detail

isNumericInteger

protected boolean isNumericInteger(ValueNode... values)

Checks whether all arguments are numeric integers.

isNumericFloat

protected boolean isNumericFloat(ValueNode... values)

Checks whether all arguments are numeric floats.

getState

protected LIRFrameState getState(MemoryAccess access)

getMemoryKind

protected AArch64Kind getMemoryKind(MemoryAccess access)

emitBinaryShift

protected ComplexMatchResult emitBinaryShift(AArch64ArithmeticOp op,
                                             ValueNode value,
                                             ShiftNode<?> shift)

mergeSignExtendByShiftIntoAddSub

public ComplexMatchResult mergeSignExtendByShiftIntoAddSub(BinaryNode op,
                                                           LeftShiftNode lshift,
                                                           ValueNode ext,
                                                           ValueNode x,
                                                           ValueNode y)

Goal: Use AArch64's add/sub (extended register) instructions to fold away extend and shift of left operand.

mergeShiftDowncastIntoAddSub

public ComplexMatchResult mergeShiftDowncastIntoAddSub(BinaryNode op,
                                                       LeftShiftNode lshift,
                                                       ConstantNode constant,
                                                       ValueNode x,
                                                       ValueNode y)

Goal: Use AArch64's add/sub (extended register) instructions to fold away the and operation (into a zero extend) and shift of left operand.

mergePairShiftIntoAddSub

public ComplexMatchResult mergePairShiftIntoAddSub(BinaryNode op,
                                                   RightShiftNode signExt,
                                                   ValueNode x,
                                                   ValueNode y)

Goal: Switch ((x << amt) >> amt) into a sign extend and fold into AArch64 add/sub (extended register) instruction.

mergeShiftedPairShiftIntoAddSub

public ComplexMatchResult mergeShiftedPairShiftIntoAddSub(BinaryNode op,
                                                          LeftShiftNode outerShift,
                                                          RightShiftNode signExt,
                                                          ValueNode x,
                                                          ValueNode y)

Goal: Fold ((x << amt) >> amt) << [0,4] into AArch64 add/sub (extended register) instruction with a sign extend and a shift.

extendedPointerAddShift

public ComplexMatchResult extendedPointerAddShift(AArch64PointerAddNode addP)

Goal: Fold zero extend and (optional) shift into AArch64 add/sub (extended register) instruction.

unsignedBitField

public ComplexMatchResult unsignedBitField(BinaryNode shift,
                                           ValueNode value,
                                           ConstantNode a)

Goal: Use AArch64's bit unsigned field insert/extract (UBFIZ/UBFX) instructions to copy over desired bits.

unsignedExtBitField

public ComplexMatchResult unsignedExtBitField(ZeroExtendNode extend,
                                              BinaryNode shift,
                                              ValueNode value,
                                              ConstantNode a)

Goal: Use AArch64's bit unsigned field insert/extract (UBFIZ/UBFX) instructions to copy over desired bits.

signedBitField

public ComplexMatchResult signedBitField(LeftShiftNode shift,
                                         ValueNode value)

Goal: Use AArch64's signed bitfield insert in zeros (sbfiz) instruction to extract desired bits while folding away sign extend.

bitFieldMove

public ComplexMatchResult bitFieldMove(BinaryNode rshift,
                                       LeftShiftNode lshift,
                                       ValueNode value)

Goal: Use AArch64's bit field insert/extract instructions to copy over desired bits.

rotationConstant

public ComplexMatchResult rotationConstant(ValueNode op,
                                           ValueNode x,
                                           ValueNode y,
                                           ValueNode src)

Goal: Use AArch64's ror instruction for rotations.

rotationExpander

public ComplexMatchResult rotationExpander(ValueNode src,
                                           ValueNode shiftAmount,
                                           ValueNode x,
                                           ValueNode y)

Goal: Use AArch64's ror instruction for rotations.

addSubShift

public ComplexMatchResult addSubShift(BinaryNode binary,
                                      ValueNode a,
                                      BinaryNode shift)

Goal: Use AArch64 binary shift add/sub ops to fold shift.

logicShift

public ComplexMatchResult logicShift(BinaryNode binary,
                                     ValueNode a,
                                     BinaryNode shift)

Goal: Use AArch64 binary shift logic ops to fold shift.

negShift

public ComplexMatchResult negShift(BinaryNode shift,
                                   ValueNode a,
                                   ConstantNode b)

Goal: fold shift into negate operation using AArch64's sub (shifted register) instruction.

bitwiseLogicNot

public final ComplexMatchResult bitwiseLogicNot(BinaryNode logic,
                                                NotNode not)

Goal: use AArch64's and not (bic) & or not (orn) instructions.

bitwiseNotXor

public ComplexMatchResult bitwiseNotXor(ValueNode value1,
                                        ValueNode value2)

Goal: Use AArch64's bitwise exclusive or not (eon) instruction. Note that !(A^B) == (!A)^B == A^(!B).

signedMultiplyAddSubLong

public ComplexMatchResult signedMultiplyAddSubLong(BinaryNode binary,
                                                   MulNode mul,
                                                   ValueNode a,
                                                   ValueNode b,
                                                   ValueNode c)

Goal: use AArch64's (i32,i32) -> i64 multiply instructions to fold away sign extensions.

signedMultiplyNegLong

public ComplexMatchResult signedMultiplyNegLong(MulNode mul,
                                                SignExtendNode ext1,
                                                SignExtendNode ext2,
                                                ValueNode a,
                                                ValueNode b)

Goal: use AArch64's (i32,i32) -> i64 multiply instructions to fold away sign extensions.

signedMultiplyLong

public ComplexMatchResult signedMultiplyLong(MulNode mul,
                                             ValueNode a,
                                             ValueNode b)

Goal: use AArch64's (i32,i32) -> i64 multiply instructions to fold away sign extensions.

mergeDowncastIntoAddSub

public ComplexMatchResult mergeDowncastIntoAddSub(BinaryNode op,
                                                  ValueNode x,
                                                  ValueNode y,
                                                  ConstantNode constant)

Goal: Use AArch64's add/sub (extended register) instructions to fold in and operand.

mergeSignExtendIntoAddSub

public ComplexMatchResult mergeSignExtendIntoAddSub(BinaryNode op,
                                                    UnaryNode ext,
                                                    ValueNode x,
                                                    ValueNode y)

Goal: Use AArch64's add/sub (extended register) instruction.

multiplyNegate

public final ComplexMatchResult multiplyNegate(ValueNode a,
                                               ValueNode b)

Goal: Use AArch64's multiple-negate (mneg) instruction.

multiplyAddSub

public final ComplexMatchResult multiplyAddSub(BinaryNode binary,
                                               ValueNode a,
                                               ValueNode b,
                                               ValueNode c)

Goal: Use AArch64's multiply-add (madd) and multiply-subtract (msub) instructions.

testBitAndBranch

public ComplexMatchResult testBitAndBranch(IfNode root,
                                           ValueNode value,
                                           ConstantNode a)

Goal: Transform ((x & (1 << n)) == 0) -> (tbz/tbnz n label).

checkNegativeAndBranch

public ComplexMatchResult checkNegativeAndBranch(IfNode root,
                                                 IntegerLessThanNode lessNode,
                                                 ValueNode x,
                                                 ConstantNode y)

Goal: Transform (if x < 0) -> (tbz x, sizeOfBits(x) - 1, label).

floatSqrt

public final ComplexMatchResult floatSqrt(FloatConvertNode a,
                                          FloatConvertNode b,
                                          ValueNode c)

Goal: Use directly AArch64's single-precision fsqrt op.

getLIRGeneratorTool

public AArch64LIRGenerator getLIRGeneratorTool()

Overrides:

getLIRGeneratorTool in class NodeMatchRules

getArithmeticLIRGenerator

protected AArch64ArithmeticLIRGenerator getArithmeticLIRGenerator()