[GR-71120] Canonicalize disjoint or to add

PullRequest: graal/22518

Author: gergo-

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/CountedLoopTest.java

@@ -587,6 +587,22 @@ public void shiftLargeLong() {
         testCounted("shiftLargeLongSnippet");
     }
 
+    public static Result disjointOrToAddSnippet(int limit) {
+        Result ret = new Result();
+        int i;
+        for (i = 0; GraalDirectives.injectIterationCount(11, (i | 4) < limit); i += 8) {
+            GraalDirectives.controlFlowAnchor();
+            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i | 4);
+        }
+        ret.exitValue = get(InductionVariable::exitValueNode, i);
+        return ret;
+    }
+
+    @Test
+    public void disjointOrToAdd() {
+        testCounted("disjointOrToAddSnippet", 256);
+    }
+
     @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED)
     private static class IVPropertyNode extends FloatingNode implements LIRLowerable {
         public static final NodeClass<IVPropertyNode> TYPE = NodeClass.create(IVPropertyNode.class);

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/common/type/IntegerStamp.java

@@ -990,6 +990,12 @@ public static boolean negateCanOverflow(IntegerStamp stamp) {
         return stamp.lowerBound() == CodeUtil.minValue(stamp.getBits());
     }
 
+    /** Returns {@code true} if the two stamps cannot have any common set bits. */
+    public static boolean bitwiseDisjoint(IntegerStamp x, IntegerStamp y) {
+        GraalError.guarantee(x.getBits() == y.getBits(), "must be compatible: %s / %s", x, y);
+        return (x.mayBeSet() & y.mayBeSet()) == 0;
+    }
+
     public static final ArithmeticOpTable OPS = new ArithmeticOpTable(
 
                     new ArithmeticOpTable.UnaryOp.Neg() {

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/ValuePhiNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,6 +26,7 @@
 
 import java.util.Map;
 
+import jdk.graal.compiler.core.common.type.IntegerStamp;
 import jdk.graal.compiler.core.common.type.Stamp;
 import jdk.graal.compiler.core.common.type.StampFactory;
 import jdk.graal.compiler.debug.Assertions;
@@ -35,9 +36,11 @@
 import jdk.graal.compiler.graph.NodeInputList;
 import jdk.graal.compiler.nodeinfo.InputType;
 import jdk.graal.compiler.nodeinfo.NodeInfo;
+import jdk.graal.compiler.nodes.calc.AddNode;
 import jdk.graal.compiler.nodes.spi.LimitedValueProxy;
 import jdk.graal.compiler.nodes.type.StampTool;
 import jdk.graal.compiler.util.CollectionsUtil;
+import jdk.vm.ci.code.CodeUtil;
 
 /**
  * Value {@link PhiNode}s merge data flow values at control flow merges.
@@ -91,6 +94,7 @@ public boolean inferStamp() {
             valuesStamp = stamp;
         }
         valuesStamp = tryInferLoopPhiStamp(valuesStamp);
+        valuesStamp = tryImproveIntegerBits(valuesStamp);
         if (stamp.isCompatible(valuesStamp)) {
             valuesStamp = stamp.join(valuesStamp);
         }
@@ -176,6 +180,54 @@ private Stamp tryInferLoopPhiStamp(Stamp valuesStamp) {
         return valuesStamp;
     }
 
+    /**
+     * Tries to strengthen an integer-typed loop phi's bitmasks. This is meant for phis like the
+     * counter in the following loop:
+     *
+     * <pre>
+     *     for (int i = 0; i < limit; i += 8) ...
+     * </pre>
+     *
+     * In this loop, {@code i} will always be divisible by 8, even on overflow. We can derive this
+     * from the may-be-set masks of the inputs: Any low bits that are clear in both the initial
+     * value and the increment must also be clear in the phi's stamp.
+     *
+     * @param valuesStamp a stamp derived from this phi's direct inputs
+     * @return a stronger stamp than {@code valuesStamp} if lower bits could be cleared;
+     *         {@code valuesStamp} otherwise
+     */
+    private Stamp tryImproveIntegerBits(Stamp valuesStamp) {
+        if (isAlive() && isLoopPhi() && valuesStamp instanceof IntegerStamp integerStamp && singleBackValueOrThis() instanceof AddNode add && add.getX() == this) {
+            long valuesMask = integerStamp.mayBeSet();
+            long initMask = ((IntegerStamp) valueAt(0).stamp(NodeView.DEFAULT)).mayBeSet();
+            long incrementMask = ((IntegerStamp) add.getY().stamp(NodeView.DEFAULT)).mayBeSet();
+            int clearLowBits = Long.numberOfTrailingZeros(initMask | incrementMask);
+            if (Long.numberOfTrailingZeros(valuesMask) < clearLowBits) {
+                long improvedValuesMask = valuesMask & ~CodeUtil.mask(clearLowBits);
+                IntegerStamp improvedMaskStamp = IntegerStamp.stampForMask(integerStamp.getBits(), 0, improvedValuesMask);
+                return valuesStamp.improveWith(improvedMaskStamp);
+            }
+        }
+        return valuesStamp;
+    }
+
+    /**
+     * Update this phi's stamp by {@linkplain Stamp#tryImproveWith improving it with} the new
+     * information in the given stamp. This is necessary for cases where we have some high-level
+     * knowledge about this phi's value that's not expressed in the graph. It's illegal to call
+     * {@link #setStamp} on value phis because we override {@link #inferStamp()}}.
+     *
+     * @return {@code true} if the stamp was updated, {@code false} otherwise
+     */
+    public boolean refineStampWith(Stamp newInformation) {
+        Stamp improved = stamp.tryImproveWith(newInformation);
+        if (improved == null) {
+            return false;
+        } else {
+            return updateStamp(improved);
+        }
+    }
+
     private static Node stripProxies(Node n) {
         if (n instanceof ValueNode value) {
             return stripProxies(value);

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/calc/OrNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +39,6 @@
 import jdk.graal.compiler.nodes.spi.CanonicalizerTool;
 import jdk.graal.compiler.nodes.spi.NodeLIRBuilderTool;
 import jdk.graal.compiler.nodes.util.GraphUtil;
-
 import jdk.vm.ci.meta.Constant;
 
 @NodeInfo(shortName = "|")
@@ -94,6 +93,14 @@ private static ValueNode canonical(OrNode self, BinaryOp<Or> op, ValueNode forX,
                 return forX;
             } else if (((~yStamp.mustBeSet()) & xStamp.mayBeSet()) == 0) {
                 return forY;
+            } else if (IntegerStamp.bitwiseDisjoint(xStamp, yStamp)) {
+                /*
+                 * Representing a disjoint "or" as an add may help us discover induction variables.
+                 * However, don't destroy bit rotate patterns.
+                 */
+                if (!(forX instanceof ShiftNode<?> && forY instanceof ShiftNode<?>)) {
+                    return AddNode.create(forX, forY, view);
+                }
             }
         }