[ConstantFPRange] Add rounding mode parameter

Author: dtcxzyw

llvm/include/llvm/IR/ConstantFPRange.h

@@ -201,8 +201,11 @@ class [[nodiscard]] ConstantFPRange {
   /// elements of both sets, but may contain more.
   LLVM_ABI ConstantFPRange unionWith(const ConstantFPRange &CR) const;
 
-  /// Return a new range in the specified format.
-  LLVM_ABI ConstantFPRange cast(const fltSemantics &DstSem) const;
+  /// Return a new range in the specified format with the specified rounding
+  /// mode.
+  LLVM_ABI ConstantFPRange
+  cast(const fltSemantics &DstSem,
+       APFloat::roundingMode RM = APFloat::rmNearestTiesToEven) const;
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const ConstantFPRange &CR) {

llvm/lib/IR/ConstantFPRange.cpp

@@ -326,6 +326,8 @@ std::optional<bool> ConstantFPRange::getSignBit() const {
 }
 
 bool ConstantFPRange::operator==(const ConstantFPRange &CR) const {
+  assert(&getSemantics() == &CR.getSemantics() &&
+         "Should only use the same semantics");
   if (MayBeSNaN != CR.MayBeSNaN || MayBeQNaN != CR.MayBeQNaN)
     return false;
   return Lower.bitwiseIsEqual(CR.Lower) && Upper.bitwiseIsEqual(CR.Upper);
@@ -392,17 +394,16 @@ ConstantFPRange ConstantFPRange::unionWith(const ConstantFPRange &CR) const {
                          MayBeQNaN | CR.MayBeQNaN, MayBeSNaN | CR.MayBeSNaN);
 }
 
-ConstantFPRange ConstantFPRange::cast(const fltSemantics &DstSem) const {
+ConstantFPRange ConstantFPRange::cast(const fltSemantics &DstSem,
+                                      APFloat::roundingMode RM) const {
   bool LosesInfo;
   APFloat NewLower = Lower;
   APFloat NewUpper = Upper;
   // For conservative, return full range if conversion is invalid.
-  if (NewLower.convert(DstSem, APFloat::rmNearestTiesToEven, &LosesInfo) ==
-          APFloat::opInvalidOp ||
+  if (NewLower.convert(DstSem, RM, &LosesInfo) == APFloat::opInvalidOp ||
       NewLower.isNaN())
     return getFull(DstSem);
-  if (NewUpper.convert(DstSem, APFloat::rmNearestTiesToEven, &LosesInfo) ==
-          APFloat::opInvalidOp ||
+  if (NewUpper.convert(DstSem, RM, &LosesInfo) == APFloat::opInvalidOp ||
       NewUpper.isNaN())
     return getFull(DstSem);
   return ConstantFPRange(std::move(NewLower), std::move(NewUpper),

llvm/unittests/IR/ConstantFPRangeTest.cpp

@@ -828,6 +828,28 @@ TEST_F(ConstantFPRangeTest, cast) {
                                        APFloat::getInf(Sem, /*Negative=*/false))
                 .cast(F8NanOnlySem),
             ConstantFPRange::getFull(F8NanOnlySem));
+  // other rounding modes
+  EXPECT_EQ(
+      ConstantFPRange::getNonNaN(APFloat::getSmallest(Sem, /*Negative=*/true),
+                                 APFloat::getSmallest(Sem, /*Negative=*/false))
+          .cast(F32Sem, APFloat::rmTowardNegative),
+      ConstantFPRange::getNonNaN(
+          APFloat::getSmallest(F32Sem, /*Negative=*/true),
+          APFloat::getZero(F32Sem, /*Negative=*/false)));
+  EXPECT_EQ(
+      ConstantFPRange::getNonNaN(APFloat::getSmallest(Sem, /*Negative=*/true),
+                                 APFloat::getSmallest(Sem, /*Negative=*/false))
+          .cast(F32Sem, APFloat::rmTowardPositive),
+      ConstantFPRange::getNonNaN(
+          APFloat::getZero(F32Sem, /*Negative=*/true),
+          APFloat::getSmallest(F32Sem, /*Negative=*/false)));
+  EXPECT_EQ(
+      ConstantFPRange::getNonNaN(
+          APFloat::getSmallestNormalized(Sem, /*Negative=*/true),
+          APFloat::getSmallestNormalized(Sem, /*Negative=*/false))
+          .cast(F32Sem, APFloat::rmTowardZero),
+      ConstantFPRange::getNonNaN(APFloat::getZero(F32Sem, /*Negative=*/true),
+                                 APFloat::getZero(F32Sem, /*Negative=*/false)));
 
   EnumerateValuesInConstantFPRange(
       ConstantFPRange::getFull(APFloat::Float8E4M3()),