Examples with CompareNode org.graalvm.compiler.nodes.calc.CompareNode used on opensource projects

Example 6 with CompareNode

use of org.graalvm.compiler.nodes.calc.CompareNode in project graal by oracle.

the class IfNode method removeIntermediateMaterialization.

/**
 * Tries to connect code that initializes a variable directly with the successors of an if
 * construct that switches on the variable. For example, the pseudo code below:
 *
 * <pre>
 * contains(list, e, yes, no) {
 *     if (list == null || e == null) {
 *         condition = false;
 *     } else {
 *         condition = false;
 *         for (i in list) {
 *             if (i.equals(e)) {
 *                 condition = true;
 *                 break;
 *             }
 *         }
 *     }
 *     if (condition) {
 *         return yes;
 *     } else {
 *         return no;
 *     }
 * }
 * </pre>
 *
 * will be transformed into:
 *
 * <pre>
 * contains(list, e, yes, no) {
 *     if (list == null || e == null) {
 *         return no;
 *     } else {
 *         condition = false;
 *         for (i in list) {
 *             if (i.equals(e)) {
 *                 return yes;
 *             }
 *         }
 *         return no;
 *     }
 * }
 * </pre>
 *
 * @return true if a transformation was made, false otherwise
 */
private boolean removeIntermediateMaterialization(SimplifierTool tool) {
    if (!(predecessor() instanceof AbstractMergeNode) || predecessor() instanceof LoopBeginNode) {
        return false;
    }
    AbstractMergeNode merge = (AbstractMergeNode) predecessor();
    if (!(condition() instanceof CompareNode)) {
        return false;
    }
    CompareNode compare = (CompareNode) condition();
    if (compare.getUsageCount() != 1) {
        return false;
    }
    // Only consider merges with a single usage that is both a phi and an operand of the
    // comparison
    NodeIterable<Node> mergeUsages = merge.usages();
    if (mergeUsages.count() != 1) {
        return false;
    }
    Node singleUsage = mergeUsages.first();
    if (!(singleUsage instanceof ValuePhiNode) || (singleUsage != compare.getX() && singleUsage != compare.getY())) {
        return false;
    }
    // Ensure phi is used by at most the comparison and the merge's frame state (if any)
    ValuePhiNode phi = (ValuePhiNode) singleUsage;
    NodeIterable<Node> phiUsages = phi.usages();
    if (phiUsages.count() > 2) {
        return false;
    }
    for (Node usage : phiUsages) {
        if (usage != compare && usage != merge.stateAfter()) {
            return false;
        }
    }
    List<EndNode> mergePredecessors = merge.cfgPredecessors().snapshot();
    assert phi.valueCount() == merge.forwardEndCount();
    Constant[] xs = constantValues(compare.getX(), merge, false);
    Constant[] ys = constantValues(compare.getY(), merge, false);
    if (xs == null || ys == null) {
        return false;
    }
    // Sanity check that both ends are not followed by a merge without frame state.
    if (!checkFrameState(trueSuccessor()) && !checkFrameState(falseSuccessor())) {
        return false;
    }
    List<EndNode> falseEnds = new ArrayList<>(mergePredecessors.size());
    List<EndNode> trueEnds = new ArrayList<>(mergePredecessors.size());
    EconomicMap<AbstractEndNode, ValueNode> phiValues = EconomicMap.create(Equivalence.IDENTITY, mergePredecessors.size());
    AbstractBeginNode oldFalseSuccessor = falseSuccessor();
    AbstractBeginNode oldTrueSuccessor = trueSuccessor();
    setFalseSuccessor(null);
    setTrueSuccessor(null);
    Iterator<EndNode> ends = mergePredecessors.iterator();
    for (int i = 0; i < xs.length; i++) {
        EndNode end = ends.next();
        phiValues.put(end, phi.valueAt(end));
        if (compare.condition().foldCondition(xs[i], ys[i], tool.getConstantReflection(), compare.unorderedIsTrue())) {
            trueEnds.add(end);
        } else {
            falseEnds.add(end);
        }
    }
    assert !ends.hasNext();
    assert falseEnds.size() + trueEnds.size() == xs.length;
    connectEnds(falseEnds, phiValues, oldFalseSuccessor, merge, tool);
    connectEnds(trueEnds, phiValues, oldTrueSuccessor, merge, tool);
    if (this.trueSuccessorProbability == 0.0) {
        for (AbstractEndNode endNode : trueEnds) {
            propagateZeroProbability(endNode);
        }
    }
    if (this.trueSuccessorProbability == 1.0) {
        for (AbstractEndNode endNode : falseEnds) {
            propagateZeroProbability(endNode);
        }
    }
    /*
         * Remove obsolete ends only after processing all ends, otherwise oldTrueSuccessor or
         * oldFalseSuccessor might have been removed if it is a LoopExitNode.
         */
    if (falseEnds.isEmpty()) {
        GraphUtil.killCFG(oldFalseSuccessor);
    }
    if (trueEnds.isEmpty()) {
        GraphUtil.killCFG(oldTrueSuccessor);
    }
    GraphUtil.killCFG(merge);
    assert !merge.isAlive() : merge;
    assert !phi.isAlive() : phi;
    assert !compare.isAlive() : compare;
    assert !this.isAlive() : this;
    return true;
}

