Skip to content

Commit

Permalink
Revert "[SCEV] Precise trip multiples"
Browse files Browse the repository at this point in the history 
This reverts commit 027a4c8.
  • Loading branch information
@caojoshua
caojoshua committed Apr 24, 2023
1 parent 920cbe8 commit a4e420e
Show file tree
Hide file tree
Showing 6 changed files with 70 additions and 130 deletions.
14 changes: 4 additions & 10 deletions llvm/include/llvm/Analysis/ScalarEvolution.h
View file
Expand Up @@ -964,12 +964,6 @@ class ScalarEvolution {
/// 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) {
Expand Down Expand Up @@ -1437,14 +1431,14 @@ class ScalarEvolution {
/// predicate by splitting it into a set of independent predicates.
bool ProvingSplitPredicate = false;

/// Memoized values for the getConstantMultiple
DenseMap<const SCEV *, APInt> ConstantMultipleCache;
/// Memoized values for the GetMinTrailingZeros
DenseMap<const SCEV *, uint32_t> MinTrailingZerosCache;

/// Return the Value set from which the SCEV expr is generated.
ArrayRef<Value *> 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.
Expand Down
156 changes: 51 additions & 105 deletions llvm/lib/Analysis/ScalarEvolution.cpp
View file
Expand Up @@ -6281,115 +6281,77 @@ 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<SCEVConstant>(S)->getAPInt();
case scPtrToInt:
return getConstantMultiple(cast<SCEVPtrToIntExpr>(S)->getOperand());
case scUDivExpr:
case scVScale:
return APInt(BitWidth, 1);
return cast<SCEVConstant>(S)->getAPInt().countr_zero();
case scTruncate: {
// Only multiples that are a power of 2 will hold after truncation.
const SCEVTruncateExpr *T = cast<SCEVTruncateExpr>(S);
uint32_t TZ = getMinTrailingZeros(T->getOperand());
return GetShiftedByZeros(TZ);
}
case scZeroExtend: {
const SCEVZeroExtendExpr *Z = cast<SCEVZeroExtendExpr>(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<SCEVSignExtendExpr>(S);
return getConstantMultiple(E->getOperand()).sext(BitWidth);
const SCEVIntegralCastExpr *E = cast<SCEVIntegralCastExpr>(S);
uint32_t OpRes = getMinTrailingZeros(E->getOperand());
return OpRes == getTypeSizeInBits(E->getOperand()->getType())
? getTypeSizeInBits(E->getType())
: OpRes;
}
case scMulExpr: {
const SCEVMulExpr *M = cast<SCEVMulExpr>(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<SCEVNAryExpr>(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<SCEVNAryExpr>(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<const SCEV *> 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<SCEVUnknown>(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!");
}
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<ConstantRange> GetRangeFromMetadata(Value *V) {
if (Instruction *I = dyn_cast<Instruction>(V))
Expand Down Expand Up @@ -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()) {
Expand Down Expand Up @@ -8271,10 +8228,10 @@ unsigned ScalarEvolution::getSmallConstantTripMultiple(const Loop *L,
};

const SCEVConstant *TC = dyn_cast<SCEVConstant>(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");
Expand Down Expand Up @@ -8455,7 +8412,7 @@ void ScalarEvolution::forgetAllLoops() {
SignedRanges.clear();
ExprValueMap.clear();
HasRecMap.clear();
ConstantMultipleCache.clear();
MinTrailingZerosCache.clear();
PredicatedSCEVRewrites.clear();
FoldCache.clear();
FoldCacheUser.clear();
Expand Down Expand Up @@ -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)),
Expand Down Expand Up @@ -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<SCEVAddRecExpr>(S)) {
UnsignedWrapViaInductionTried.erase(AR);
Expand Down Expand Up @@ -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(
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Analysis/ScalarEvolution/nsw.ll
View file
Expand Up @@ -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}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 7
; CHECK-NEXT: --> {7,+,7}<nuw><%loop> U: [7,-3) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: --> {7,+,7}<nuw><%loop> U: [7,0) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %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))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566756
Expand Down
12 changes: 6 additions & 6 deletions llvm/test/Analysis/ScalarEvolution/ranges.ll
View file
@@ -1,6 +1,6 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>,verify<scalar-evolution>" 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>,verify<scalar-evolution>" -scev-range-iter-threshold=1 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -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"

Expand Down Expand Up @@ -133,7 +133,7 @@ define void @add_6(i32 %n) {
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,6}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,2147483647) Exits: (6 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 6
; CHECK-NEXT: --> {6,+,6}<nuw><%loop> U: [6,-3) S: [-2147483648,2147483647) Exits: (6 + (6 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: --> {6,+,6}<nuw><%loop> U: [6,-1) S: [-2147483648,2147483647) Exits: (6 + (6 * ((((-1 * (1 umin %n))<nuw><nsw> + %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))<nuw><nsw> + %n) /u 6) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 715827882
Expand All @@ -160,7 +160,7 @@ define void @add_7(i32 %n) {
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,7}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 7
; CHECK-NEXT: --> {7,+,7}<nuw><%loop> U: [7,-3) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: --> {7,+,7}<nuw><%loop> U: [7,0) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %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))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566756
Expand Down Expand Up @@ -215,7 +215,7 @@ define void @add_9(i32 %n) {
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,9}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 9
; CHECK-NEXT: --> {9,+,9}<nuw><%loop> U: [9,-3) S: [9,0) Exits: (9 + (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: --> {9,+,9}<nuw><%loop> U: [9,0) S: [9,0) Exits: (9 + (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %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))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 477218588
Expand Down Expand Up @@ -243,7 +243,7 @@ define void @add_10(i32 %n) {
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,10}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,2147483647) Exits: (10 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 10
; CHECK-NEXT: --> {10,+,10}<nuw><%loop> U: [10,-5) S: [-2147483648,2147483647) Exits: (10 + (10 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: --> {10,+,10}<nuw><%loop> U: [10,-1) S: [-2147483648,2147483647) Exits: (10 + (10 * ((((-1 * (1 umin %n))<nuw><nsw> + %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))<nuw><nsw> + %n) /u 10) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 429496729
Expand Down
2 changes: 1 addition & 1 deletion llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
View file
Expand Up @@ -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
Expand Down
14 changes: 7 additions & 7 deletions llvm/test/Analysis/ScalarEvolution/trip-multiple.ll
View file
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -passes='print<scalar-evolution>,verify<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s
; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s

; Test trip multiples with functions that look like:

Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down

0 comments on commit a4e420e

Please sign in to comment.