src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes.test/src/org/graalvm/compiler/nodes/test/PrimitiveStampBoundaryTest.java

@@ -81,11 +81,11 @@
         integerTestStamps.add((PrimitiveStamp) StampFactory.empty(JavaKind.Int));
         integerTestStamps.add((PrimitiveStamp) StampFactory.empty(JavaKind.Long));
     }
 
     static double[] doubleBoundaryValues = {Double.NEGATIVE_INFINITY, Double.MIN_VALUE, Float.NEGATIVE_INFINITY, Float.MIN_VALUE,
-                    Long.MIN_VALUE, Long.MIN_VALUE + 1, Integer.MIN_VALUE, Integer.MIN_VALUE + 1, -1, 0, 1,
+                    Long.MIN_VALUE, Long.MIN_VALUE + 1, Integer.MIN_VALUE, Integer.MIN_VALUE + 1, -1, -0.0, +0.0, 1,
                     Integer.MAX_VALUE - 1, Integer.MAX_VALUE, Long.MAX_VALUE - 1, Long.MAX_VALUE,
                     Float.MAX_VALUE, Float.POSITIVE_INFINITY, Double.MAX_VALUE, Double.POSITIVE_INFINITY};
 
     static double[] doubleSpecialValues = {Double.NaN, -0.0, -0.0F, Float.NaN};
 

@@ -169,15 +169,28 @@
                 Stamp upper = boundaryStamp(stamp, true);
                 checkConvertOperation(op, op.foldStamp(stamp), lower);
                 checkConvertOperation(op, op.foldStamp(stamp), upper);
             }
         }
+
+    }
+
+    static void shouldConstantFold(boolean b, Stamp folded, Object o, Stamp s1) {
+        assertTrue(b || (folded instanceof FloatStamp && ((FloatStamp) folded).contains(0.0)), "should constant fold %s %s %s", o, s1, folded);
+    }
+
+    private static boolean constantFloatStampMayIncludeNegativeZero(Stamp s) {
+        if (s instanceof FloatStamp) {
+            FloatStamp f = (FloatStamp) s;
+            return Double.compare(f.lowerBound(), f.upperBound()) == 0 && f.isNonNaN();
+        }
+        return false;
     }
 
     private static void checkConvertOperation(ArithmeticOpTable.FloatConvertOp op, Stamp result, Stamp v1stamp) {
         Stamp folded = op.foldStamp(v1stamp);
-        assertTrue(folded.isEmpty() || folded.asConstant() != null, "should constant fold %s %s %s", op, v1stamp, folded);
+        shouldConstantFold(folded.isEmpty() || folded.asConstant() != null, folded, op, v1stamp);
         assertTrue(result.meet(folded).equals(result), "result out of range %s %s %s %s %s", op, v1stamp, folded, result, result.meet(folded));
     }
 
     @Test
     public void testShiftBoundaryValues() {

@@ -214,10 +227,13 @@
         assertTrue(folded.asConstant() != null, "should constant fold %s %s %s %s", op, v1stamp, v2stamp, folded);
         assertTrue(result.meet(folded).equals(result), "result out of range %s %s %s %s %s %s", op, v1stamp, v2stamp, folded, result, result.meet(folded));
     }
 
     private static void checkBinaryOperation(ArithmeticOpTable.BinaryOp<?> op, Stamp result, Stamp v1stamp, Stamp v2stamp) {
+        if (constantFloatStampMayIncludeNegativeZero(v1stamp) || constantFloatStampMayIncludeNegativeZero(v2stamp)) {
+            return;
+        }
         Stamp folded = op.foldStamp(v1stamp, v2stamp);
         if (v1stamp.isEmpty() || v2stamp.isEmpty()) {
             assertTrue(folded.isEmpty());
             assertTrue(v1stamp.asConstant() != null || v1stamp.isEmpty());
             assertTrue(v2stamp.asConstant() != null || v2stamp.isEmpty());