Add unsigned integer from/to float conversion ops.

Author: woess

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/common/NumUtil.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2024, 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
@@ -442,4 +442,39 @@ public static int unsafeAbs(int i) {
     public static long unsafeAbs(long l) {
         return Math.abs(l);
     }
+
+    /**
+     * Converts the double value to unsigned long, rounding toward zero.
+     */
+    public static long toUnsignedLong(double value) {
+        if (value >= 0x1p63) {
+            return (long) (value - 0x1p63) + Long.MIN_VALUE;
+        } else if (value >= 0) {
+            return (long) value;
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * Converts the unsigned long value to the nearest double value.
+     */
+    public static double unsignedToDouble(long value) {
+        if (value >= 0) {
+            return value;
+        } else {
+            return ((value >>> 1) | (value & 1)) * 2.0;
+        }
+    }
+
+    /**
+     * Converts the unsigned long value to the nearest float value.
+     */
+    public static float unsignedToFloat(long value) {
+        if (value >= 0) {
+            return value;
+        } else {
+            return ((value >>> 1) | (value & 1)) * 2.0f;
+        }
+    }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/common/calc/FloatConvert.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -40,7 +40,17 @@ public enum FloatConvert {
     D2F(FloatConvertCategory.FloatingPointToFloatingPoint, 64),
     I2D(FloatConvertCategory.IntegerToFloatingPoint, 32),
     L2D(FloatConvertCategory.IntegerToFloatingPoint, 64),
-    F2D(FloatConvertCategory.FloatingPointToFloatingPoint, 32);
+    F2D(FloatConvertCategory.FloatingPointToFloatingPoint, 32),
+
+    // to or from unsigned integer
+    F2UI(FloatConvertCategory.FloatingPointToInteger, 32),
+    D2UI(FloatConvertCategory.FloatingPointToInteger, 64),
+    F2UL(FloatConvertCategory.FloatingPointToInteger, 32),
+    D2UL(FloatConvertCategory.FloatingPointToInteger, 64),
+    UI2F(FloatConvertCategory.IntegerToFloatingPoint, 32),
+    UL2F(FloatConvertCategory.IntegerToFloatingPoint, 64),
+    UI2D(FloatConvertCategory.IntegerToFloatingPoint, 32),
+    UL2D(FloatConvertCategory.IntegerToFloatingPoint, 64);
 
     private final FloatConvertCategory category;
     private final int inputBits;
@@ -55,30 +65,27 @@ public FloatConvertCategory getCategory() {
     }
 
     public FloatConvert reverse() {
-        switch (this) {
-            case D2F:
-                return F2D;
-            case D2I:
-                return I2D;
-            case D2L:
-                return L2D;
-            case F2D:
-                return D2F;
-            case F2I:
-                return I2F;
-            case F2L:
-                return L2F;
-            case I2D:
-                return D2I;
-            case I2F:
-                return F2I;
-            case L2D:
-                return D2L;
-            case L2F:
-                return F2L;
-            default:
-                throw GraalError.shouldNotReachHereUnexpectedValue(this); // ExcludeFromJacocoGeneratedReport
-        }
+        return switch (this) {
+            case D2F -> F2D;
+            case D2I -> I2D;
+            case D2L -> L2D;
+            case F2D -> D2F;
+            case F2I -> I2F;
+            case F2L -> L2F;
+            case I2D -> D2I;
+            case I2F -> F2I;
+            case L2D -> D2L;
+            case L2F -> F2L;
+            case F2UI -> UI2F;
+            case D2UI -> UI2D;
+            case F2UL -> UL2F;
+            case D2UL -> UL2D;
+            case UI2F -> F2UI;
+            case UL2F -> F2UL;
+            case UI2D -> D2UI;
+            case UL2D -> D2UL;
+            default -> throw GraalError.shouldNotReachHereUnexpectedValue(this); // ExcludeFromJacocoGeneratedReport
+        };
     }
 
     public int getInputBits() {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -27,9 +27,13 @@
 import static jdk.graal.compiler.core.common.calc.FloatConvert.D2F;
 import static jdk.graal.compiler.core.common.calc.FloatConvert.D2I;
 import static jdk.graal.compiler.core.common.calc.FloatConvert.D2L;
+import static jdk.graal.compiler.core.common.calc.FloatConvert.D2UI;
+import static jdk.graal.compiler.core.common.calc.FloatConvert.D2UL;
 import static jdk.graal.compiler.core.common.calc.FloatConvert.F2D;
 import static jdk.graal.compiler.core.common.calc.FloatConvert.F2I;
 import static jdk.graal.compiler.core.common.calc.FloatConvert.F2L;
+import static jdk.graal.compiler.core.common.calc.FloatConvert.F2UI;
+import static jdk.graal.compiler.core.common.calc.FloatConvert.F2UL;
 
 import java.nio.ByteBuffer;
 import java.util.function.DoubleBinaryOperator;
@@ -456,21 +460,27 @@ private static Stamp maybeFoldConstant(ArithmeticOpTable.BinaryOp<?> op, FloatSt
     }
 
     public static boolean floatingToIntegerCanOverflow(FloatStamp floatStamp, int integerBits) {
+        return floatingToIntegerCanOverflow(floatStamp, integerBits, false);
+    }
+
+    public static boolean floatingToIntegerCanOverflow(FloatStamp floatStamp, int integerBits, boolean unsigned) {
         final boolean canBeInfinity = Double.isInfinite(floatStamp.lowerBound()) || Double.isInfinite(floatStamp.upperBound());
         if (canBeInfinity) {
             return true;
         }
-        final boolean conversionCanOverflow = integralPartLargerMaxValue(floatStamp, integerBits) || integralPartSmallerMinValue(floatStamp, integerBits);
+        final boolean conversionCanOverflow = integralPartLargerMaxValue(floatStamp, integerBits, unsigned) || integralPartSmallerMinValue(floatStamp, integerBits, unsigned);
         return conversionCanOverflow;
     }
 
-    private static boolean integralPartLargerMaxValue(FloatStamp floatStamp, int integerBits) {
+    private static boolean integralPartLargerMaxValue(FloatStamp floatStamp, int integerBits, boolean unsigned) {
         double upperBound = floatStamp.upperBound();
         if (Double.isInfinite(upperBound) || Double.isNaN(upperBound)) {
             return true;
         }
         assert integerBits == 32 || integerBits == 64 : "Must be int or long " + Assertions.errorMessage(integerBits, upperBound);
-        long maxValue = NumUtil.maxValue(integerBits);
+        double maxValue = unsigned
+                        ? NumUtil.unsignedToDouble(NumUtil.maxValueUnsigned(integerBits))
+                        : NumUtil.maxValue(integerBits);
         /*
          * There could be conversion loss here when casting maxValue from long to double - given
          * that max can be Long.MAX_VALUE. In order to avoid checking if upperBound is larger than
@@ -482,17 +492,23 @@ private static boolean integralPartLargerMaxValue(FloatStamp floatStamp, int int
          * Long.MAX_VALUE) == 9223372036854774784, which fits into long. So if upperBound >=
          * (double) maxValue does not hold, i.e., upperBound < (double) maxValue does hold, then
          * (long) upperBound will not overflow.
+         *
+         * Similarly, for the unsigned case, unsignedToDouble(-1L) is 18446744073709551616 (2**64),
+         * which is 1 more than the unsigned long max value, i.e. 18446744073709551615 (2**64 - 1).
+         * So toUnsignedLong(unsignedToDouble(-1L)) will already overflow. The next lower double
+         * value is Math.nextDown(0x1p64) == 18446744073709549568, which fits into unsigned long.
+         * The same overflow condition reasoning as for the signed long case applies.
          */
         return upperBound >= maxValue;
     }
 
-    private static boolean integralPartSmallerMinValue(FloatStamp floatStamp, int integerBits) {
+    private static boolean integralPartSmallerMinValue(FloatStamp floatStamp, int integerBits, boolean unsigned) {
         double lowerBound = floatStamp.lowerBound();
         if (Double.isInfinite(lowerBound) || Double.isNaN(lowerBound)) {
             return true;
         }
         assert integerBits == 32 || integerBits == 64 : "Must be int or long " + Assertions.errorMessage(integerBits, lowerBound);
-        long minValue = NumUtil.minValue(integerBits);
+        double minValue = unsigned ? 0 : NumUtil.minValue(integerBits);
         return lowerBound <= minValue;
     }
 
@@ -1677,6 +1693,114 @@ protected Stamp foldStampImpl(Stamp stamp) {
                             assert floatStamp.getBits() == 64 : Assertions.errorMessage(floatStamp);
                             return StampFactory.forFloat(JavaKind.Float, (float) floatStamp.lowerBound(), (float) floatStamp.upperBound(), floatStamp.isNonNaN());
                         }
+                    },
+
+                    new ArithmeticOpTable.FloatConvertOp(F2UI) {
+
+                        @Override
+                        public Constant foldConstant(Constant c) {
+                            PrimitiveConstant value = (PrimitiveConstant) c;
+                            return JavaConstant.forInt((int) NumUtil.minUnsigned(NumUtil.toUnsignedLong(value.asFloat()), 0xffff_ffffL));
+                        }
+
+                        @Override
+                        protected Stamp foldStampImpl(Stamp stamp) {
+                            if (stamp.isEmpty()) {
+                                return StampFactory.empty(JavaKind.Int);
+                            }
+                            FloatStamp floatStamp = (FloatStamp) stamp;
+                            assert floatStamp.getBits() == 32 : floatStamp;
+                            long lowerBound = floatStamp.canBeNaN() ? 0
+                                            : NumUtil.minUnsigned(NumUtil.toUnsignedLong(floatStamp.lowerBound()), 0xffff_ffffL);
+                            long upperBound = NumUtil.minUnsigned(NumUtil.toUnsignedLong(floatStamp.upperBound()), 0xffff_ffffL);
+                            return StampFactory.forUnsignedInteger(JavaKind.Int.getBitCount(), lowerBound, upperBound);
+                        }
+
+                        @Override
+                        public boolean canOverflowInteger(Stamp inputStamp) {
+                            return inputStamp instanceof FloatStamp floatStamp && floatingToIntegerCanOverflow(floatStamp, Integer.SIZE, true);
+                        }
+                    },
+
+                    new ArithmeticOpTable.FloatConvertOp(F2UL) {
+
+                        @Override
+                        public Constant foldConstant(Constant c) {
+                            PrimitiveConstant value = (PrimitiveConstant) c;
+                            return JavaConstant.forLong(NumUtil.toUnsignedLong(value.asFloat()));
+                        }
+
+                        @Override
+                        protected Stamp foldStampImpl(Stamp stamp) {
+                            if (stamp.isEmpty()) {
+                                return StampFactory.empty(JavaKind.Long);
+                            }
+                            FloatStamp floatStamp = (FloatStamp) stamp;
+                            assert floatStamp.getBits() == 32 : floatStamp;
+                            long lowerBound = floatStamp.canBeNaN() ? 0
+                                            : NumUtil.toUnsignedLong(floatStamp.lowerBound());
+                            long upperBound = NumUtil.toUnsignedLong(floatStamp.upperBound());
+                            return StampFactory.forUnsignedInteger(JavaKind.Long.getBitCount(), lowerBound, upperBound);
+                        }
+
+                        @Override
+                        public boolean canOverflowInteger(Stamp inputStamp) {
+                            return inputStamp instanceof FloatStamp floatStamp && floatingToIntegerCanOverflow(floatStamp, Long.SIZE, true);
+                        }
+                    },
+
+                    new ArithmeticOpTable.FloatConvertOp(D2UI) {
+
+                        @Override
+                        public Constant foldConstant(Constant c) {
+                            PrimitiveConstant value = (PrimitiveConstant) c;
+                            return JavaConstant.forInt((int) NumUtil.minUnsigned(NumUtil.toUnsignedLong(value.asDouble()), 0xffff_ffffL));
+                        }
+
+                        @Override
+                        protected Stamp foldStampImpl(Stamp stamp) {
+                            if (stamp.isEmpty()) {
+                                return StampFactory.empty(JavaKind.Int);
+                            }
+                            FloatStamp floatStamp = (FloatStamp) stamp;
+                            assert floatStamp.getBits() == 64 : floatStamp;
+                            long lowerBound = floatStamp.canBeNaN() ? 0
+                                            : NumUtil.minUnsigned(NumUtil.toUnsignedLong(floatStamp.lowerBound()), 0xffff_ffffL);
+                            long upperBound = NumUtil.minUnsigned(NumUtil.toUnsignedLong(floatStamp.upperBound()), 0xffff_ffffL);
+                            return StampFactory.forUnsignedInteger(JavaKind.Int.getBitCount(), lowerBound, upperBound);
+                        }
+
+                        @Override
+                        public boolean canOverflowInteger(Stamp inputStamp) {
+                            return inputStamp instanceof FloatStamp floatStamp && floatingToIntegerCanOverflow(floatStamp, Integer.SIZE, true);
+                        }
+                    },
+
+                    new ArithmeticOpTable.FloatConvertOp(D2UL) {
+
+                        @Override
+                        public Constant foldConstant(Constant c) {
+                            PrimitiveConstant value = (PrimitiveConstant) c;
+                            return JavaConstant.forLong(NumUtil.toUnsignedLong(value.asDouble()));
+                        }
+
+                        @Override
+                        protected Stamp foldStampImpl(Stamp stamp) {
+                            if (stamp.isEmpty()) {
+                                return StampFactory.empty(JavaKind.Long);
+                            }
+                            FloatStamp floatStamp = (FloatStamp) stamp;
+                            assert floatStamp.getBits() == 64 : floatStamp;
+                            long lowerBound = floatStamp.canBeNaN() ? 0
+                                            : NumUtil.toUnsignedLong(floatStamp.lowerBound());
+                            long upperBound = NumUtil.toUnsignedLong(floatStamp.upperBound());
+                            return StampFactory.forUnsignedInteger(JavaKind.Long.getBitCount(), lowerBound, upperBound);
+                        }
+
+                        @Override
+                        public boolean canOverflowInteger(Stamp inputStamp) {
+                            return inputStamp instanceof FloatStamp floatStamp && floatingToIntegerCanOverflow(floatStamp, Long.SIZE, true);
+                        }
                     });
 
     // Use a separate class to avoid initialization cycles