Example 7 with CompareNode

use of org.graalvm.compiler.nodes.calc.CompareNode in project graal by oracle.

the class WordOperationPlugin method comparisonOp.

private ValueNode comparisonOp(GraphBuilderContext graph, Condition condition, ValueNode left, ValueNode right) {
    assert left.getStackKind() == wordKind && right.getStackKind() == wordKind;
    CanonicalizedCondition canonical = condition.canonicalize();
    ValueNode a = canonical.mustMirror() ? right : left;
    ValueNode b = canonical.mustMirror() ? left : right;
    CompareNode comparison;
    if (canonical.getCanonicalCondition() == CanonicalCondition.EQ) {
        comparison = new IntegerEqualsNode(a, b);
    } else if (canonical.getCanonicalCondition() == CanonicalCondition.BT) {
        comparison = new IntegerBelowNode(a, b);
    } else {
        assert canonical.getCanonicalCondition() == CanonicalCondition.LT;
        comparison = new IntegerLessThanNode(a, b);
    }
    ConstantNode trueValue = graph.add(forInt(1));
    ConstantNode falseValue = graph.add(forInt(0));
    if (canonical.mustNegate()) {
        ConstantNode temp = trueValue;
        trueValue = falseValue;
        falseValue = temp;
    }
    return graph.add(new ConditionalNode(graph.add(comparison), trueValue, falseValue));
}

Example 8 with CompareNode

use of org.graalvm.compiler.nodes.calc.CompareNode in project graal by oracle.

the class LoopFragmentInside method insertWithinAfter.

/**
 * Duplicate the body within the loop after the current copy copy of the body.
 *
 * @param loop
 * @param updateLimit true if the iteration limit should be adjusted.
 */
