llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: Antonio Frighetto (antoniofrighetto)
<details>
<summary>Changes</summary>
When transforming floating-point induction variables into integer ones, make sure we stay within the bounds of fp values that can be represented as integers without gaps, i.e., 2^24 and 2^53 for IEEE-754 single and double precision respectively (both on negative and positive side).
Fixes: https://github.com/llvm/llvm-project/issues/166496.
---
Full diff: https://github.com/llvm/llvm-project/pull/166649.diff
2 Files Affected:
- (modified) llvm/lib/Transforms/Scalar/IndVarSimplify.cpp (+27)
- (modified) llvm/test/Transforms/IndVarSimplify/floating-point-iv.ll (+83)
``````````diff
diff --git a/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp b/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
index 4ba4ba3850e58..0df8670942212 100644
--- a/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -228,6 +228,21 @@ bool IndVarSimplify::handleFloatingPointIV(Loop *L, PHINode *PN) {
!ConvertToSInt(IncValueVal->getValueAPF(), IncValue))
return false;
+ // Ensure we stay within the bounds of fp values that can be represented
+ // as integers without gaps, i.e., 2^24 and 2^53 for IEEE-754 single and
+ // double precision respectively (both on negative and positive side).
+ const auto &SVFltSema = InitValueVal->getValueAPF().getSemantics();
+ if (!APFloat::isIEEELikeFP(SVFltSema))
+ return false;
+
+ uint64_t StartValPrecision = APFloat::semanticsPrecision(SVFltSema);
+ if (StartValPrecision >= 64)
+ return false;
+
+ uint64_t StartValIntegerLimit = 1LL << StartValPrecision;
+ if (uint64_t(std::abs(InitValue)) > StartValIntegerLimit)
+ return false;
+
// Check Incr uses. One user is PN and the other user is an exit condition
// used by the conditional terminator.
Value::user_iterator IncrUse = Incr->user_begin();
@@ -265,6 +280,18 @@ bool IndVarSimplify::handleFloatingPointIV(Loop *L, PHINode *PN) {
!ConvertToSInt(ExitValueVal->getValueAPF(), ExitValue))
return false;
+ const auto &EVFltSema = ExitValueVal->getValueAPF().getSemantics();
+ if (!APFloat::isIEEELikeFP(EVFltSema))
+ return false;
+
+ uint64_t ExitValPrecision = APFloat::semanticsPrecision(EVFltSema);
+ if (ExitValPrecision >= 64)
+ return false;
+
+ uint64_t ExitValIntegerLimit = 1LL << ExitValPrecision;
+ if (uint64_t(std::abs(ExitValue)) > ExitValIntegerLimit)
+ return false;
+
// Find new predicate for integer comparison.
CmpInst::Predicate NewPred = CmpInst::BAD_ICMP_PREDICATE;
switch (Compare->getPredicate()) {
diff --git a/llvm/test/Transforms/IndVarSimplify/floating-point-iv.ll b/llvm/test/Transforms/IndVarSimplify/floating-point-iv.ll
index b1ef50382c070..e3e6f5e1d2a6f 100644
--- a/llvm/test/Transforms/IndVarSimplify/floating-point-iv.ll
+++ b/llvm/test/Transforms/IndVarSimplify/floating-point-iv.ll
@@ -417,3 +417,86 @@ loop:
exit:
ret void
}
+
+define void @test_fp_to_int_irrealizable_initval() {
+; CHECK-LABEL: @test_fp_to_int_irrealizable_initval(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[LOOP:%.*]]
+; CHECK: loop:
+; CHECK-NEXT: [[IV:%.*]] = phi float [ 1.000000e+08, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
+; CHECK-NEXT: call void @opaque()
+; CHECK-NEXT: [[IV_NEXT]] = fadd float [[IV]], -1.700000e+01
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[IV_NEXT]], 2.500000e+01
+; CHECK-NEXT: br i1 [[CMP]], label [[EXIT:%.*]], label [[LOOP]]
+; CHECK: exit:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi float [ 1.000000e+08, %entry ], [ %iv.next, %loop ]
+ call void @opaque()
+ %iv.next = fadd float %iv, -1.700000e+01
+ %cmp = fcmp ult float %iv.next, 2.500000e+01
+ br i1 %cmp, label %exit, label %loop
+
+exit:
+ ret void
+}
+
+define void @test_fp_to_int_irrealizable_exitval() {
+; CHECK-LABEL: @test_fp_to_int_irrealizable_exitval(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[LOOP:%.*]]
+; CHECK: loop:
+; CHECK-NEXT: [[IV:%.*]] = phi float [ 2.500000e+01, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
+; CHECK-NEXT: call void @opaque()
+; CHECK-NEXT: [[IV_NEXT]] = fadd float [[IV]], 1.700000e+01
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[IV_NEXT]], 1.000000e+08
+; CHECK-NEXT: br i1 [[CMP]], label [[EXIT:%.*]], label [[LOOP]]
+; CHECK: exit:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi float [ 2.500000e+01, %entry ], [ %iv.next, %loop ]
+ call void @opaque()
+ %iv.next = fadd float %iv, 1.700000e+01
+ %cmp = fcmp ugt float %iv.next, 1.000000e+08
+ br i1 %cmp, label %exit, label %loop
+
+exit:
+ ret void
+}
+
+define void @test_fp_to_int_irrealizable_negative_exitval() {
+; CHECK-LABEL: @test_fp_to_int_irrealizable_negative_exitval(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: br label [[LOOP:%.*]]
+; CHECK: loop:
+; CHECK-NEXT: [[IV:%.*]] = phi float [ -2.500000e+01, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
+; CHECK-NEXT: call void @opaque()
+; CHECK-NEXT: [[IV_NEXT]] = fadd float [[IV]], -1.700000e+01
+; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[IV_NEXT]], -1.000000e+08
+; CHECK-NEXT: br i1 [[CMP]], label [[EXIT:%.*]], label [[LOOP]]
+; CHECK: exit:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi float [ -2.500000e+01, %entry ], [ %iv.next, %loop ]
+ call void @opaque()
+ %iv.next = fadd float %iv, -1.700000e+01
+ %cmp = fcmp ult float %iv.next, -1.000000e+08
+ br i1 %cmp, label %exit, label %loop
+
+exit:
+ ret void
+}
+
+declare void @opaque()
``````````
</details>
https://github.com/llvm/llvm-project/pull/166649