From: Joshua Cao Date: Mon, 24 Apr 2023 08:39:13 +0000 (-0700) Subject: Revert "[SCEV] Precise trip multiples" X-Git-Tag: upstream/17.0.6~10664 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a4e420ea642ad8a375458e3e975fe21b610b5081;p=platform%2Fupstream%2Fllvm.git Revert "[SCEV] Precise trip multiples" This reverts commit 027a4c8b96c7f97df8e98b1dac069b956810ab94. --- diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h index 7dd90203925d..f27cf22639c9 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolution.h +++ b/llvm/include/llvm/Analysis/ScalarEvolution.h @@ -964,12 +964,6 @@ public: /// If S is guaranteed to be 0, it returns the bitwidth of S. uint32_t getMinTrailingZeros(const SCEV *S); - /// Returns the max constant multiple of S. - APInt getConstantMultiple(const SCEV *S); - - // Returns the max constant multiple of S. If S is exactly 0, return 1. - APInt getNonZeroConstantMultiple(const SCEV *S); - /// Determine the unsigned range for a particular SCEV. /// NOTE: This returns a copy of the reference returned by getRangeRef. ConstantRange getUnsignedRange(const SCEV *S) { @@ -1437,14 +1431,14 @@ private: /// predicate by splitting it into a set of independent predicates. bool ProvingSplitPredicate = false; - /// Memoized values for the getConstantMultiple - DenseMap ConstantMultipleCache; + /// Memoized values for the GetMinTrailingZeros + DenseMap MinTrailingZerosCache; /// Return the Value set from which the SCEV expr is generated. ArrayRef getSCEVValues(const SCEV *S); - /// Private helper method for the getConstantMultiple method. - APInt getConstantMultipleImpl(const SCEV *S); + /// Private helper method for the GetMinTrailingZeros method + uint32_t getMinTrailingZerosImpl(const SCEV *S); /// Information about the number of times a particular loop exit may be /// reached before exiting the loop. diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index c00cf62fc035..f12013f4ff62 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -6281,87 +6281,59 @@ const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) { return getGEPExpr(GEP, IndexExprs); } -APInt ScalarEvolution::getConstantMultipleImpl(const SCEV *S) { - uint64_t BitWidth = getTypeSizeInBits(S->getType()); - auto GetShiftedByZeros = [BitWidth](uint32_t TrailingZeros) { - return TrailingZeros >= BitWidth - ? APInt::getZero(BitWidth) - : APInt::getOneBitSet(BitWidth, TrailingZeros); - }; - +uint32_t ScalarEvolution::getMinTrailingZerosImpl(const SCEV *S) { switch (S->getSCEVType()) { case scConstant: - return cast(S)->getAPInt(); - case scPtrToInt: - return getConstantMultiple(cast(S)->getOperand()); - case scUDivExpr: - case scVScale: - return APInt(BitWidth, 1); + return cast(S)->getAPInt().countr_zero(); case scTruncate: { - // Only multiples that are a power of 2 will hold after truncation. const SCEVTruncateExpr *T = cast(S); - uint32_t TZ = getMinTrailingZeros(T->getOperand()); - return GetShiftedByZeros(TZ); - } - case scZeroExtend: { - const SCEVZeroExtendExpr *Z = cast(S); - return getConstantMultiple(Z->getOperand()).zext(BitWidth); + return std::min(getMinTrailingZeros(T->getOperand()), + (uint32_t)getTypeSizeInBits(T->getType())); } + case scZeroExtend: case scSignExtend: { - const SCEVSignExtendExpr *E = cast(S); - return getConstantMultiple(E->getOperand()).sext(BitWidth); + const SCEVIntegralCastExpr *E = cast(S); + uint32_t OpRes = getMinTrailingZeros(E->getOperand()); + return OpRes == getTypeSizeInBits(E->getOperand()->getType()) + ? getTypeSizeInBits(E->getType()) + : OpRes; } case scMulExpr: { const SCEVMulExpr *M = cast(S); - if (M->hasNoUnsignedWrap()) { - // The result is the product of all operand results. - APInt Res = getConstantMultiple(M->getOperand(0)); - for (const SCEV *Operand : M->operands().drop_front()) - Res = Res * getConstantMultiple(Operand); - return Res; - } - - // If there are no wrap guarentees, find the trailing zeros, which is the - // sum of trailing zeros for all its operands. - uint32_t TZ = 0; - for (const SCEV *Operand : M->operands()) - TZ += getMinTrailingZeros(Operand); - return GetShiftedByZeros(TZ); + // The result is the sum of all operands results. + uint32_t SumOpRes = getMinTrailingZeros(M->getOperand(0)); + uint32_t BitWidth = getTypeSizeInBits(M->getType()); + for (unsigned I = 1, E = M->getNumOperands(); + SumOpRes != BitWidth && I != E; ++I) + SumOpRes = + std::min(SumOpRes + getMinTrailingZeros(M->getOperand(I)), BitWidth); + return SumOpRes; } + case scVScale: + return 0; + case scUDivExpr: + return 0; + case scPtrToInt: case scAddExpr: - case scAddRecExpr: { - const SCEVNAryExpr *N = cast(S); - if (N->hasNoUnsignedWrap()) { - // The result is GCD of all operands results. - APInt Res = getConstantMultiple(N->getOperand(0)); - for (unsigned I = 1, E = N->getNumOperands(); I < E && Res != 1; ++I) - Res = APIntOps::GreatestCommonDivisor( - Res, getConstantMultiple(N->getOperand(I))); - return Res; - } - } - // If there is no unsigned wrap guarentees, fall through to find trailing - // bits. - LLVM_FALLTHROUGH; + case scAddRecExpr: case scUMaxExpr: case scSMaxExpr: case scUMinExpr: case scSMinExpr: case scSequentialUMinExpr: { - const SCEVNAryExpr *N = cast(S); - // Find the trailing bits, which is the minimum of its operands. - uint32_t TZ = getMinTrailingZeros(N->getOperand(0)); - for (const SCEV *Operand : N->operands().drop_front()) - TZ = std::min(TZ, getMinTrailingZeros(Operand)); - return GetShiftedByZeros(TZ); + // The result is the min of all operands results. + ArrayRef Ops = S->operands(); + uint32_t MinOpRes = getMinTrailingZeros(Ops[0]); + for (unsigned I = 1, E = Ops.size(); MinOpRes && I != E; ++I) + MinOpRes = std::min(MinOpRes, getMinTrailingZeros(Ops[I])); + return MinOpRes; } case scUnknown: { - // ask ValueTracking for known bits const SCEVUnknown *U = cast(S); - unsigned Known = - computeKnownBits(U->getValue(), getDataLayout(), 0, &AC, nullptr, &DT) - .countMinTrailingZeros(); - return GetShiftedByZeros(Known); + // For a SCEVUnknown, ask ValueTracking. + KnownBits Known = + computeKnownBits(U->getValue(), getDataLayout(), 0, &AC, nullptr, &DT); + return Known.countMinTrailingZeros(); } case scCouldNotCompute: llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!"); @@ -6369,27 +6341,17 @@ APInt ScalarEvolution::getConstantMultipleImpl(const SCEV *S) { llvm_unreachable("Unknown SCEV kind!"); } -APInt ScalarEvolution::getConstantMultiple(const SCEV *S) { - auto I = ConstantMultipleCache.find(S); - if (I != ConstantMultipleCache.end()) +uint32_t ScalarEvolution::getMinTrailingZeros(const SCEV *S) { + auto I = MinTrailingZerosCache.find(S); + if (I != MinTrailingZerosCache.end()) return I->second; - APInt Result = getConstantMultipleImpl(S); - auto InsertPair = ConstantMultipleCache.insert({S, Result}); + uint32_t Result = getMinTrailingZerosImpl(S); + auto InsertPair = MinTrailingZerosCache.insert({S, Result}); assert(InsertPair.second && "Should insert a new key"); return InsertPair.first->second; } -APInt ScalarEvolution::getNonZeroConstantMultiple(const SCEV *S) { - APInt Multiple = getConstantMultiple(S); - return Multiple == 0 ? APInt(Multiple.getBitWidth(), 1) : Multiple; -} - -uint32_t ScalarEvolution::getMinTrailingZeros(const SCEV *S) { - return std::min(getConstantMultiple(S).countTrailingZeros(), - (unsigned)getTypeSizeInBits(S->getType())); -} - /// Helper method to assign a range to V from metadata present in the IR. static std::optional GetRangeFromMetadata(Value *V) { if (Instruction *I = dyn_cast(V)) @@ -6638,21 +6600,16 @@ const ConstantRange &ScalarEvolution::getRangeRef( // If the value has known zeros, the maximum value will have those known zeros // as well. - if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED) { - APInt Multiple = getNonZeroConstantMultiple(S); - APInt Remainder = APInt::getMaxValue(BitWidth).urem(Multiple); - if (!Remainder.isZero()) + uint32_t TZ = getMinTrailingZeros(S); + if (TZ != 0) { + if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED) ConservativeResult = ConstantRange(APInt::getMinValue(BitWidth), - APInt::getMaxValue(BitWidth) - Remainder + 1); - } - else { - uint32_t TZ = getMinTrailingZeros(S); - if (TZ != 0) { + APInt::getMaxValue(BitWidth).lshr(TZ).shl(TZ) + 1); + else ConservativeResult = ConstantRange( APInt::getSignedMinValue(BitWidth), APInt::getSignedMaxValue(BitWidth).ashr(TZ).shl(TZ) + 1); - } } switch (S->getSCEVType()) { @@ -8271,10 +8228,10 @@ unsigned ScalarEvolution::getSmallConstantTripMultiple(const Loop *L, }; const SCEVConstant *TC = dyn_cast(TCExpr); - if (!TC) { - APInt Multiple = getNonZeroConstantMultiple(TCExpr); - return Multiple.getActiveBits() > 32 ? 1 : *Multiple.getRawData(); - } + if (!TC) + // Attempt to factor more general cases. Returns the greatest power of + // two divisor. + return GetSmallMultiple(getMinTrailingZeros(TCExpr)); ConstantInt *Result = TC->getValue(); assert(Result && "SCEVConstant expected to have non-null ConstantInt"); @@ -8455,7 +8412,7 @@ void ScalarEvolution::forgetAllLoops() { SignedRanges.clear(); ExprValueMap.clear(); HasRecMap.clear(); - ConstantMultipleCache.clear(); + MinTrailingZerosCache.clear(); PredicatedSCEVRewrites.clear(); FoldCache.clear(); FoldCacheUser.clear(); @@ -13480,7 +13437,7 @@ ScalarEvolution::ScalarEvolution(ScalarEvolution &&Arg) PendingLoopPredicates(std::move(Arg.PendingLoopPredicates)), PendingPhiRanges(std::move(Arg.PendingPhiRanges)), PendingMerges(std::move(Arg.PendingMerges)), - ConstantMultipleCache(std::move(Arg.ConstantMultipleCache)), + MinTrailingZerosCache(std::move(Arg.MinTrailingZerosCache)), BackedgeTakenCounts(std::move(Arg.BackedgeTakenCounts)), PredicatedBackedgeTakenCounts( std::move(Arg.PredicatedBackedgeTakenCounts)), @@ -13955,7 +13912,7 @@ void ScalarEvolution::forgetMemoizedResultsImpl(const SCEV *S) { UnsignedRanges.erase(S); SignedRanges.erase(S); HasRecMap.erase(S); - ConstantMultipleCache.erase(S); + MinTrailingZerosCache.erase(S); if (auto *AR = dyn_cast(S)) { UnsignedWrapViaInductionTried.erase(AR); @@ -14335,17 +14292,6 @@ void ScalarEvolution::verify() const { } } } - - // Verify that ConstantMultipleCache computations are correct. - for (auto [S, Multiple] : ConstantMultipleCache) { - APInt RecomputedMultiple = SE2.getConstantMultipleImpl(S); - if (Multiple != RecomputedMultiple) { - dbgs() << "Incorrect computation in ConstantMultipleCache for " << *S - << " : Expected " << RecomputedMultiple << " but got " << Multiple - << "!\n"; - std::abort(); - } - } } bool ScalarEvolution::invalidate( diff --git a/llvm/test/Analysis/ScalarEvolution/nsw.ll b/llvm/test/Analysis/ScalarEvolution/nsw.ll index 25f7c0e426b6..5b2378502c52 100644 --- a/llvm/test/Analysis/ScalarEvolution/nsw.ll +++ b/llvm/test/Analysis/ScalarEvolution/nsw.ll @@ -322,7 +322,7 @@ define void @bad_postinc_nsw_a(i32 %n) { ; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ] ; CHECK-NEXT: --> {0,+,7}<%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 7 -; CHECK-NEXT: --> {7,+,7}<%loop> U: [7,-3) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {7,+,7}<%loop> U: [7,0) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @bad_postinc_nsw_a ; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566756 diff --git a/llvm/test/Analysis/ScalarEvolution/ranges.ll b/llvm/test/Analysis/ScalarEvolution/ranges.ll index ad11a94b3963..a0af8ae653cb 100644 --- a/llvm/test/Analysis/ScalarEvolution/ranges.ll +++ b/llvm/test/Analysis/ScalarEvolution/ranges.ll @@ -1,6 +1,6 @@ ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py - ; RUN: opt < %s -disable-output "-passes=print,verify" 2>&1 | FileCheck %s - ; RUN: opt < %s -disable-output "-passes=print,verify" -scev-range-iter-threshold=1 2>&1 | FileCheck %s + ; RUN: opt < %s -disable-output "-passes=print" 2>&1 | FileCheck %s + ; RUN: opt < %s -disable-output "-passes=print" -scev-range-iter-threshold=1 2>&1 | FileCheck %s target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" @@ -133,7 +133,7 @@ define void @add_6(i32 %n) { ; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ] ; CHECK-NEXT: --> {0,+,6}<%loop> U: [0,-2147483648) S: [0,2147483647) Exits: (6 * ((((-1 * (1 umin %n)) + %n) /u 6) + (1 umin %n))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 6 -; CHECK-NEXT: --> {6,+,6}<%loop> U: [6,-3) S: [-2147483648,2147483647) Exits: (6 + (6 * ((((-1 * (1 umin %n)) + %n) /u 6) + (1 umin %n)))) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {6,+,6}<%loop> U: [6,-1) S: [-2147483648,2147483647) Exits: (6 + (6 * ((((-1 * (1 umin %n)) + %n) /u 6) + (1 umin %n)))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @add_6 ; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n)) + %n) /u 6) + (1 umin %n)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 715827882 @@ -160,7 +160,7 @@ define void @add_7(i32 %n) { ; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ] ; CHECK-NEXT: --> {0,+,7}<%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 7 -; CHECK-NEXT: --> {7,+,7}<%loop> U: [7,-3) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {7,+,7}<%loop> U: [7,0) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @add_7 ; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n)) + %n) /u 7) + (1 umin %n)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566756 @@ -215,7 +215,7 @@ define void @add_9(i32 %n) { ; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ] ; CHECK-NEXT: --> {0,+,9}<%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (9 * ((((-1 * (1 umin %n)) + %n) /u 9) + (1 umin %n))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 9 -; CHECK-NEXT: --> {9,+,9}<%loop> U: [9,-3) S: [9,0) Exits: (9 + (9 * ((((-1 * (1 umin %n)) + %n) /u 9) + (1 umin %n)))) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {9,+,9}<%loop> U: [9,0) S: [9,0) Exits: (9 + (9 * ((((-1 * (1 umin %n)) + %n) /u 9) + (1 umin %n)))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @add_9 ; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n)) + %n) /u 9) + (1 umin %n)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 477218588 @@ -243,7 +243,7 @@ define void @add_10(i32 %n) { ; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ] ; CHECK-NEXT: --> {0,+,10}<%loop> U: [0,-2147483648) S: [0,2147483647) Exits: (10 * ((((-1 * (1 umin %n)) + %n) /u 10) + (1 umin %n))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 10 -; CHECK-NEXT: --> {10,+,10}<%loop> U: [10,-5) S: [-2147483648,2147483647) Exits: (10 + (10 * ((((-1 * (1 umin %n)) + %n) /u 10) + (1 umin %n)))) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {10,+,10}<%loop> U: [10,-1) S: [-2147483648,2147483647) Exits: (10 + (10 * ((((-1 * (1 umin %n)) + %n) /u 10) + (1 umin %n)))) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @add_10 ; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n)) + %n) /u 10) + (1 umin %n)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 429496729 diff --git a/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll index da7bdbcf2d92..492ed9c4d265 100644 --- a/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll +++ b/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll @@ -520,7 +520,7 @@ define void @test_trip_multiple_5(i32 %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 5 +; CHECK: Loop %for.body: Trip multiple is 1 ; entry: %u = urem i32 %num, 5 diff --git a/llvm/test/Analysis/ScalarEvolution/trip-multiple.ll b/llvm/test/Analysis/ScalarEvolution/trip-multiple.ll index 65d3c5938001..5a82151065e4 100644 --- a/llvm/test/Analysis/ScalarEvolution/trip-multiple.ll +++ b/llvm/test/Analysis/ScalarEvolution/trip-multiple.ll @@ -1,5 +1,5 @@ ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py -; RUN: opt -passes='print,verify' -disable-output %s 2>&1 | FileCheck %s +; RUN: opt -passes='print' -disable-output %s 2>&1 | FileCheck %s ; Test trip multiples with functions that look like: @@ -29,7 +29,7 @@ define void @trip_multiple_3(i32 noundef %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 3 +; CHECK: Loop %for.body: Trip multiple is 1 ; entry: %rem = urem i32 %num, 3 @@ -102,7 +102,7 @@ define void @trip_multiple_5(i32 noundef %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 5 +; CHECK: Loop %for.body: Trip multiple is 1 ; entry: %rem = urem i32 %num, 5 @@ -139,7 +139,7 @@ define void @trip_multiple_6(i32 noundef %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 6 +; CHECK: Loop %for.body: Trip multiple is 2 ; entry: %rem = urem i32 %num, 6 @@ -176,7 +176,7 @@ define void @trip_multiple_7(i32 noundef %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 7 +; CHECK: Loop %for.body: Trip multiple is 1 ; entry: %rem = urem i32 %num, 7 @@ -249,7 +249,7 @@ define void @trip_multiple_9(i32 noundef %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 9 +; CHECK: Loop %for.body: Trip multiple is 1 ; entry: %rem = urem i32 %num, 9 @@ -285,7 +285,7 @@ define void @trip_multiple_10(i32 noundef %num) { ; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num) ; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num) ; CHECK-NEXT: Predicates: -; CHECK: Loop %for.body: Trip multiple is 10 +; CHECK: Loop %for.body: Trip multiple is 2 ; entry: %rem = urem i32 %num, 10