public void insertWithinAfter(LoopEx loop, boolean updateLimit) {
    assert isDuplicate() && original().loop() == loop;
    patchNodes(dataFixWithinAfter);
    /*
         * Collect any new back edges values before updating them since they might reference each
         * other.
         */
    LoopBeginNode mainLoopBegin = loop.loopBegin();
    ArrayList<ValueNode> backedgeValues = new ArrayList<>();
    for (PhiNode mainPhiNode : mainLoopBegin.phis()) {
        ValueNode duplicatedNode = getDuplicatedNode(mainPhiNode.valueAt(1));
        if (duplicatedNode == null) {
            if (mainLoopBegin.isPhiAtMerge(mainPhiNode.valueAt(1))) {
                duplicatedNode = ((PhiNode) (mainPhiNode.valueAt(1))).valueAt(1);
            } else {
                assert mainPhiNode.valueAt(1).isConstant() : mainPhiNode.valueAt(1);
            }
        }
        backedgeValues.add(duplicatedNode);
    }
    int index = 0;
    for (PhiNode mainPhiNode : mainLoopBegin.phis()) {
        ValueNode duplicatedNode = backedgeValues.get(index++);
        if (duplicatedNode != null) {
            mainPhiNode.setValueAt(1, duplicatedNode);
        }
    }
    placeNewSegmentAndCleanup(loop);
    // Remove any safepoints from the original copy leaving only the duplicated one
    assert loop.whole().nodes().filter(SafepointNode.class).count() == nodes().filter(SafepointNode.class).count();
    for (SafepointNode safepoint : loop.whole().nodes().filter(SafepointNode.class)) {
        graph().removeFixed(safepoint);
    }
    int unrollFactor = mainLoopBegin.getUnrollFactor();
    StructuredGraph graph = mainLoopBegin.graph();
    if (updateLimit) {
        // Now use the previous unrollFactor to update the exit condition to power of two
        InductionVariable iv = loop.counted().getCounter();
        CompareNode compareNode = (CompareNode) loop.counted().getLimitTest().condition();
        ValueNode compareBound;
        if (compareNode.getX() == iv.valueNode()) {
            compareBound = compareNode.getY();
        } else if (compareNode.getY() == iv.valueNode()) {
            compareBound = compareNode.getX();
        } else {
            throw GraalError.shouldNotReachHere();
        }
        long originalStride = unrollFactor == 1 ? iv.constantStride() : iv.constantStride() / unrollFactor;
        if (iv.direction() == InductionVariable.Direction.Up) {
            ConstantNode aboveVal = graph.unique(ConstantNode.forIntegerStamp(iv.initNode().stamp(NodeView.DEFAULT), unrollFactor * originalStride));
            ValueNode newLimit = graph.addWithoutUnique(new SubNode(compareBound, aboveVal));
            compareNode.replaceFirstInput(compareBound, newLimit);
        } else if (iv.direction() == InductionVariable.Direction.Down) {
            ConstantNode aboveVal = graph.unique(ConstantNode.forIntegerStamp(iv.initNode().stamp(NodeView.DEFAULT), unrollFactor * -originalStride));
            ValueNode newLimit = graph.addWithoutUnique(new AddNode(compareBound, aboveVal));
            compareNode.replaceFirstInput(compareBound, newLimit);
        }
    }
    mainLoopBegin.setUnrollFactor(unrollFactor * 2);
    mainLoopBegin.setLoopFrequency(mainLoopBegin.loopFrequency() / 2);
    graph.getDebug().dump(DebugContext.DETAILED_LEVEL, graph, "LoopPartialUnroll %s", loop);
    mainLoopBegin.getDebug().dump(DebugContext.VERBOSE_LEVEL, mainLoopBegin.graph(), "After insertWithinAfter %s", mainLoopBegin);
}

Example 9 with CompareNode

use of org.graalvm.compiler.nodes.calc.CompareNode in project graal by oracle.

the class LoopEx method detectCounted.

