org.graalvm.compiler.nodes.calc

Class IntegerLowerThanNode.LowerOp

java.lang.Object

org.graalvm.compiler.nodes.calc.CompareNode.CompareOp

org.graalvm.compiler.nodes.calc.IntegerLowerThanNode.LowerOp

Direct Known Subclasses:

IntegerBelowNode.BelowOp, IntegerLessThanNode.LessThanOp

Enclosing class:

IntegerLowerThanNode

public abstract static class IntegerLowerThanNode.LowerOp
extends CompareNode.CompareOp

Constructor Summary

Constructors

Constructor and Description
LowerOp()

Method Summary

Modifier and Type	Method and Description
protected abstract boolean	addCanOverflow(IntegerStamp a, IntegerStamp b) Return true if the a + b can overflow w.r.t.
LogicNode	canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, CanonicalCondition condition, boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view)
protected LogicNode	canonicalizeCommonArithmetic(ValueNode forX, ValueNode forY, NodeView view)
protected static LogicNode	canonicalizeRangeFlip(ValueNode forX, ValueNode forY, int bits, boolean signed, NodeView view) Exploit the fact that adding the (signed) MIN_VALUE on both side flips signed and unsigned comparison.
protected abstract long	cast(long a, int bits)
protected abstract int	compare(long a, long b)
LogicConstantNode	constantOrNull(ValueNode x, ValueNode y, NodeView view) Tries to further canonicalize the condition, but only returns the result if it is constant.
LogicNode	create(ValueNode x, ValueNode y, NodeView view)
protected abstract IntegerLowerThanNode	createNode(ValueNode x, ValueNode y)
protected LogicNode	findSynonym(ValueNode forX, ValueNode forY, NodeView view)
protected abstract IntegerStamp	forInteger(int bits, long min, long max)
protected abstract CanonicalCondition	getCondition()
protected IntegerStamp	getSucceedingStampForX(IntegerStamp xStamp, IntegerStamp yStamp, boolean mirror, boolean strict)
protected IntegerStamp	getSucceedingStampForXLowerXPlusA(boolean mirrored, boolean strict, IntegerStamp aStamp, IntegerStamp xStamp)
protected abstract boolean	isMatchingBitExtendNode(ValueNode node) Return true if the node is an IntegerConvertNode that does not change the comparison result.
protected abstract boolean	leftShiftCanOverflow(IntegerStamp a, long shift) Return true if the a << shift can overflow w.r.t.
protected abstract long	lowerBound(IntegerStamp stamp)
protected abstract long	max(long a, long b)
protected long	max(long a, long b, int bits)
protected abstract long	maxValue(int bits)
protected abstract long	min(long a, long b)
protected long	min(long a, long b, int bits)
protected abstract long	minValue(int bits)
protected TriState	tryFold(Stamp xStampGeneric, Stamp yStampGeneric)
protected abstract long	upperBound(IntegerStamp stamp)

Methods inherited from class org.graalvm.compiler.nodes.calc.CompareNode.CompareOp

canonicalizeSymmetricConstant, duplicateModified, optimizeNormalizeCompare

Methods inherited from class java.lang.Object

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

Constructor Detail

LowerOp

public LowerOp()

Method Detail

canonical

public LogicNode canonical(ConstantReflectionProvider constantReflection,
                           MetaAccessProvider metaAccess,
                           OptionValues options,
                           Integer smallestCompareWidth,
                           CanonicalCondition condition,
                           boolean unorderedIsTrue,
                           ValueNode forX,
                           ValueNode forY,
                           NodeView view)

Overrides:

canonical in class CompareNode.CompareOp

upperBound

protected abstract long upperBound(IntegerStamp stamp)

lowerBound

protected abstract long lowerBound(IntegerStamp stamp)

compare

protected abstract int compare(long a,
                               long b)

min

protected abstract long min(long a,
                            long b)

max

protected abstract long max(long a,
                            long b)

min

protected long min(long a,
                   long b,
                   int bits)

max

protected long max(long a,
                   long b,
                   int bits)

cast

protected abstract long cast(long a,
                             int bits)

minValue

protected abstract long minValue(int bits)

maxValue

protected abstract long maxValue(int bits)

forInteger

protected abstract IntegerStamp forInteger(int bits,
                                           long min,
                                           long max)

getCondition

protected abstract CanonicalCondition getCondition()

createNode

protected abstract IntegerLowerThanNode createNode(ValueNode x,
                                                   ValueNode y)

create

public LogicNode create(ValueNode x,
                        ValueNode y,
                        NodeView view)

constantOrNull

public LogicConstantNode constantOrNull(ValueNode x,
                                        ValueNode y,
                                        NodeView view)

Tries to further canonicalize the condition, but only returns the result if it is constant.

See Also:

IntegerLowerThanNode.LowerOp.create(org.graalvm.compiler.nodes.ValueNode, org.graalvm.compiler.nodes.ValueNode, org.graalvm.compiler.nodes.NodeView)

findSynonym

protected LogicNode findSynonym(ValueNode forX,
                                ValueNode forY,
                                NodeView view)

canonicalizeCommonArithmetic

protected LogicNode canonicalizeCommonArithmetic(ValueNode forX,
                                                 ValueNode forY,
                                                 NodeView view)

isMatchingBitExtendNode

protected abstract boolean isMatchingBitExtendNode(ValueNode node)

Return true if the node is an IntegerConvertNode that does not change the comparison result.

addCanOverflow

protected abstract boolean addCanOverflow(IntegerStamp a,
                                          IntegerStamp b)

Return true if the a + b can overflow w.r.t. signed or unsigned semantics.

leftShiftCanOverflow

protected abstract boolean leftShiftCanOverflow(IntegerStamp a,
                                                long shift)

Return true if the a << shift can overflow w.r.t. signed or unsigned semantics.

canonicalizeRangeFlip

protected static LogicNode canonicalizeRangeFlip(ValueNode forX,
                                                 ValueNode forY,
                                                 int bits,
                                                 boolean signed,
                                                 NodeView view)

Exploit the fact that adding the (signed) MIN_VALUE on both side flips signed and unsigned comparison. In particular:

• x + MIN_VALUE < y + MIN_VALUE <=> x |<| y
• x + MIN_VALUE |<| y + MIN_VALUE <=> x < y

tryFold

protected TriState tryFold(Stamp xStampGeneric,
                           Stamp yStampGeneric)

getSucceedingStampForX

protected IntegerStamp getSucceedingStampForX(IntegerStamp xStamp,
                                              IntegerStamp yStamp,
                                              boolean mirror,
                                              boolean strict)

getSucceedingStampForXLowerXPlusA

protected IntegerStamp getSucceedingStampForXLowerXPlusA(boolean mirrored,
                                                         boolean strict,
                                                         IntegerStamp aStamp,
                                                         IntegerStamp xStamp)