!fixup use llvm::absolutevalue, add more tests

Author: antoniofrighetto

llvm/lib/Transforms/Scalar/IndVarSimplify.cpp

@@ -231,16 +231,16 @@ bool IndVarSimplify::handleFloatingPointIV(Loop *L, PHINode *PN) {
   // 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))
+  const auto &InitValueFltSema = InitValueVal->getValueAPF().getSemantics();
+  if (!APFloat::isIEEELikeFP(InitValueFltSema))
     return false;
 
-  uint64_t StartValPrecision = APFloat::semanticsPrecision(SVFltSema);
-  if (StartValPrecision >= 64)
+  uint64_t InitValuePrecision = APFloat::semanticsPrecision(InitValueFltSema);
+  if (InitValuePrecision >= 64)
     return false;
 
-  uint64_t StartValIntegerLimit = 1LL << StartValPrecision;
-  if (uint64_t(std::abs(InitValue)) > StartValIntegerLimit)
+  uint64_t InitValueIntegerLimit = 1LL << InitValuePrecision;
+  if (AbsoluteValue(InitValue) > InitValueIntegerLimit)
     return false;
 
   // Check Incr uses. One user is PN and the other user is an exit condition
@@ -280,16 +280,16 @@ bool IndVarSimplify::handleFloatingPointIV(Loop *L, PHINode *PN) {
       !ConvertToSInt(ExitValueVal->getValueAPF(), ExitValue))
     return false;
 
-  const auto &EVFltSema = ExitValueVal->getValueAPF().getSemantics();
-  if (!APFloat::isIEEELikeFP(EVFltSema))
+  const auto &ExitValueFltSema = ExitValueVal->getValueAPF().getSemantics();
+  if (!APFloat::isIEEELikeFP(ExitValueFltSema))
     return false;
 
-  uint64_t ExitValPrecision = APFloat::semanticsPrecision(EVFltSema);
-  if (ExitValPrecision >= 64)
+  uint64_t ExitValuePrecision = APFloat::semanticsPrecision(ExitValueFltSema);
+  if (ExitValuePrecision >= 64)
     return false;
 
-  uint64_t ExitValIntegerLimit = 1LL << ExitValPrecision;
-  if (uint64_t(std::abs(ExitValue)) > ExitValIntegerLimit)
+  uint64_t ExitValueIntegerLimit = 1LL << ExitValuePrecision;
+  if (AbsoluteValue(ExitValue) > ExitValueIntegerLimit)
     return false;
 
   // Find new predicate for integer comparison.

llvm/test/Transforms/IndVarSimplify/floating-point-iv.ll

@@ -499,4 +499,61 @@ exit:
   ret void
 }
 
+define void @test_fp_to_int_irrealizable_exitval_int64_min() {
+; CHECK-LABEL: @test_fp_to_int_irrealizable_exitval_int64_min(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[LOOP:%.*]]
+; CHECK:       loop:
+; CHECK-NEXT:    [[IV:%.*]] = phi double [ 2.500000e+01, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
+; CHECK-NEXT:    call void @opaque()
+; CHECK-NEXT:    [[IV_NEXT]] = fadd double [[IV]], 1.700000e+01
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double [[IV_NEXT]], 0xC3E0000000000000
+; CHECK-NEXT:    br i1 [[CMP]], label [[EXIT:%.*]], label [[LOOP]]
+; CHECK:       exit:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %loop
+
+loop:
+  %iv = phi double [ 2.500000e+01, %entry ], [ %iv.next, %loop ]
+  call void @opaque()
+  %iv.next = fadd double %iv, 1.700000e+01
+  %cmp = fcmp ult double %iv.next, 0xC3E0000000000000
+  br i1 %cmp, label %exit, label %loop
+
+exit:
+  ret void
+}
+
+; Init value is 2^53 fp. While it would be within the representable consecutive
+; integers, start/stride/exit values currently needs to fit in a signed i32.
+
+define void @test_fp_to_int_maybe_realizable_initval_pow_2_53() {
+; CHECK-LABEL: @test_fp_to_int_maybe_realizable_initval_pow_2_53(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[LOOP:%.*]]
+; CHECK:       loop:
+; CHECK-NEXT:    [[IV:%.*]] = phi double [ 0x4340000000000000, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
+; CHECK-NEXT:    call void @opaque()
+; CHECK-NEXT:    [[IV_NEXT]] = fadd double [[IV]], -1.700000e+01
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double [[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 double [ 0x4340000000000000, %entry ], [ %iv.next, %loop ]
+  call void @opaque()
+  %iv.next = fadd double %iv, -1.700000e+01
+  %cmp = fcmp ult double %iv.next, 2.500000e+01
+  br i1 %cmp, label %exit, label %loop
+
+exit:
+  ret void
+}
+
 declare void @opaque()