[GR-46028] Properly handle stamps with only high bit set

PullRequest: graal/14525

Author: tkrodriguez

compiler/src/jdk.internal.vm.compiler.test/src/org/graalvm/compiler/nodes/test/IntegerStampTest.java

@@ -777,4 +777,26 @@ public void testCanBeZero13() {
         IntegerStamp union = (IntegerStamp) stampWithZero.meet(stampWithoutZero);
         assertCanBeZero(union);
     }
+
+    /**
+     * Check that a stamp that only allows the high bit to be set properly handles a range that
+     * crosses 0 but doesn't include the min value.
+     */
+    @Test
+    public void testHighBitOnly() {
+        for (int shift = 0, initialBits = 8; shift < 4; shift++) {
+            int bits = initialBits << shift;
+            long lo = CodeUtil.minValue(bits) + 1;
+            long mustBeSet = 0L;
+            long mayBeSet = 1L << ((bits) - 1);
+            for (long hi = -1; hi < 1; hi++) {
+                IntegerStamp s = IntegerStamp.create(bits, lo, hi, mustBeSet, mayBeSet, true);
+                if (hi == 0) {
+                    Assert.assertTrue("Stamp = " + s, s.contains(0L));
+                } else {
+                    Assert.assertTrue("Stamp = " + s, s.isEmpty());
+                }
+            }
+        }
+    }
 }

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/core/common/type/IntegerStamp.java

@@ -390,39 +390,43 @@ private static long setOptionalBits(int bits, long bound, long mustBeSet, long m
      */
     private static long computeLowerBound(int bits, long lowerBound, long mustBeSet, long mayBeSet, boolean canBeZero) {
         long newLowerBound = minValueForMasks(bits, mustBeSet, mayBeSet);
+        final long optionalBits = mayBeSet & ~mustBeSet & CodeUtil.mask(bits - 1);
         if (newLowerBound < lowerBound) {
-            // First find the largest value which is less the current bound
-            final long optionalBits = mayBeSet & ~mustBeSet & CodeUtil.mask(bits - 1);
-            for (int position = bits - 1; position >= 0; position--) {
-                long bit = 1L << position;
-                if ((bit & optionalBits) != 0) {
-                    if (newLowerBound + bit <= lowerBound) {
-                        newLowerBound += bit;
+            if (optionalBits == 0) {
+                newLowerBound = 0;
+            } else {
+                // First find the largest value which is less than or equal to the current bound
+                for (int position = bits - 1; position >= 0; position--) {
+                    long bit = 1L << position;
+                    if ((bit & optionalBits) != 0) {
+                        if (newLowerBound + bit <= lowerBound) {
+                            newLowerBound += bit;
+                        }
                     }
                 }
-            }
-            GraalError.guarantee(newLowerBound <= lowerBound, "should have been sufficient");
-            if (newLowerBound < lowerBound) {
-                // Increment the first optional bit and then adjust the bits upward until it's
-                // compatible with the masks
-                boolean incremented = false;
-                for (int position = 0; position < bits - 1; position++) {
-                    long bit = 1L << position;
-                    if (incremented) {
-                        // We have to propagate any carried bit that changed any bits which must
-                        // be set or cleared.
-                        if ((bit & mustBeSet) != 0 && (newLowerBound & bit) == 0) {
-                            // A mustBeSet bit has been cleared so set it
-                            newLowerBound |= bit;
-                        }
-                        if ((bit & mayBeSet) == 0 && (newLowerBound & bit) != 0) {
-                            // A bit has carried into the clear section so it needs to propagate
-                            // into an mayBeSet bit.
+                GraalError.guarantee(newLowerBound <= lowerBound, "should have been sufficient");
+                if (newLowerBound < lowerBound) {
+                    // Increment the first optional bit and then adjust the bits upward until it's
+                    // compatible with the masks
+                    boolean incremented = false;
+                    for (int position = 0; position < bits - 1; position++) {
+                        long bit = 1L << position;
+                        if (incremented) {
+                            // We have to propagate any carried bit that changed any bits which must
+                            // be set or cleared.
+                            if ((bit & mustBeSet) != 0 && (newLowerBound & bit) == 0) {
+                                // A mustBeSet bit has been cleared so set it
+                                newLowerBound |= bit;
+                            }
+                            if ((bit & mayBeSet) == 0 && (newLowerBound & bit) != 0) {
+                                // A bit has carried into the clear section so it needs to propagate
+                                // into an mayBeSet bit.
+                                newLowerBound += bit;
+                            }
+                        } else if ((bit & optionalBits) != 0) {
                             newLowerBound += bit;
+                            incremented = true;
                         }
-                    } else if ((bit & optionalBits) != 0) {
-                        newLowerBound += bit;
-                        incremented = true;
                     }
                 }
             }