public boolean detectCounted() {
    LoopBeginNode loopBegin = loopBegin();
    FixedNode next = loopBegin.next();
    while (next instanceof FixedGuardNode || next instanceof ValueAnchorNode || next instanceof FullInfopointNode) {
        next = ((FixedWithNextNode) next).next();
    }
    if (next instanceof IfNode) {
        IfNode ifNode = (IfNode) next;
        boolean negated = false;
        if (!loopBegin.isLoopExit(ifNode.falseSuccessor())) {
            if (!loopBegin.isLoopExit(ifNode.trueSuccessor())) {
                return false;
            }
            negated = true;
        }
        LogicNode ifTest = ifNode.condition();
        if (!(ifTest instanceof IntegerLessThanNode) && !(ifTest instanceof IntegerEqualsNode)) {
            if (ifTest instanceof IntegerBelowNode) {
                ifTest.getDebug().log("Ignored potential Counted loop at %s with |<|", loopBegin);
            }
            return false;
        }
        CompareNode lessThan = (CompareNode) ifTest;
        Condition condition = null;
        InductionVariable iv = null;
        ValueNode limit = null;
        if (isOutsideLoop(lessThan.getX())) {
            iv = getInductionVariables().get(lessThan.getY());
            if (iv != null) {
                condition = lessThan.condition().asCondition().mirror();
                limit = lessThan.getX();
            }
        } else if (isOutsideLoop(lessThan.getY())) {
            iv = getInductionVariables().get(lessThan.getX());
            if (iv != null) {
                condition = lessThan.condition().asCondition();
                limit = lessThan.getY();
            }
        }
        if (condition == null) {
            return false;
        }
        if (negated) {
            condition = condition.negate();
        }
        boolean oneOff = false;
        switch(condition) {
            case EQ:
                return false;
            case NE:
                {
                    if (!iv.isConstantStride() || Math.abs(iv.constantStride()) != 1) {
                        return false;
                    }
                    IntegerStamp initStamp = (IntegerStamp) iv.initNode().stamp(NodeView.DEFAULT);
                    IntegerStamp limitStamp = (IntegerStamp) limit.stamp(NodeView.DEFAULT);
                    if (iv.direction() == Direction.Up) {
                        if (initStamp.upperBound() > limitStamp.lowerBound()) {
                            return false;
                        }
                    } else if (iv.direction() == Direction.Down) {
                        if (initStamp.lowerBound() < limitStamp.upperBound()) {
                            return false;
                        }
                    } else {
                        return false;
                    }
                    break;
                }
            case LE:
                oneOff = true;
                if (iv.direction() != Direction.Up) {
                    return false;
                }
                break;
            case LT:
                if (iv.direction() != Direction.Up) {
                    return false;
                }
                break;
            case GE:
                oneOff = true;
                if (iv.direction() != Direction.Down) {
                    return false;
                }
                break;
            case GT:
                if (iv.direction() != Direction.Down) {
                    return false;
                }
                break;
            default:
                throw GraalError.shouldNotReachHere();
        }
        counted = new CountedLoopInfo(this, iv, ifNode, limit, oneOff, negated ? ifNode.falseSuccessor() : ifNode.trueSuccessor());
        return true;
    }
    return false;
}

Example 10 with CompareNode

use of org.graalvm.compiler.nodes.calc.CompareNode in project graal by oracle.

the class AMD64NodeMatchRules method ifCompareLogicCas.

@MatchRule("(If (ObjectEquals=compare value LogicCompareAndSwap=cas))")
@MatchRule("(If (PointerEquals=compare value LogicCompareAndSwap=cas))")
@MatchRule("(If (FloatEquals=compare value LogicCompareAndSwap=cas))")
@MatchRule("(If (IntegerEquals=compare value LogicCompareAndSwap=cas))")
public ComplexMatchResult ifCompareLogicCas(IfNode root, CompareNode compare, ValueNode value, LogicCompareAndSwapNode cas) {
    JavaConstant constant = value.asJavaConstant();
    assert compare.condition() == CanonicalCondition.EQ;
    if (constant != null && cas.usages().count() == 1) {
        long constantValue = constant.asLong();
        boolean successIsTrue;
        if (constantValue == 0) {
            successIsTrue = false;
        } else if (constantValue == 1) {
            successIsTrue = true;
        } else {
            return null;
        }
        return builder -> {
            LIRKind kind = getLirKind(cas);
            LabelRef trueLabel = getLIRBlock(root.trueSuccessor());
            LabelRef falseLabel = getLIRBlock(root.falseSuccessor());
            double trueLabelProbability = root.probability(root.trueSuccessor());
            Value expectedValue = operand(cas.getExpectedValue());
            Value newValue = operand(cas.getNewValue());
            AMD64AddressValue address = (AMD64AddressValue) operand(cas.getAddress());
            Condition condition = successIsTrue ? Condition.EQ : Condition.NE;
            getLIRGeneratorTool().emitCompareAndSwapBranch(kind, address, expectedValue, newValue, condition, trueLabel, falseLabel, trueLabelProbability);
            return null;
        };
    }
    return null;
}