Index: llvm/include/llvm/Analysis/ScalarEvolution.h =================================================================== --- llvm/include/llvm/Analysis/ScalarEvolution.h +++ llvm/include/llvm/Analysis/ScalarEvolution.h @@ -2130,10 +2130,16 @@ bool isSCEVExprNeverPoison(const Instruction *I); /// This is like \c isSCEVExprNeverPoison but it specifically works for - /// instructions that will get mapped to SCEV add recurrences. Return true - /// if \p I will never generate poison under the assumption that \p I is an - /// add recurrence on the loop \p L. - bool isAddRecNeverPoison(const Instruction *I, const Loop *L); + /// instructions that will get mapped to SCEV post-inc add recurrences. + /// Return true if \p I will never generate poison under the assumption that + /// \p I is an add recurrence on the loop \p L. + bool isPostIncAddRecNeverPoison(const Instruction *I, const Loop *L); + + /// Check whether nowrap flags from the IR increment operation can be + /// transferred to the pre-inc addrec. + bool canPreservePreIncAddRecNoWrapFlags(const Instruction *PreIncI, + const Instruction *PostIncI, + const Loop *L); /// Similar to createAddRecFromPHI, but with the additional flexibility of /// suggesting runtime overflow checks in case casts are encountered. Index: llvm/lib/Analysis/ScalarEvolution.cpp =================================================================== --- llvm/lib/Analysis/ScalarEvolution.cpp +++ llvm/lib/Analysis/ScalarEvolution.cpp @@ -5681,14 +5681,19 @@ if (!Accum) return nullptr; - SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap; + SCEV::NoWrapFlags IRFlags = SCEV::FlagAnyWrap; if (BO->IsNUW) - Flags = setFlags(Flags, SCEV::FlagNUW); + IRFlags = setFlags(IRFlags, SCEV::FlagNUW); if (BO->IsNSW) - Flags = setFlags(Flags, SCEV::FlagNSW); + IRFlags = setFlags(IRFlags, SCEV::FlagNSW); + auto *BEInst = dyn_cast(BEValueV); + SCEV::NoWrapFlags PreIncFlags = + BEInst && canPreservePreIncAddRecNoWrapFlags(PN, BEInst, L) + ? IRFlags + : SCEV::FlagAnyWrap; const SCEV *StartVal = getSCEV(StartValueV); - const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, Flags); + const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, PreIncFlags); insertValueToMap(PN, PHISCEV); if (auto *AR = dyn_cast(PHISCEV)) { @@ -5700,11 +5705,11 @@ // We can add Flags to the post-inc expression only if we // know that it is *undefined behavior* for BEValueV to // overflow. - if (auto *BEInst = dyn_cast(BEValueV)) { + if (BEInst) { assert(isLoopInvariant(Accum, L) && "Accum is defined outside L, but is not invariant?"); - if (isAddRecNeverPoison(BEInst, L)) - (void)getAddRecExpr(getAddExpr(StartVal, Accum), Accum, L, Flags); + if (isPostIncAddRecNeverPoison(BEInst, L)) + (void)getAddRecExpr(getAddExpr(StartVal, Accum), Accum, L, IRFlags); } return PHISCEV; @@ -5784,14 +5789,14 @@ if (isLoopInvariant(Accum, L) || (isa(Accum) && cast(Accum)->getLoop() == L)) { - SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap; + SCEV::NoWrapFlags IRFlags = SCEV::FlagAnyWrap; if (auto BO = MatchBinaryOp(BEValueV, getDataLayout(), AC, DT, PN)) { if (BO->Opcode == Instruction::Add && BO->LHS == PN) { if (BO->IsNUW) - Flags = setFlags(Flags, SCEV::FlagNUW); + IRFlags = setFlags(IRFlags, SCEV::FlagNUW); if (BO->IsNSW) - Flags = setFlags(Flags, SCEV::FlagNSW); + IRFlags = setFlags(IRFlags, SCEV::FlagNSW); } } else if (GEPOperator *GEP = dyn_cast(BEValueV)) { // If the increment is an inbounds GEP, then we know the address @@ -5801,11 +5806,11 @@ // pointer. We can guarantee that no unsigned wrap occurs if the // indices form a positive value. if (GEP->isInBounds() && GEP->getOperand(0) == PN) { - Flags = setFlags(Flags, SCEV::FlagNW); + IRFlags = setFlags(IRFlags, SCEV::FlagNW); const SCEV *Ptr = getSCEV(GEP->getPointerOperand()); if (isKnownPositive(getMinusSCEV(getSCEV(GEP), Ptr))) - Flags = setFlags(Flags, SCEV::FlagNUW); + IRFlags = setFlags(IRFlags, SCEV::FlagNUW); } // We cannot transfer nuw and nsw flags from subtraction @@ -5814,7 +5819,12 @@ } const SCEV *StartVal = getSCEV(StartValueV); - const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, Flags); + auto *BEInst = dyn_cast(BEValueV); + SCEV::NoWrapFlags PreIncFlags = + BEInst && canPreservePreIncAddRecNoWrapFlags(PN, BEInst, L) + ? IRFlags + : SCEV::FlagAnyWrap; + const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, PreIncFlags); // Okay, for the entire analysis of this edge we assumed the PHI // to be symbolic. We now need to go back and purge all of the @@ -5831,9 +5841,9 @@ // We can add Flags to the post-inc expression only if we // know that it is *undefined behavior* for BEValueV to // overflow. - if (auto *BEInst = dyn_cast(BEValueV)) - if (isLoopInvariant(Accum, L) && isAddRecNeverPoison(BEInst, L)) - (void)getAddRecExpr(getAddExpr(StartVal, Accum), Accum, L, Flags); + if (BEInst && isLoopInvariant(Accum, L) && + isPostIncAddRecNeverPoison(BEInst, L)) + (void)getAddRecExpr(getAddExpr(StartVal, Accum), Accum, L, IRFlags); return PHISCEV; } @@ -7259,29 +7269,16 @@ return isGuaranteedToTransferExecutionTo(DefI, I); } -bool ScalarEvolution::isAddRecNeverPoison(const Instruction *I, const Loop *L) { - // If we know that \c I can never be poison period, then that's enough. - if (isSCEVExprNeverPoison(I)) - return true; - - // If the loop only has one exit, then we know that, if the loop is entered, - // any instruction dominating that exit will be executed. If any such - // instruction would result in UB, the addrec cannot be poison. - // - // This is basically the same reasoning as in isSCEVExprNeverPoison(), but - // also handles uses outside the loop header (they just need to dominate the - // single exit). - - auto *ExitingBB = L->getExitingBlock(); - if (!ExitingBB || !loopHasNoAbnormalExits(L)) - return false; - +/// Check whether there is an instruction dominating BB that would cause +/// undefined behavior if I is poison. (The caller is responsible for making +/// sure the instruction actually executes.) +static bool poisonCausesDominatingUB(const Instruction *I, const BasicBlock *BB, + const Loop *L, const DominatorTree &DT) { SmallPtrSet KnownPoison; SmallVector Worklist; - // We start by assuming \c I, the post-inc add recurrence, is poison. Only - // things that are known to be poison under that assumption go on the - // Worklist. + // We start by assuming \c I is poison. Only things that are known to be + // poison under that assumption go on the Worklist. KnownPoison.insert(I); Worklist.push_back(I); @@ -7291,7 +7288,7 @@ for (const Use &U : Poison->uses()) { const Instruction *PoisonUser = cast(U.getUser()); if (mustTriggerUB(PoisonUser, KnownPoison) && - DT.dominates(PoisonUser->getParent(), ExitingBB)) + DT.dominates(PoisonUser->getParent(), BB)) return true; if (propagatesPoison(U) && L->contains(PoisonUser)) @@ -7303,6 +7300,45 @@ return false; } +bool ScalarEvolution::isPostIncAddRecNeverPoison(const Instruction *PostIncI, + const Loop *L) { + // If we know that \c PostIncI can never be poison period, then that's enough. + if (isSCEVExprNeverPoison(PostIncI)) + return true; + + // If the loop only has one exit, then we know that, if the loop is entered, + // any instruction dominating that exit will be executed. If any such + // instruction would result in UB, the addrec cannot be poison. + // + // This is basically the same reasoning as in isSCEVExprNeverPoison(), but + // also handles uses outside the loop header (they just need to dominate the + // single exit). + + auto *ExitingBB = L->getExitingBlock(); + if (!ExitingBB || !loopHasNoAbnormalExits(L)) + return false; + + return poisonCausesDominatingUB(PostIncI, ExitingBB, L, DT); +} + +bool ScalarEvolution::canPreservePreIncAddRecNoWrapFlags( + const Instruction *PreIncI, const Instruction *PostIncI, const Loop *L) { + // If we know that PreIncI can never be poison period, then that's enough. + if (programUndefinedIfPoison(PreIncI)) + return true; + + // Nowrap flags are always valid on the first iteration. For subsequent + // iterations, we use the post-inc value after taking the loop latch. As such, + // if a poison post-inc value would cause UB in any instruction dominating + // the latch, we know that it cannot be poison. + + auto *Latch = L->getLoopLatch(); + if (!Latch) + return false; + + return poisonCausesDominatingUB(PostIncI, Latch, L, DT); +} + ScalarEvolution::LoopProperties ScalarEvolution::getLoopProperties(const Loop *L) { using LoopProperties = ScalarEvolution::LoopProperties; Index: llvm/test/Analysis/ScalarEvolution/decrementing_addrecs.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/decrementing_addrecs.ll +++ llvm/test/Analysis/ScalarEvolution/decrementing_addrecs.ll @@ -34,11 +34,11 @@ ; DEFAULT-NEXT: %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] ; DEFAULT-NEXT: --> {0,+,1}<%loop> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %n) LoopDispositions: { %loop: Computable } ; DEFAULT-NEXT: %j = phi i32 [ %n.minus.1, %entry ], [ %j.next, %loop ] -; DEFAULT-NEXT: --> {(-1 + %n),+,-1}<%loop> U: full-set S: full-set Exits: 0 LoopDispositions: { %loop: Computable } +; DEFAULT-NEXT: --> {(-1 + %n),+,-1}<%loop> U: full-set S: full-set Exits: 0 LoopDispositions: { %loop: Computable } ; DEFAULT-NEXT: %a = sub i32 %n, %i ; DEFAULT-NEXT: --> {%n,+,-1}<%loop> U: full-set S: full-set Exits: 1 LoopDispositions: { %loop: Computable } ; DEFAULT-NEXT: %b = sub i32 %n.minus.1, %i -; DEFAULT-NEXT: --> {(-1 + %n),+,-1}<%loop> U: full-set S: full-set Exits: 0 LoopDispositions: { %loop: Computable } +; DEFAULT-NEXT: --> {(-1 + %n),+,-1}<%loop> U: full-set S: full-set Exits: 0 LoopDispositions: { %loop: Computable } ; DEFAULT-NEXT: %c = sub i32 2147483647, %i ; DEFAULT-NEXT: --> {2147483647,+,-1}<%loop> U: [1,-2147483648) S: [1,-2147483648) Exits: (-2147483648 + (-1 * %n)) LoopDispositions: { %loop: Computable } ; DEFAULT-NEXT: %i.next = add nuw nsw i32 %i, 1 @@ -60,17 +60,17 @@ ; EXPENSIVE_SHARPENING-NEXT: %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] ; EXPENSIVE_SHARPENING-NEXT: --> {0,+,1}<%loop> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %n) LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: %j = phi i32 [ %n.minus.1, %entry ], [ %j.next, %loop ] -; EXPENSIVE_SHARPENING-NEXT: --> {(-1 + %n),+,-1}<%loop> U: [0,2147483647) S: [0,2147483647) Exits: 0 LoopDispositions: { %loop: Computable } +; EXPENSIVE_SHARPENING-NEXT: --> {(-1 + %n),+,-1}<%loop> U: [0,2147483647) S: [0,2147483647) Exits: 0 LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: %a = sub i32 %n, %i ; EXPENSIVE_SHARPENING-NEXT: --> {%n,+,-1}<%loop> U: [1,-2147483648) S: [1,-2147483648) Exits: 1 LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: %b = sub i32 %n.minus.1, %i -; EXPENSIVE_SHARPENING-NEXT: --> {(-1 + %n),+,-1}<%loop> U: [0,2147483647) S: [0,2147483647) Exits: 0 LoopDispositions: { %loop: Computable } +; EXPENSIVE_SHARPENING-NEXT: --> {(-1 + %n),+,-1}<%loop> U: [0,2147483647) S: [0,2147483647) Exits: 0 LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: %c = sub i32 2147483647, %i ; EXPENSIVE_SHARPENING-NEXT: --> {2147483647,+,-1}<%loop> U: [1,-2147483648) S: [1,-2147483648) Exits: (-2147483648 + (-1 * %n)) LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: %i.next = add nuw nsw i32 %i, 1 ; EXPENSIVE_SHARPENING-NEXT: --> {1,+,1}<%loop> U: [1,-2147483648) S: [1,-2147483648) Exits: %n LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: %j.next = add nsw i32 %j, -1 -; EXPENSIVE_SHARPENING-NEXT: --> {(-2 + %n),+,-1}<%loop> U: full-set S: [-1,2147483646) Exits: -1 LoopDispositions: { %loop: Computable } +; EXPENSIVE_SHARPENING-NEXT: --> {(-2 + %n),+,-1}<%loop> U: full-set S: [-1,2147483646) Exits: -1 LoopDispositions: { %loop: Computable } ; EXPENSIVE_SHARPENING-NEXT: Determining loop execution counts for: @test_step_1_flags ; EXPENSIVE_SHARPENING-NEXT: Loop %loop: backedge-taken count is (-1 + %n) ; EXPENSIVE_SHARPENING-NEXT: Loop %loop: constant max backedge-taken count is 2147483646 Index: llvm/test/Analysis/ScalarEvolution/different-loops-recs.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/different-loops-recs.ll +++ llvm/test/Analysis/ScalarEvolution/different-loops-recs.ll @@ -1,3 +1,4 @@ +; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 2 ; RUN: opt -disable-output "-passes=print" < %s 2>&1 | FileCheck %s ; This test set ensures that we can correctly operate with recurrencies from @@ -7,28 +8,66 @@ ; order. define void @test_00() { - -; CHECK-LABEL: Classifying expressions for: @test_00 -; CHECK: %sum1 = add i32 %phi1, %phi2 -; CHECK-NEXT: --> {14,+,3}<%loop1> -; CHECK: %sum2 = add i32 %sum1, %phi3 -; CHECK-NEXT: --> {20,+,6}<%loop1> -; CHECK: %sum3 = add i32 %phi4, %phi5 -; CHECK-NEXT: --> {116,+,3}<%loop2> -; CHECK: %sum4 = add i32 %sum3, %phi6 -; CHECK-NEXT: --> {159,+,6}<%loop2> -; CHECK: %s1 = add i32 %phi1, %phi4 -; CHECK-NEXT: --> {{{{}}73,+,1}<%loop1>,+,1}<%loop2> -; CHECK: %s2 = add i32 %phi5, %phi2 -; CHECK-NEXT: --> {{{{}}57,+,2}<%loop1>,+,2}<%loop2> -; CHECK: %s3 = add i32 %sum1, %sum3 -; CHECK-NEXT: --> {{{{}}130,+,3}<%loop1>,+,3}<%loop2> -; CHECK: %s4 = add i32 %sum4, %sum2 -; CHECK-NEXT: --> {{{{}}179,+,6}<%loop1>,+,6}<%loop2> -; CHECK: %s5 = add i32 %phi3, %sum3 -; CHECK-NEXT: --> {{{{}}122,+,3}<%loop1>,+,3}<%loop2> -; CHECK: %s6 = add i32 %sum2, %phi6 -; CHECK-NEXT: --> {{{{}}63,+,6}<%loop1>,+,3}<%loop2> +; CHECK-LABEL: 'test_00' +; CHECK-NEXT: Classifying expressions for: @test_00 +; CHECK-NEXT: %phi1 = phi i32 [ 10, %entry ], [ %phi1.inc, %loop1 ] +; CHECK-NEXT: --> {10,+,1}<%loop1> U: [10,175) S: [10,175) Exits: 174 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2 = phi i32 [ 4, %entry ], [ %phi2.inc, %loop1 ] +; CHECK-NEXT: --> {4,+,2}<%loop1> U: [4,333) S: [4,333) Exits: 332 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi3 = phi i32 [ 6, %entry ], [ %phi3.inc, %loop1 ] +; CHECK-NEXT: --> {6,+,3}<%loop1> U: [6,499) S: [6,499) Exits: 498 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi1.inc = add i32 %phi1, 1 +; CHECK-NEXT: --> {11,+,1}<%loop1> U: [11,176) S: [11,176) Exits: 175 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2.inc = add i32 %phi2, 2 +; CHECK-NEXT: --> {6,+,2}<%loop1> U: [6,335) S: [6,335) Exits: 334 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi3.inc = add i32 %phi3, 3 +; CHECK-NEXT: --> {9,+,3}<%loop1> U: [9,502) S: [9,502) Exits: 501 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %sum1 = add i32 %phi1, %phi2 +; CHECK-NEXT: --> {14,+,3}<%loop1> U: [14,507) S: [14,507) Exits: 506 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %sum2 = add i32 %sum1, %phi3 +; CHECK-NEXT: --> {20,+,6}<%loop1> U: [20,1005) S: [20,1005) Exits: 1004 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi4 = phi i32 [ 63, %loop1 ], [ %phi4.inc, %loop2 ] +; CHECK-NEXT: --> {63,+,1}<%loop2> U: [63,205) S: [63,205) Exits: 204 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi5 = phi i32 [ 53, %loop1 ], [ %phi5.inc, %loop2 ] +; CHECK-NEXT: --> {53,+,2}<%loop2> U: [53,336) S: [53,336) Exits: 335 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi6 = phi i32 [ 43, %loop1 ], [ %phi6.inc, %loop2 ] +; CHECK-NEXT: --> {43,+,3}<%loop2> U: [43,467) S: [43,467) Exits: 466 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi4.inc = add i32 %phi4, 1 +; CHECK-NEXT: --> {64,+,1}<%loop2> U: [64,206) S: [64,206) Exits: 205 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi5.inc = add i32 %phi5, 2 +; CHECK-NEXT: --> {55,+,2}<%loop2> U: [55,338) S: [55,338) Exits: 337 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi6.inc = add i32 %phi6, 3 +; CHECK-NEXT: --> {46,+,3}<%loop2> U: [46,470) S: [46,470) Exits: 469 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %sum3 = add i32 %phi4, %phi5 +; CHECK-NEXT: --> {116,+,3}<%loop2> U: [116,540) S: [116,540) Exits: 539 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %sum4 = add i32 %sum3, %phi6 +; CHECK-NEXT: --> {159,+,6}<%loop2> U: [159,1006) S: [159,1006) Exits: 1005 LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %s1 = add i32 %phi1, %phi4 +; CHECK-NEXT: --> {{73,+,1}<%loop1>,+,1}<%loop2> U: [73,379) S: [73,379) --> 378 U: [378,379) S: [378,379) +; CHECK-NEXT: %s2 = add i32 %phi5, %phi2 +; CHECK-NEXT: --> {{57,+,2}<%loop1>,+,2}<%loop2> U: [57,668) S: [57,668) --> 667 U: [667,668) S: [667,668) +; CHECK-NEXT: %s3 = add i32 %sum1, %sum3 +; CHECK-NEXT: --> {{130,+,3}<%loop1>,+,3}<%loop2> U: [130,1046) S: [130,1046) --> 1045 U: [1045,1046) S: [1045,1046) +; CHECK-NEXT: %s4 = add i32 %sum4, %sum2 +; CHECK-NEXT: --> {{179,+,6}<%loop1>,+,6}<%loop2> U: [179,2010) S: [179,2010) --> 2009 U: [2009,2010) S: [2009,2010) +; CHECK-NEXT: %s5 = add i32 %phi3, %sum3 +; CHECK-NEXT: --> {{122,+,3}<%loop1>,+,3}<%loop2> U: [122,1038) S: [122,1038) --> 1037 U: [1037,1038) S: [1037,1038) +; CHECK-NEXT: %s6 = add i32 %sum2, %phi6 +; CHECK-NEXT: --> {{63,+,6}<%loop1>,+,3}<%loop2> U: [63,1471) S: [63,1471) --> 1470 U: [1470,1471) S: [1470,1471) +; CHECK-NEXT: Determining loop execution counts for: @test_00 +; CHECK-NEXT: Loop %loop2: backedge-taken count is 141 +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is 141 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is 141 +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is 141 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 142 +; CHECK-NEXT: Loop %loop1: backedge-taken count is 164 +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is 164 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is 164 +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is 164 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 165 +; entry: br label %loop1 @@ -71,34 +110,72 @@ ; in any order. define void @test_01(i32 %a, i32 %b) { - -; CHECK-LABEL: Classifying expressions for: @test_01 -; CHECK: %sum1 = add i32 %phi1, %phi2 -; CHECK-NEXT: --> {(%a + %b),+,3}<%loop1> -; CHECK: %sum2 = add i32 %sum1, %phi3 -; CHECK-NEXT: --> {(6 + %a + %b),+,6}<%loop1> -; CHECK: %is1 = add i32 %sum2, %a -; CHECK-NEXT: --> {(6 + (2 * %a) + %b),+,6}<%loop1> -; CHECK: %sum3 = add i32 %phi4, %phi5 -; CHECK-NEXT: --> {116,+,3}<%loop2> -; CHECK: %sum4 = add i32 %sum3, %phi6 -; CHECK-NEXT: --> {159,+,6}<%loop2> -; CHECK: %is2 = add i32 %sum4, %b -; CHECK-NEXT: --> {(159 + %b),+,6}<%loop2> -; CHECK: %ec2 = add i32 %is1, %is2 -; CHECK-NEXT: --> {{{{}}(165 + (2 * %a) + (2 * %b)),+,6}<%loop1>,+,6}<%loop2> -; CHECK: %s1 = add i32 %phi1, %is1 -; CHECK-NEXT: --> {(6 + (3 * %a) + %b),+,7}<%loop1> -; CHECK: %s2 = add i32 %is2, %phi4 -; CHECK-NEXT: --> {(222 + %b),+,7}<%loop2> -; CHECK: %s3 = add i32 %is1, %phi5 -; CHECK-NEXT: --> {{{{}}(59 + (2 * %a) + %b),+,6}<%loop1>,+,2}<%loop2> -; CHECK: %s4 = add i32 %phi2, %is2 -; CHECK-NEXT: --> {{{{}}(159 + (2 * %b)),+,2}<%loop1>,+,6}<%loop2> -; CHECK: %s5 = add i32 %is1, %is2 -; CHECK-NEXT: --> {{{{}}(165 + (2 * %a) + (2 * %b)),+,6}<%loop1>,+,6}<%loop2> -; CHECK: %s6 = add i32 %is2, %is1 -; CHECK-NEXT: --> {{{{}}(165 + (2 * %a) + (2 * %b)),+,6}<%loop1>,+,6}<%loop2> +; CHECK-LABEL: 'test_01' +; CHECK-NEXT: Classifying expressions for: @test_01 +; CHECK-NEXT: %phi1 = phi i32 [ %a, %entry ], [ %phi1.inc, %loop1 ] +; CHECK-NEXT: --> {%a,+,1}<%loop1> U: full-set S: full-set Exits: (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))) + %a) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2 = phi i32 [ %b, %entry ], [ %phi2.inc, %loop1 ] +; CHECK-NEXT: --> {%b,+,2}<%loop1> U: full-set S: full-set Exits: ((2 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %b) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi3 = phi i32 [ 6, %entry ], [ %phi3.inc, %loop1 ] +; CHECK-NEXT: --> {6,+,3}<%loop1> U: [6,508) S: [6,508) Exits: (6 + (3 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi1.inc = add i32 %phi1, 1 +; CHECK-NEXT: --> {(1 + %a),+,1}<%loop1> U: full-set S: full-set Exits: (1 + ((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))) + %a) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2.inc = add i32 %phi2, 2 +; CHECK-NEXT: --> {(2 + %b),+,2}<%loop1> U: full-set S: full-set Exits: (2 + (2 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %b) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi3.inc = add i32 %phi3, 3 +; CHECK-NEXT: --> {9,+,3}<%loop1> U: [9,511) S: [9,511) Exits: (9 + (3 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %sum1 = add i32 %phi1, %phi2 +; CHECK-NEXT: --> {(%a + %b),+,3}<%loop1> U: full-set S: full-set Exits: ((3 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %a + %b) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %sum2 = add i32 %sum1, %phi3 +; CHECK-NEXT: --> {(6 + %a + %b),+,6}<%loop1> U: full-set S: full-set Exits: (6 + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %a + %b) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %is1 = add i32 %sum2, %a +; CHECK-NEXT: --> {(6 + (2 * %a) + %b),+,6}<%loop1> U: full-set S: full-set Exits: (6 + (2 * %a) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %b) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi4 = phi i32 [ 63, %loop1 ], [ %phi4.inc, %loop2 ] +; CHECK-NEXT: --> {63,+,1}<%loop2> U: [63,231) S: [63,231) Exits: (63 + ((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi5 = phi i32 [ 53, %loop1 ], [ %phi5.inc, %loop2 ] +; CHECK-NEXT: --> {53,+,2}<%loop2> U: [53,388) S: [53,388) Exits: (53 + (2 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi6 = phi i32 [ 43, %loop1 ], [ %phi6.inc, %loop2 ] +; CHECK-NEXT: --> {43,+,3}<%loop2> U: [43,545) S: [43,545) Exits: (43 + (3 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi4.inc = add i32 %phi4, 1 +; CHECK-NEXT: --> {64,+,1}<%loop2> U: [64,232) S: [64,232) Exits: (64 + ((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi5.inc = add i32 %phi5, 2 +; CHECK-NEXT: --> {55,+,2}<%loop2> U: [55,390) S: [55,390) Exits: (55 + (2 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi6.inc = add i32 %phi6, 3 +; CHECK-NEXT: --> {46,+,3}<%loop2> U: [46,548) S: [46,548) Exits: (46 + (3 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %sum3 = add i32 %phi4, %phi5 +; CHECK-NEXT: --> {116,+,3}<%loop2> U: [116,618) S: [116,618) Exits: (116 + (3 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %sum4 = add i32 %sum3, %phi6 +; CHECK-NEXT: --> {159,+,6}<%loop2> U: [159,1162) S: [159,1162) Exits: (159 + (6 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %is2 = add i32 %sum4, %b +; CHECK-NEXT: --> {(159 + %b),+,6}<%loop2> U: full-set S: full-set Exits: (159 + (6 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))))))))) + %b) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %ec2 = add i32 %is1, %is2 +; CHECK-NEXT: --> {{(165 + (2 * %a) + (2 * %b)),+,6}<%loop1>,+,6}<%loop2> U: full-set S: full-set --> {(165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))),+,6}<%loop2> U: full-set S: full-set Exits: (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (6 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %s1 = add i32 %phi1, %is1 +; CHECK-NEXT: --> {(6 + (3 * %a) + %b),+,7}<%loop1> U: full-set S: full-set --> (6 + (3 * %a) + (7 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %b) U: full-set S: full-set +; CHECK-NEXT: %s2 = add i32 %is2, %phi4 +; CHECK-NEXT: --> {(222 + %b),+,7}<%loop2> U: full-set S: full-set --> (222 + (7 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))))))))) + %b) U: full-set S: full-set +; CHECK-NEXT: %s3 = add i32 %is1, %phi5 +; CHECK-NEXT: --> {{(59 + (2 * %a) + %b),+,6}<%loop1>,+,2}<%loop2> U: full-set S: full-set --> (59 + (2 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))))))))) + (2 * %a) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + %b) U: full-set S: full-set +; CHECK-NEXT: %s4 = add i32 %phi2, %is2 +; CHECK-NEXT: --> {{(159 + (2 * %b)),+,2}<%loop1>,+,6}<%loop2> U: full-set S: full-set --> (159 + (2 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (2 * %b) + (6 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) U: full-set S: full-set +; CHECK-NEXT: %s5 = add i32 %is1, %is2 +; CHECK-NEXT: --> {{(165 + (2 * %a) + (2 * %b)),+,6}<%loop1>,+,6}<%loop2> U: full-set S: full-set --> (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (6 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) U: full-set S: full-set +; CHECK-NEXT: %s6 = add i32 %is2, %is1 +; CHECK-NEXT: --> {{(165 + (2 * %a) + (2 * %b)),+,6}<%loop1>,+,6}<%loop2> U: full-set S: full-set --> (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (6 * (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))))) U: full-set S: full-set +; CHECK-NEXT: Determining loop execution counts for: @test_01 +; CHECK-NEXT: Loop %loop2: backedge-taken count is (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is 167 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is (((-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (-1 * (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))) /u 6) + (1 umin (-165 + (-6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b)))))) + (-2 * %a) + (-2 * %b) + (1000 umax (165 + (2 * %a) + (2 * %b) + (6 * (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))))))))) +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 1 +; CHECK-NEXT: Loop %loop1: backedge-taken count is (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is 167 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is (((-6 + (-2 * %a) + (-1 * (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))) /u 6) + (1 umin (-6 + (-2 * %a) + (-1 * %b) + (1000 umax (6 + (2 * %a) + %b))))) +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 1 +; entry: br label %loop1 @@ -144,36 +221,74 @@ ; loops in any order. define void @test_02(i32 %a, i32 %b, ptr %p) { - -; CHECK-LABEL: Classifying expressions for: @test_02 -; CHECK: %sum1 = add i32 %phi1, %phi2 -; CHECK-NEXT: --> {(%a + %b),+,3}<%loop1> -; CHECK: %sum2 = add i32 %sum1, %phi3 -; CHECK-NEXT: --> {(6 + %a + %b),+,6}<%loop1> -; CHECK: %is1 = add i32 %sum2, %v1 -; CHECK-NEXT: --> ({(6 + %a + %b),+,6}<%loop1> + %v1) -; CHECK: %sum3 = add i32 %phi4, %phi5 -; CHECK-NEXT: --> {(%a + %b),+,3}<%loop2> -; CHECK: %sum4 = add i32 %sum3, %phi6 -; CHECK-NEXT: --> {(43 + %a + %b),+,6}<%loop2> -; CHECK: %is2 = add i32 %sum4, %v2 -; CHECK-NEXT: --> ({(43 + %a + %b),+,6}<%loop2> + %v2) -; CHECK: %is3 = add i32 %v1, %sum2 -; CHECK-NEXT: --> ({(6 + %a + %b),+,6}<%loop1> + %v1) -; CHECK: %ec2 = add i32 %is1, %is3 -; CHECK-NEXT: --> (2 * ({(6 + %a + %b),+,6}<%loop1> + %v1)) -; CHECK: %s1 = add i32 %phi1, %is1 -; CHECK-NEXT: --> ({(6 + (2 * %a) + %b),+,7}<%loop1> + %v1) -; CHECK: %s2 = add i32 %is2, %phi4 -; CHECK-NEXT: --> ({(43 + (2 * %a) + %b),+,7}<%loop2> + %v2) -; CHECK: %s3 = add i32 %is1, %phi5 -; CHECK-NEXT: --> {({(6 + (2 * %b) + %a),+,6}<%loop1> + %v1),+,2}<%loop2> -; CHECK: %s4 = add i32 %phi2, %is2 -; CHECK-NEXT: --> ({{{{}}(43 + (2 * %b) + %a),+,2}<%loop1>,+,6}<%loop2> + %v2) -; CHECK: %s5 = add i32 %is1, %is2 -; CHECK-NEXT: --> ({({(49 + (2 * %a) + (2 * %b)),+,6}<%loop1> + %v1),+,6}<%loop2> + %v2) -; CHECK: %s6 = add i32 %is2, %is1 -; CHECK-NEXT: --> ({({(49 + (2 * %a) + (2 * %b)),+,6}<%loop1> + %v1),+,6}<%loop2> + %v2) +; CHECK-LABEL: 'test_02' +; CHECK-NEXT: Classifying expressions for: @test_02 +; CHECK-NEXT: %phi1 = phi i32 [ %a, %entry ], [ %phi1.inc, %loop1 ] +; CHECK-NEXT: --> {%a,+,1}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2 = phi i32 [ %b, %entry ], [ %phi2.inc, %loop1 ] +; CHECK-NEXT: --> {%b,+,2}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi3 = phi i32 [ 6, %entry ], [ %phi3.inc, %loop1 ] +; CHECK-NEXT: --> {6,+,3}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi1.inc = add i32 %phi1, 1 +; CHECK-NEXT: --> {(1 + %a),+,1}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2.inc = add i32 %phi2, 2 +; CHECK-NEXT: --> {(2 + %b),+,2}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi3.inc = add i32 %phi3, 3 +; CHECK-NEXT: --> {9,+,3}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %v1 = load i32, ptr %p, align 4 +; CHECK-NEXT: --> %v1 U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Variant } +; CHECK-NEXT: %sum1 = add i32 %phi1, %phi2 +; CHECK-NEXT: --> {(%a + %b),+,3}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %sum2 = add i32 %sum1, %phi3 +; CHECK-NEXT: --> {(6 + %a + %b),+,6}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %is1 = add i32 %sum2, %v1 +; CHECK-NEXT: --> ({(6 + %a + %b),+,6}<%loop1> + %v1) U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Variant } +; CHECK-NEXT: %phi4 = phi i32 [ %a, %loop1 ], [ %phi4.inc, %loop2 ] +; CHECK-NEXT: --> {%a,+,1}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi5 = phi i32 [ %b, %loop1 ], [ %phi5.inc, %loop2 ] +; CHECK-NEXT: --> {%b,+,2}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi6 = phi i32 [ 43, %loop1 ], [ %phi6.inc, %loop2 ] +; CHECK-NEXT: --> {43,+,3}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi4.inc = add i32 %phi4, 1 +; CHECK-NEXT: --> {(1 + %a),+,1}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi5.inc = add i32 %phi5, 2 +; CHECK-NEXT: --> {(2 + %b),+,2}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi6.inc = add i32 %phi6, 3 +; CHECK-NEXT: --> {46,+,3}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %v2 = load i32, ptr %p, align 4 +; CHECK-NEXT: --> %v2 U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %sum3 = add i32 %phi4, %phi5 +; CHECK-NEXT: --> {(%a + %b),+,3}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %sum4 = add i32 %sum3, %phi6 +; CHECK-NEXT: --> {(43 + %a + %b),+,6}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %is2 = add i32 %sum4, %v2 +; CHECK-NEXT: --> ({(43 + %a + %b),+,6}<%loop2> + %v2) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %is3 = add i32 %v1, %sum2 +; CHECK-NEXT: --> ({(6 + %a + %b),+,6}<%loop1> + %v1) U: full-set S: full-set Exits: ({(6 + %a + %b),+,6}<%loop1> + %v1) LoopDispositions: { %loop2: Invariant } +; CHECK-NEXT: %ec2 = add i32 %is1, %is3 +; CHECK-NEXT: --> (2 * ({(6 + %a + %b),+,6}<%loop1> + %v1)) U: [0,-1) S: [-2147483648,2147483647) Exits: (2 * ({(6 + %a + %b),+,6}<%loop1> + %v1)) LoopDispositions: { %loop2: Invariant } +; CHECK-NEXT: %s1 = add i32 %phi1, %is1 +; CHECK-NEXT: --> ({(6 + (2 * %a) + %b),+,7}<%loop1> + %v1) U: full-set S: full-set +; CHECK-NEXT: %s2 = add i32 %is2, %phi4 +; CHECK-NEXT: --> ({(43 + (2 * %a) + %b),+,7}<%loop2> + %v2) U: full-set S: full-set +; CHECK-NEXT: %s3 = add i32 %is1, %phi5 +; CHECK-NEXT: --> {({(6 + (2 * %b) + %a),+,6}<%loop1> + %v1),+,2}<%loop2> U: full-set S: full-set +; CHECK-NEXT: %s4 = add i32 %phi2, %is2 +; CHECK-NEXT: --> ({{(43 + (2 * %b) + %a),+,2}<%loop1>,+,6}<%loop2> + %v2) U: full-set S: full-set +; CHECK-NEXT: %s5 = add i32 %is1, %is2 +; CHECK-NEXT: --> ({({(49 + (2 * %a) + (2 * %b)),+,6}<%loop1> + %v1),+,6}<%loop2> + %v2) U: full-set S: full-set +; CHECK-NEXT: %s6 = add i32 %is2, %is1 +; CHECK-NEXT: --> ({({(49 + (2 * %a) + (2 * %b)),+,6}<%loop1> + %v1),+,6}<%loop2> + %v2) U: full-set S: full-set +; CHECK-NEXT: Determining loop execution counts for: @test_02 +; CHECK-NEXT: Loop %loop2: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop2: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop2: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop2: Unpredictable predicated backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable predicated backedge-taken count. +; entry: br label %loop1 @@ -224,16 +339,36 @@ ; because we cannot prove for sure that it doesn't use Phis of loop 2. define void @test_03(i32 %a, i32 %b, i32 %c, ptr %p) { - -; CHECK-LABEL: Classifying expressions for: @test_03 -; CHECK: %v1 = load i32, ptr %p -; CHECK-NEXT: --> %v1 -; CHECK: %s1 = add i32 %phi1, %v1 -; CHECK-NEXT: --> ({%a,+,1}<%loop1> + %v1) -; CHECK: %s2 = add i32 %s1, %b -; CHECK-NEXT: --> ({(%a + %b),+,1}<%loop1> + %v1) -; CHECK: %s3 = add i32 %s2, %phi2 -; CHECK-NEXT: --> ({{{{}}((2 * %a) + %b),+,1}<%loop1>,+,2}<%loop2> + %v1) +; CHECK-LABEL: 'test_03' +; CHECK-NEXT: Classifying expressions for: @test_03 +; CHECK-NEXT: %phi1 = phi i32 [ %a, %entry ], [ %phi1.inc, %loop1 ] +; CHECK-NEXT: --> {%a,+,1}<%loop1> U: full-set S: full-set Exits: (%a umax %c) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi1.inc = add i32 %phi1, 1 +; CHECK-NEXT: --> {(1 + %a),+,1}<%loop1> U: full-set S: full-set Exits: (1 + (%a umax %c)) LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %phi2 = phi i32 [ %a, %loop1 ], [ %phi2.inc, %loop2 ] +; CHECK-NEXT: --> {%a,+,2}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %phi2.inc = add i32 %phi2, 2 +; CHECK-NEXT: --> {(2 + %a),+,2}<%loop2> U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %v1 = load i32, ptr %p, align 4 +; CHECK-NEXT: --> %v1 U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %s1 = add i32 %phi1, %v1 +; CHECK-NEXT: --> ({%a,+,1}<%loop1> + %v1) U: full-set S: full-set --> ((%a umax %c) + %v1) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %s2 = add i32 %s1, %b +; CHECK-NEXT: --> ({(%a + %b),+,1}<%loop1> + %v1) U: full-set S: full-set --> ((%a umax %c) + %b + %v1) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %s3 = add i32 %s2, %phi2 +; CHECK-NEXT: --> ({{((2 * %a) + %b),+,1}<%loop1>,+,2}<%loop2> + %v1) U: full-set S: full-set --> ({((%a umax %c) + %a + %b),+,2}<%loop2> + %v1) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: Determining loop execution counts for: @test_03 +; CHECK-NEXT: Loop %loop2: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop2: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop2: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop2: Unpredictable predicated backedge-taken count. +; CHECK-NEXT: Loop %loop1: backedge-taken count is ((-1 * %a) + (%a umax %c)) +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is -1 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is ((-1 * %a) + (%a umax %c)) +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is ((-1 * %a) + (%a umax %c)) +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 1 +; entry: br label %loop1 @@ -262,29 +397,43 @@ ; Another mix of previous use cases that demonstrates that incorrect picking of ; a loop for a recurrence may cause a crash of SCEV analysis. define void @test_04() { - -; CHECK-LABEL: Classifying expressions for: @test_04 -; CHECK: %tmp = phi i64 [ 2, %bb ], [ %tmp4, %bb3 ] -; CHECK-NEXT: --> {2,+,1}<%loop1> -; CHECK: %tmp2 = trunc i64 %tmp to i32 -; CHECK-NEXT: --> {2,+,1}<%loop1> -; CHECK: %tmp4 = add nuw nsw i64 %tmp, 1 -; CHECK-NEXT: --> {3,+,1}<%loop1> -; CHECK: %tmp7 = phi i64 [ %tmp15, %loop2 ], [ 2, %loop1 ] -; CHECK-NEXT: --> {2,+,1}<%loop2> U: [2,9223372036854775807) S: [2,9223372036854775807) -; CHECK: %tmp9 = sext i8 %tmp8 to i64 -; CHECK-NEXT: --> (sext i8 %tmp8 to i64) U: [-128,128) S: [-128,128) -; CHECK: %tmp10 = sub i64 %tmp9, %tmp7 -; CHECK-NEXT: --> ((sext i8 %tmp8 to i64) + {-2,+,-1}<%loop2>) U: [9223372036854775682,126) S: [9223372036854775682,126) -; CHECK: %tmp11 = add i64 %tmp10, undef -; CHECK-NEXT: --> ((sext i8 %tmp8 to i64) + {(-2 + undef),+,-1}<%loop2>) -; CHECK: %tmp13 = trunc i64 %tmp11 to i32 -; CHECK-NEXT: --> ((sext i8 %tmp8 to i32) + {(-2 + (trunc i64 undef to i32)),+,-1}<%loop2>) -; CHECK: %tmp14 = sub i32 %tmp13, %tmp2 +; CHECK-LABEL: 'test_04' +; CHECK-NEXT: Classifying expressions for: @test_04 +; CHECK-NEXT: %tmp = phi i64 [ 2, %bb ], [ %tmp4, %bb3 ] +; CHECK-NEXT: --> {2,+,1}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %tmp2 = trunc i64 %tmp to i32 +; CHECK-NEXT: --> {2,+,1}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %tmp4 = add nuw nsw i64 %tmp, 1 +; CHECK-NEXT: --> {3,+,1}<%loop1> U: full-set S: full-set Exits: <> LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %tmp7 = phi i64 [ %tmp15, %loop2 ], [ 2, %loop1 ] +; CHECK-NEXT: --> {2,+,1}<%loop2> U: [2,9223372036854775807) S: [2,9223372036854775807) Exits: (-1 + (3 smax {2,+,1}<%loop1>)) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %tmp8 = load i8, ptr addrspace(1) undef, align 1 +; CHECK-NEXT: --> %tmp8 U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %tmp9 = sext i8 %tmp8 to i64 +; CHECK-NEXT: --> (sext i8 %tmp8 to i64) U: [-128,128) S: [-128,128) Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %tmp10 = sub i64 %tmp9, %tmp7 +; CHECK-NEXT: --> ((sext i8 %tmp8 to i64) + {-2,+,-1}<%loop2>) U: [9223372036854775682,126) S: [9223372036854775682,126) Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %tmp11 = add i64 %tmp10, undef +; CHECK-NEXT: --> ((sext i8 %tmp8 to i64) + {(-2 + undef),+,-1}<%loop2>) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %tmp13 = trunc i64 %tmp11 to i32 +; CHECK-NEXT: --> ((sext i8 %tmp8 to i32) + {(-2 + (trunc i64 undef to i32)),+,-1}<%loop2>) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %tmp14 = sub i32 %tmp13, %tmp2 +; CHECK-NEXT: --> ((sext i8 %tmp8 to i32) + {{(-4 + (trunc i64 undef to i32)),+,-1}<%loop1>,+,-1}<%loop2>) U: full-set S: full-set Exits: <> LoopDispositions: { %loop2: Variant } +; CHECK-NEXT: %tmp15 = add nuw nsw i64 %tmp7, 1 +; CHECK-NEXT: --> {3,+,1}<%loop2> U: [3,-9223372036854775808) S: [3,-9223372036854775808) Exits: (3 smax {2,+,1}<%loop1>) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: Determining loop execution counts for: @test_04 +; CHECK-NEXT: Loop %loop2: backedge-taken count is (-3 + (3 smax {2,+,1}<%loop1>)) +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is 9223372036854775804 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is (-3 + (3 smax {2,+,1}<%loop1>)) +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is (-3 + (3 smax {2,+,1}<%loop1>)) +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 1 +; CHECK-NEXT: Loop %loop1: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop1: Unpredictable predicated backedge-taken count. +; ; `{{[{][{]}}` is the ugliness needed to match `{{` -; CHECK-NEXT: --> ((sext i8 %tmp8 to i32) + {{[{][{]}}(-4 + (trunc i64 undef to i32)),+,-1}<%loop1>,+,-1}<%loop2>) -; CHECK: %tmp15 = add nuw nsw i64 %tmp7, 1 -; CHECK-NEXT: --> {3,+,1}<%loop2> bb: br label %loop1 @@ -319,57 +468,105 @@ ; Demonstrate a situation when we can add two recs with different degrees from ; the same loop. define void @test_05(i32 %N) { - -; CHECK-LABEL: Classifying expressions for: @test_05 -; CHECK: %SQ = mul i32 %i.0, %i.0 -; CHECK-NEXT: --> {4,+,5,+,2}<%bb3> -; CHECK: %tmp4 = mul i32 %i.0, 2 -; CHECK-NEXT: --> {4,+,2}<%bb3> -; CHECK: %tmp5 = sub i32 %SQ, %tmp4 -; CHECK-NEXT: --> {0,+,3,+,2}<%bb3> +; CHECK-LABEL: 'test_05' +; CHECK-NEXT: Classifying expressions for: @test_05 +; CHECK-NEXT: %"alloca point" = bitcast i32 0 to i32 +; CHECK-NEXT: --> 0 U: [0,1) S: [0,1) +; CHECK-NEXT: %tmp = getelementptr [1000 x i32], ptr @A, i32 0, i32 %i.0 +; CHECK-NEXT: --> {(8 + @A),+,4}<%bb3> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (408 + @A) LoopDispositions: { %bb3: Computable } +; CHECK-NEXT: %tmp2 = add i32 %i.0, 1 +; CHECK-NEXT: --> {3,+,1}<%bb3> U: [3,104) S: [3,104) Exits: 103 LoopDispositions: { %bb3: Computable } +; CHECK-NEXT: %i.0 = phi i32 [ 2, %entry ], [ %tmp2, %bb ] +; CHECK-NEXT: --> {2,+,1}<%bb3> U: [2,103) S: [2,103) Exits: 102 LoopDispositions: { %bb3: Computable } +; CHECK-NEXT: %SQ = mul i32 %i.0, %i.0 +; CHECK-NEXT: --> {4,+,5,+,2}<%bb3> U: full-set S: full-set Exits: 10404 LoopDispositions: { %bb3: Computable } +; CHECK-NEXT: %tmp4 = mul i32 %i.0, 2 +; CHECK-NEXT: --> {4,+,2}<%bb3> U: [4,205) S: [4,205) Exits: 204 LoopDispositions: { %bb3: Computable } +; CHECK-NEXT: %tmp5 = sub i32 %SQ, %tmp4 +; CHECK-NEXT: --> {0,+,3,+,2}<%bb3> U: full-set S: full-set Exits: 10200 LoopDispositions: { %bb3: Computable } +; CHECK-NEXT: Determining loop execution counts for: @test_05 +; CHECK-NEXT: Loop %bb3: backedge-taken count is 100 +; CHECK-NEXT: Loop %bb3: constant max backedge-taken count is 100 +; CHECK-NEXT: Loop %bb3: symbolic max backedge-taken count is 100 +; CHECK-NEXT: Loop %bb3: Predicated backedge-taken count is 100 +; CHECK-NEXT: Predicates: +; CHECK: Loop %bb3: Trip multiple is 101 +; entry: - %"alloca point" = bitcast i32 0 to i32 ; [#uses=0] - br label %bb3 + %"alloca point" = bitcast i32 0 to i32 ; [#uses=0] + br label %bb3 bb: ; preds = %bb3 - %tmp = getelementptr [1000 x i32], ptr @A, i32 0, i32 %i.0 ; [#uses=1] - store i32 123, ptr %tmp - %tmp2 = add i32 %i.0, 1 ; [#uses=1] - br label %bb3 + %tmp = getelementptr [1000 x i32], ptr @A, i32 0, i32 %i.0 ; [#uses=1] + store i32 123, ptr %tmp + %tmp2 = add i32 %i.0, 1 ; [#uses=1] + br label %bb3 bb3: ; preds = %bb, %entry - %i.0 = phi i32 [ 2, %entry ], [ %tmp2, %bb ] ; [#uses=3] - %SQ = mul i32 %i.0, %i.0 - %tmp4 = mul i32 %i.0, 2 - %tmp5 = sub i32 %SQ, %tmp4 - %tmp3 = icmp sle i32 %tmp5, 9999 ; [#uses=1] - br i1 %tmp3, label %bb, label %bb5 + %i.0 = phi i32 [ 2, %entry ], [ %tmp2, %bb ] ; [#uses=3] + %SQ = mul i32 %i.0, %i.0 + %tmp4 = mul i32 %i.0, 2 + %tmp5 = sub i32 %SQ, %tmp4 + %tmp3 = icmp sle i32 %tmp5, 9999 ; [#uses=1] + br i1 %tmp3, label %bb, label %bb5 bb5: ; preds = %bb3 - br label %return + br label %return return: ; preds = %bb5 - ret void + ret void } ; Check that we can add Phis from different loops with different nesting, nested ; loop comes first. define void @test_06() { - -; CHECK-LABEL: Classifying expressions for: @test_06 -; CHECK: %s1 = add i32 %phi1, %phi2 -; CHECK-NEXT: --> {{{{}}30,+,1}<%loop1>,+,2}<%loop2> -; CHECK: %s2 = add i32 %phi2, %phi1 -; CHECK-NEXT: --> {{{{}}30,+,1}<%loop1>,+,2}<%loop2> -; CHECK: %s3 = add i32 %phi1, %phi3 -; CHECK-NEXT: --> {{{{}}40,+,1}<%loop1>,+,3}<%loop3> -; CHECK: %s4 = add i32 %phi3, %phi1 -; CHECK-NEXT: --> {{{{}}40,+,1}<%loop1>,+,3}<%loop3> -; CHECK: %s5 = add i32 %phi2, %phi3 -; CHECK-NEXT: --> {{{{}}50,+,2}<%loop2>,+,3}<%loop3> -; CHECK: %s6 = add i32 %phi3, %phi2 -; CHECK-NEXT: --> {{{{}}50,+,2}<%loop2>,+,3}<%loop3> +; CHECK-LABEL: 'test_06' +; CHECK-NEXT: Classifying expressions for: @test_06 +; CHECK-NEXT: %phi1 = phi i32 [ 10, %entry ], [ %phi1.inc, %loop1.exit ] +; CHECK-NEXT: --> {10,+,1}<%loop1> U: [10,1000) S: [10,1000) Exits: 999 LoopDispositions: { %loop1: Computable, %loop2: Invariant } +; CHECK-NEXT: %phi2 = phi i32 [ 20, %loop1 ], [ %phi2.inc, %loop2 ] +; CHECK-NEXT: --> {20,+,2}<%loop2> U: [20,999) S: [20,999) Exits: 998 LoopDispositions: { %loop2: Computable, %loop1: Variant } +; CHECK-NEXT: %phi2.inc = add i32 %phi2, 2 +; CHECK-NEXT: --> {22,+,2}<%loop2> U: [22,1001) S: [22,1001) Exits: 1000 LoopDispositions: { %loop2: Computable, %loop1: Variant } +; CHECK-NEXT: %phi1.inc = add i32 %phi1, 1 +; CHECK-NEXT: --> {11,+,1}<%loop1> U: [11,1001) S: [11,1001) Exits: 1000 LoopDispositions: { %loop1: Computable, %loop2: Invariant } +; CHECK-NEXT: %phi3 = phi i32 [ 30, %loop1.exit ], [ %phi3.inc, %loop3 ] +; CHECK-NEXT: --> {30,+,3}<%loop3> U: [30,1000) S: [30,1000) Exits: 999 LoopDispositions: { %loop3: Computable } +; CHECK-NEXT: %phi3.inc = add i32 %phi3, 3 +; CHECK-NEXT: --> {33,+,3}<%loop3> U: [33,1003) S: [33,1003) Exits: 1002 LoopDispositions: { %loop3: Computable } +; CHECK-NEXT: %s1 = add i32 %phi1, %phi2 +; CHECK-NEXT: --> {{30,+,1}<%loop1>,+,2}<%loop2> U: [30,1998) S: [30,1998) --> 1997 U: [1997,1998) S: [1997,1998) +; CHECK-NEXT: %s2 = add i32 %phi2, %phi1 +; CHECK-NEXT: --> {{30,+,1}<%loop1>,+,2}<%loop2> U: [30,1998) S: [30,1998) --> 1997 U: [1997,1998) S: [1997,1998) +; CHECK-NEXT: %s3 = add i32 %phi1, %phi3 +; CHECK-NEXT: --> {{40,+,1}<%loop1>,+,3}<%loop3> U: [40,1999) S: [40,1999) --> 1998 U: [1998,1999) S: [1998,1999) +; CHECK-NEXT: %s4 = add i32 %phi3, %phi1 +; CHECK-NEXT: --> {{40,+,1}<%loop1>,+,3}<%loop3> U: [40,1999) S: [40,1999) --> 1998 U: [1998,1999) S: [1998,1999) +; CHECK-NEXT: %s5 = add i32 %phi2, %phi3 +; CHECK-NEXT: --> {{50,+,2}<%loop2>,+,3}<%loop3> U: [50,1998) S: [50,1998) --> 1997 U: [1997,1998) S: [1997,1998) +; CHECK-NEXT: %s6 = add i32 %phi3, %phi2 +; CHECK-NEXT: --> {{50,+,2}<%loop2>,+,3}<%loop3> U: [50,1998) S: [50,1998) --> 1997 U: [1997,1998) S: [1997,1998) +; CHECK-NEXT: Determining loop execution counts for: @test_06 +; CHECK-NEXT: Loop %loop3: backedge-taken count is 323 +; CHECK-NEXT: Loop %loop3: constant max backedge-taken count is 323 +; CHECK-NEXT: Loop %loop3: symbolic max backedge-taken count is 323 +; CHECK-NEXT: Loop %loop3: Predicated backedge-taken count is 323 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop3: Trip multiple is 324 +; CHECK-NEXT: Loop %loop2: backedge-taken count is 489 +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is 489 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is 489 +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is 489 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 490 +; CHECK-NEXT: Loop %loop1: backedge-taken count is 989 +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is 989 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is 989 +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is 989 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 990 +; entry: br label %loop1 @@ -408,20 +605,52 @@ ; Check that we can add Phis from different loops with different nesting, nested ; loop comes second. define void @test_07() { - -; CHECK-LABEL: Classifying expressions for: @test_07 -; CHECK: %s1 = add i32 %phi1, %phi2 -; CHECK-NEXT: --> {{{{}}30,+,1}<%loop1>,+,2}<%loop2> -; CHECK: %s2 = add i32 %phi2, %phi1 -; CHECK-NEXT: --> {{{{}}30,+,1}<%loop1>,+,2}<%loop2> -; CHECK: %s3 = add i32 %phi1, %phi3 -; CHECK-NEXT: --> {{{{}}40,+,3}<%loop3>,+,1}<%loop1> -; CHECK: %s4 = add i32 %phi3, %phi1 -; CHECK-NEXT: --> {{{{}}40,+,3}<%loop3>,+,1}<%loop1> -; CHECK: %s5 = add i32 %phi2, %phi3 -; CHECK-NEXT: --> {{{{}}50,+,3}<%loop3>,+,2}<%loop2> -; CHECK: %s6 = add i32 %phi3, %phi2 -; CHECK-NEXT: --> {{{{}}50,+,3}<%loop3>,+,2}<%loop2> +; CHECK-LABEL: 'test_07' +; CHECK-NEXT: Classifying expressions for: @test_07 +; CHECK-NEXT: %phi3 = phi i32 [ 30, %entry ], [ %phi3.inc, %loop3 ] +; CHECK-NEXT: --> {30,+,3}<%loop3> U: [30,1000) S: [30,1000) Exits: 999 LoopDispositions: { %loop3: Computable } +; CHECK-NEXT: %phi3.inc = add i32 %phi3, 3 +; CHECK-NEXT: --> {33,+,3}<%loop3> U: [33,1003) S: [33,1003) Exits: 1002 LoopDispositions: { %loop3: Computable } +; CHECK-NEXT: %phi1 = phi i32 [ 10, %loop3 ], [ %phi1.inc, %loop1.exit ] +; CHECK-NEXT: --> {10,+,1}<%loop1> U: [10,11) S: [10,11) Exits: 10 LoopDispositions: { %loop1: Computable, %loop2: Invariant } +; CHECK-NEXT: %phi2 = phi i32 [ 20, %loop1 ], [ %phi2.inc, %loop2 ] +; CHECK-NEXT: --> {20,+,2}<%loop2> U: [20,999) S: [20,999) Exits: 998 LoopDispositions: { %loop2: Computable, %loop1: Variant } +; CHECK-NEXT: %phi2.inc = add i32 %phi2, 2 +; CHECK-NEXT: --> {22,+,2}<%loop2> U: [22,1001) S: [22,1001) Exits: 1000 LoopDispositions: { %loop2: Computable, %loop1: Variant } +; CHECK-NEXT: %phi1.inc = add i32 %phi1, 1 +; CHECK-NEXT: --> {11,+,1}<%loop1> U: [11,12) S: [11,12) Exits: 11 LoopDispositions: { %loop1: Computable, %loop2: Invariant } +; CHECK-NEXT: %s1 = add i32 %phi1, %phi2 +; CHECK-NEXT: --> {{30,+,1}<%loop1>,+,2}<%loop2> U: [30,1009) S: [30,1009) --> 1008 U: [1008,1009) S: [1008,1009) +; CHECK-NEXT: %s2 = add i32 %phi2, %phi1 +; CHECK-NEXT: --> {{30,+,1}<%loop1>,+,2}<%loop2> U: [30,1009) S: [30,1009) --> 1008 U: [1008,1009) S: [1008,1009) +; CHECK-NEXT: %s3 = add i32 %phi1, %phi3 +; CHECK-NEXT: --> {{40,+,3}<%loop3>,+,1}<%loop1> U: [40,1010) S: [40,1010) --> 1009 U: [1009,1010) S: [1009,1010) +; CHECK-NEXT: %s4 = add i32 %phi3, %phi1 +; CHECK-NEXT: --> {{40,+,3}<%loop3>,+,1}<%loop1> U: [40,1010) S: [40,1010) --> 1009 U: [1009,1010) S: [1009,1010) +; CHECK-NEXT: %s5 = add i32 %phi2, %phi3 +; CHECK-NEXT: --> {{50,+,3}<%loop3>,+,2}<%loop2> U: [50,1998) S: [50,1998) --> 1997 U: [1997,1998) S: [1997,1998) +; CHECK-NEXT: %s6 = add i32 %phi3, %phi2 +; CHECK-NEXT: --> {{50,+,3}<%loop3>,+,2}<%loop2> U: [50,1998) S: [50,1998) --> 1997 U: [1997,1998) S: [1997,1998) +; CHECK-NEXT: Determining loop execution counts for: @test_07 +; CHECK-NEXT: Loop %loop2: backedge-taken count is 489 +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is 489 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is 489 +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is 489 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 490 +; CHECK-NEXT: Loop %loop1: backedge-taken count is 0 +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is 0 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is 0 +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is 0 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 1 +; CHECK-NEXT: Loop %loop3: backedge-taken count is 323 +; CHECK-NEXT: Loop %loop3: constant max backedge-taken count is 323 +; CHECK-NEXT: Loop %loop3: symbolic max backedge-taken count is 323 +; CHECK-NEXT: Loop %loop3: Predicated backedge-taken count is 323 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop3: Trip multiple is 324 +; entry: br label %loop3 @@ -460,16 +689,54 @@ ; Make sure that a complicated Phi does not get folded with rec's start value ; of a loop which is above. define void @test_08() { - -; CHECK-LABEL: Classifying expressions for: @test_08 -; CHECK: %tmp11 = add i64 %iv.2.2, %iv.2.1 -; CHECK-NEXT: --> ({0,+,-1}<%loop_2> + %iv.2.1) -; CHECK: %tmp12 = trunc i64 %tmp11 to i32 -; CHECK-NEXT: --> ((trunc i64 %iv.2.1 to i32) + {0,+,-1}<%loop_2>) -; CHECK: %tmp14 = mul i32 %tmp12, %tmp7 -; CHECK-NEXT: --> (((trunc i64 %iv.2.1 to i32) + {0,+,-1}<%loop_2>) * {-1,+,-1}<%loop_1>) -; CHECK: %tmp16 = mul i64 %iv.2.1, %iv.1.1 -; CHECK-NEXT: --> ({2,+,1}<%loop_1> * %iv.2.1) +; CHECK-LABEL: 'test_08' +; CHECK-NEXT: Classifying expressions for: @test_08 +; CHECK-NEXT: %iv.1.1 = phi i64 [ 2, %entry ], [ %iv.1.1.next, %loop_1_back_branch ] +; CHECK-NEXT: --> {2,+,1}<%loop_1> U: [2,4) S: [2,4) Exits: 3 LoopDispositions: { %loop_1: Computable } +; CHECK-NEXT: %iv.1.2 = phi i32 [ -1, %entry ], [ %iv.1.2.next, %loop_1_back_branch ] +; CHECK-NEXT: --> {-1,+,1}<%loop_1> U: full-set S: full-set Exits: 0 LoopDispositions: { %loop_1: Computable } +; CHECK-NEXT: %iv.1.1.next = add nuw nsw i64 %iv.1.1, 1 +; CHECK-NEXT: --> {3,+,1}<%loop_1> U: [3,5) S: [3,5) Exits: 4 LoopDispositions: { %loop_1: Computable } +; CHECK-NEXT: %iv.1.2.next = add nsw i32 %iv.1.2, 1 +; CHECK-NEXT: --> {0,+,1}<%loop_1> U: full-set S: full-set Exits: 1 LoopDispositions: { %loop_1: Computable } +; CHECK-NEXT: %tmp6 = sub i64 1, %iv.1.1 +; CHECK-NEXT: --> {-1,+,-1}<%loop_1> U: [-2,0) S: [-2,0) --> -2 U: [-2,-1) S: [-2,-1) +; CHECK-NEXT: %tmp7 = trunc i64 %tmp6 to i32 +; CHECK-NEXT: --> {-1,+,-1}<%loop_1> U: full-set S: full-set --> -2 U: [-2,-1) S: [-2,-1) +; CHECK-NEXT: %iv.2.1 = phi i64 [ 0, %loop_2_preheader ], [ %tmp16, %loop_2 ] +; CHECK-NEXT: --> %iv.2.1 U: full-set S: full-set Exits: 0 LoopDispositions: { %loop_2: Variant } +; CHECK-NEXT: %iv.2.2 = phi i64 [ 0, %loop_2_preheader ], [ %iv.2.2.next, %loop_2 ] +; CHECK-NEXT: --> {0,+,-1}<%loop_2> U: [0,1) S: [0,1) Exits: 0 LoopDispositions: { %loop_2: Computable } +; CHECK-NEXT: %iv.2.3 = phi i64 [ 2, %loop_2_preheader ], [ %iv.2.3.next, %loop_2 ] +; CHECK-NEXT: --> {2,+,1}<%loop_2> U: [2,3) S: [2,3) Exits: 2 LoopDispositions: { %loop_2: Computable } +; CHECK-NEXT: %tmp11 = add i64 %iv.2.2, %iv.2.1 +; CHECK-NEXT: --> ({0,+,-1}<%loop_2> + %iv.2.1) U: full-set S: full-set Exits: 0 LoopDispositions: { %loop_2: Variant } +; CHECK-NEXT: %tmp12 = trunc i64 %tmp11 to i32 +; CHECK-NEXT: --> ((trunc i64 %iv.2.1 to i32) + {0,+,-1}<%loop_2>) U: full-set S: full-set Exits: 0 LoopDispositions: { %loop_2: Variant } +; CHECK-NEXT: %tmp14 = mul i32 %tmp12, %tmp7 +; CHECK-NEXT: --> (((trunc i64 %iv.2.1 to i32) + {0,+,-1}<%loop_2>) * {-1,+,-1}<%loop_1>) U: full-set S: full-set --> (-2 * ((trunc i64 %iv.2.1 to i32) + {0,+,-1}<%loop_2>)) U: [0,-1) S: [-2147483648,2147483647) Exits: 0 LoopDispositions: { %loop_2: Variant } +; CHECK-NEXT: %tmp16 = mul i64 %iv.2.1, %iv.1.1 +; CHECK-NEXT: --> ({2,+,1}<%loop_1> * %iv.2.1) U: full-set S: full-set --> (3 * %iv.2.1) U: full-set S: full-set Exits: 0 LoopDispositions: { %loop_2: Variant } +; CHECK-NEXT: %iv.2.3.next = add nuw nsw i64 %iv.2.3, 1 +; CHECK-NEXT: --> {3,+,1}<%loop_2> U: [3,4) S: [3,4) Exits: 3 LoopDispositions: { %loop_2: Computable } +; CHECK-NEXT: %iv.2.2.next = add nsw i64 %iv.2.2, -1 +; CHECK-NEXT: --> {-1,+,-1}<%loop_2> U: [-1,0) S: [-1,0) Exits: -1 LoopDispositions: { %loop_2: Computable } +; CHECK-NEXT: %tmp10 = add i32 %iv.1.2, 3 +; CHECK-NEXT: --> {2,+,1}<%loop_1> U: full-set S: full-set --> 3 U: [3,4) S: [3,4) +; CHECK-NEXT: Determining loop execution counts for: @test_08 +; CHECK-NEXT: Loop %loop_2: backedge-taken count is 0 +; CHECK-NEXT: Loop %loop_2: constant max backedge-taken count is 0 +; CHECK-NEXT: Loop %loop_2: symbolic max backedge-taken count is 0 +; CHECK-NEXT: Loop %loop_2: Predicated backedge-taken count is 0 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop_2: Trip multiple is 1 +; CHECK-NEXT: Loop %loop_1: backedge-taken count is 1 +; CHECK-NEXT: Loop %loop_1: constant max backedge-taken count is 1 +; CHECK-NEXT: Loop %loop_1: symbolic max backedge-taken count is 1 +; CHECK-NEXT: Loop %loop_1: Predicated backedge-taken count is 1 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop_1: Trip multiple is 2 +; entry: br label %loop_1 @@ -515,22 +782,40 @@ } define i64 @test_09(i32 %param) { - -; CHECK-LABEL: Classifying expressions for: @test_09 -; CHECK: %iv1 = phi i64 [ %iv1.next, %guarded ], [ 0, %outer.loop ] -; CHECK-NEXT: --> {0,+,1}<%loop1> -; CHECK: %iv1.trunc = trunc i64 %iv1 to i32 -; CHECK-NEXT: --> {0,+,1}<%loop1> -; CHECK: %iv1.next = add nuw nsw i64 %iv1, 1 -; CHECK-NEXT: --> {1,+,1}<%loop1> -; CHECK: %iv2 = phi i32 [ %iv2.next, %loop2 ], [ %param, %loop2.preheader ] -; CHECK-NEXT: --> {%param,+,1}<%loop2> -; CHECK: %iv2.next = add i32 %iv2, 1 -; CHECK-NEXT: --> {(1 + %param),+,1}<%loop2> -; CHECK: %iv2.ext = sext i32 %iv2.next to i64 -; CHECK-NEXT: --> (sext i32 {(1 + %param),+,1}<%loop2> to i64) -; CHECK: %ret = mul i64 %iv1, %iv2.ext -; CHECK-NEXT: --> ((sext i32 {(1 + %param),+,1}<%loop2> to i64) * {0,+,1}<%loop1>) +; CHECK-LABEL: 'test_09' +; CHECK-NEXT: Classifying expressions for: @test_09 +; CHECK-NEXT: %iv1 = phi i64 [ %iv1.next, %guarded ], [ 0, %outer.loop ] +; CHECK-NEXT: --> {0,+,1}<%loop1> U: [0,3) S: [0,3) Exits: 2 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %iv1.trunc = trunc i64 %iv1 to i32 +; CHECK-NEXT: --> {0,+,1}<%loop1> U: full-set S: full-set Exits: 2 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %iv1.next = add nuw nsw i64 %iv1, 1 +; CHECK-NEXT: --> {1,+,1}<%loop1> U: [1,4) S: [1,4) Exits: 3 LoopDispositions: { %loop1: Computable } +; CHECK-NEXT: %iv2 = phi i32 [ %iv2.next, %loop2 ], [ %param, %loop2.preheader ] +; CHECK-NEXT: --> {%param,+,1}<%loop2> U: full-set S: full-set Exits: (2 smax %param) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %iv2.next = add i32 %iv2, 1 +; CHECK-NEXT: --> {(1 + %param),+,1}<%loop2> U: full-set S: full-set Exits: (1 + (2 smax %param)) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %iv2.ext = sext i32 %iv2.next to i64 +; CHECK-NEXT: --> (sext i32 {(1 + %param),+,1}<%loop2> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (1 + (2 smax %param)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) +; CHECK-NEXT: %ret = mul i64 %iv1, %iv2.ext +; CHECK-NEXT: --> ((sext i32 {(1 + %param),+,1}<%loop2> to i64) * {0,+,1}<%loop1>) U: [-4294967296,4294967295) S: [-4294967296,4294967295) --> (2 * (sext i32 (1 + (2 smax %param)) to i64)) U: [0,-1) S: [-4294967296,4294967295) +; CHECK-NEXT: Determining loop execution counts for: @test_09 +; CHECK-NEXT: Loop %loop2: backedge-taken count is ((-1 * %param) + (2 smax %param)) +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is -2147483646 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is ((-1 * %param) + (2 smax %param)) +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is ((-1 * %param) + (2 smax %param)) +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 1 +; CHECK-NEXT: Loop %loop1: backedge-taken count is 2 +; CHECK-NEXT: exit count for loop1: 100 +; CHECK-NEXT: exit count for guarded: 2 +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is 2 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is 2 +; CHECK-NEXT: symbolic max exit count for loop1: 100 +; CHECK-NEXT: symbolic max exit count for guarded: 2 +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is 2 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 1 +; entry: br label %outer.loop @@ -568,26 +853,52 @@ } define i64 @test_10(i32 %param) { - -; CHECK-LABEL: Classifying expressions for: @test_10 -; CHECK: %uncle = phi i64 [ %uncle.outer.next, %uncle.loop.backedge ], [ 0, %outer.loop ] -; CHECK-NEXT: --> {0,+,1}<%uncle.loop> -; CHECK: %iv1 = phi i64 [ %iv1.next, %guarded ], [ 0, %uncle.loop ] -; CHECK-NEXT: --> {0,+,1}<%loop1> -; CHECK: %iv1.trunc = trunc i64 %iv1 to i32 -; CHECK-NEXT: --> {0,+,1}<%loop1> -; CHECK: %iv1.next = add nuw nsw i64 %iv1, 1 -; CHECK-NEXT: --> {1,+,1}<%loop1> -; CHECK: %uncle.outer.next = add i64 %uncle, 1 -; CHECK-NEXT: --> {1,+,1}<%uncle.loop> -; CHECK: %iv2 = phi i32 [ %iv2.next, %loop2 ], [ %param, %loop2.preheader ] -; CHECK-NEXT: --> {%param,+,1}<%loop2> -; CHECK: %iv2.next = add i32 %iv2, 1 -; CHECK-NEXT: --> {(1 + %param),+,1}<%loop2> -; CHECK: %iv2.ext = sext i32 %iv2.next to i64 -; CHECK-NEXT: --> (sext i32 {(1 + %param),+,1}<%loop2> to i64) -; CHECK: %ret = mul i64 %iv1, %iv2.ext -; CHECK-NEXT: --> ((sext i32 {(1 + %param),+,1}<%loop2> to i64) * {0,+,1}<%loop1>) +; CHECK-LABEL: 'test_10' +; CHECK-NEXT: Classifying expressions for: @test_10 +; CHECK-NEXT: %uncle = phi i64 [ %uncle.outer.next, %uncle.loop.backedge ], [ 0, %outer.loop ] +; CHECK-NEXT: --> {0,+,1}<%uncle.loop> U: [0,1) S: [0,1) Exits: <> LoopDispositions: { %uncle.loop: Computable, %loop1: Invariant } +; CHECK-NEXT: %iv1 = phi i64 [ %iv1.next, %guarded ], [ 0, %uncle.loop ] +; CHECK-NEXT: --> {0,+,1}<%loop1> U: [0,3) S: [0,3) Exits: 2 LoopDispositions: { %loop1: Computable, %uncle.loop: Variant } +; CHECK-NEXT: %iv1.trunc = trunc i64 %iv1 to i32 +; CHECK-NEXT: --> {0,+,1}<%loop1> U: full-set S: full-set Exits: 2 LoopDispositions: { %loop1: Computable, %uncle.loop: Variant } +; CHECK-NEXT: %iv1.next = add nuw nsw i64 %iv1, 1 +; CHECK-NEXT: --> {1,+,1}<%loop1> U: [1,4) S: [1,4) Exits: 3 LoopDispositions: { %loop1: Computable, %uncle.loop: Variant } +; CHECK-NEXT: %uncle.outer.next = add i64 %uncle, 1 +; CHECK-NEXT: --> {1,+,1}<%uncle.loop> U: [1,2) S: [1,2) Exits: <> LoopDispositions: { %uncle.loop: Computable, %loop1: Invariant } +; CHECK-NEXT: %iv2 = phi i32 [ %iv2.next, %loop2 ], [ %param, %loop2.preheader ] +; CHECK-NEXT: --> {%param,+,1}<%loop2> U: full-set S: full-set Exits: (2 smax %param) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %iv2.next = add i32 %iv2, 1 +; CHECK-NEXT: --> {(1 + %param),+,1}<%loop2> U: full-set S: full-set Exits: (1 + (2 smax %param)) LoopDispositions: { %loop2: Computable } +; CHECK-NEXT: %iv2.ext = sext i32 %iv2.next to i64 +; CHECK-NEXT: --> (sext i32 {(1 + %param),+,1}<%loop2> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (1 + (2 smax %param)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) +; CHECK-NEXT: %ret = mul i64 %iv1, %iv2.ext +; CHECK-NEXT: --> ((sext i32 {(1 + %param),+,1}<%loop2> to i64) * {0,+,1}<%loop1>) U: [-4294967296,4294967295) S: [-4294967296,4294967295) --> (2 * (sext i32 (1 + (2 smax %param)) to i64)) U: [0,-1) S: [-4294967296,4294967295) +; CHECK-NEXT: Determining loop execution counts for: @test_10 +; CHECK-NEXT: Loop %loop2: backedge-taken count is ((-1 * %param) + (2 smax %param)) +; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is -2147483646 +; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is ((-1 * %param) + (2 smax %param)) +; CHECK-NEXT: Loop %loop2: Predicated backedge-taken count is ((-1 * %param) + (2 smax %param)) +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop2: Trip multiple is 1 +; CHECK-NEXT: Loop %loop1: backedge-taken count is 2 +; CHECK-NEXT: exit count for loop1: 100 +; CHECK-NEXT: exit count for guarded: 2 +; CHECK-NEXT: Loop %loop1: constant max backedge-taken count is 2 +; CHECK-NEXT: Loop %loop1: symbolic max backedge-taken count is 2 +; CHECK-NEXT: symbolic max exit count for loop1: 100 +; CHECK-NEXT: symbolic max exit count for guarded: 2 +; CHECK-NEXT: Loop %loop1: Predicated backedge-taken count is 2 +; CHECK-NEXT: Predicates: +; CHECK: Loop %loop1: Trip multiple is 1 +; CHECK-NEXT: Loop %uncle.loop: Unpredictable backedge-taken count. +; CHECK-NEXT: exit count for loop1: ***COULDNOTCOMPUTE*** +; CHECK-NEXT: exit count for uncle.loop.backedge: 0 +; CHECK-NEXT: Loop %uncle.loop: constant max backedge-taken count is 0 +; CHECK-NEXT: Loop %uncle.loop: symbolic max backedge-taken count is 0 +; CHECK-NEXT: symbolic max exit count for loop1: ***COULDNOTCOMPUTE*** +; CHECK-NEXT: symbolic max exit count for uncle.loop.backedge: 0 +; CHECK-NEXT: Loop %uncle.loop: Unpredictable predicated backedge-taken count. +; entry: br label %outer.loop Index: llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll +++ llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll @@ -626,13 +626,13 @@ ; CHECK-LABEL: 'test-add-not-header5' ; CHECK-NEXT: Classifying expressions for: @test-add-not-header5 ; CHECK-NEXT: %i = phi i32 [ %nexti, %loop ], [ 0, %entry ] -; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {0,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %index32 = add nsw i32 %i, %offset -; CHECK-NEXT: --> {%offset,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%offset,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %ptr = getelementptr inbounds float, ptr %input, i32 %index32 -; CHECK-NEXT: --> ((4 * (sext i32 {%offset,+,1}<%loop> to i64)) + %input) U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> ((4 * (sext i32 {%offset,+,1}<%loop> to i64)) + %input) U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %nexti = add nsw i32 %i, 1 -; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {1,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test-add-not-header5 ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. Index: llvm/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll +++ llvm/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll @@ -1,11 +1,12 @@ +; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 2 ; ; RUN: opt -disable-output "-passes=print" < %s 2>&1 | FileCheck %s define void @infer.sext.0(ptr %c, i32 %start, ptr %buf) { ; CHECK-LABEL: Classifying expressions for: @infer.sext.0 - entry: + entry: br label %loop - loop: + loop: %counter = phi i32 [ 0, %entry ], [ %counter.inc, %loop ] %idx = phi i32 [ %start, %entry ], [ %idx.inc, %loop ] %idx.inc = add nsw i32 %idx, 1 @@ -20,16 +21,16 @@ %counter.inc = add i32 %counter, 1 br i1 %condition, label %exit, label %loop - exit: + exit: ret void } define void @infer.zext.0(ptr %c, i32 %start, ptr %buf) { ; CHECK-LABEL: Classifying expressions for: @infer.zext.0 - entry: + entry: br label %loop - loop: + loop: %counter = phi i32 [ 0, %entry ], [ %counter.inc, %loop ] %idx = phi i32 [ %start, %entry ], [ %idx.inc, %loop ] %idx.inc = add nuw i32 %idx, 1 @@ -44,18 +45,18 @@ %counter.inc = add i32 %counter, 1 br i1 %condition, label %exit, label %loop - exit: + exit: ret void } define void @infer.sext.1(i32 %start, ptr %c) { ; CHECK-LABEL: Classifying expressions for: @infer.sext.1 - entry: + entry: %start.mul = mul i32 %start, 4 %start.real = add i32 %start.mul, 2 br label %loop - loop: + loop: %idx = phi i32 [ %start.real, %entry ], [ %idx.inc, %loop ] %idx.sext = sext i32 %idx to i64 ; CHECK: %idx.sext = sext i32 %idx to i64 @@ -64,18 +65,18 @@ %condition = load i1, ptr %c br i1 %condition, label %exit, label %loop - exit: + exit: ret void } define void @infer.sext.2(ptr %c, i8 %start) { ; CHECK-LABEL: Classifying expressions for: @infer.sext.2 - entry: + entry: %start.inc = add i8 %start, 1 %entry.condition = icmp slt i8 %start, 127 br i1 %entry.condition, label %loop, label %exit - loop: + loop: %idx = phi i8 [ %start.inc, %entry ], [ %idx.inc, %loop ] %idx.sext = sext i8 %idx to i16 ; CHECK: %idx.sext = sext i8 %idx to i16 @@ -84,18 +85,18 @@ %condition = load volatile i1, ptr %c br i1 %condition, label %exit, label %loop - exit: + exit: ret void } define void @infer.zext.1(ptr %c, i8 %start) { ; CHECK-LABEL: Classifying expressions for: @infer.zext.1 - entry: + entry: %start.inc = add i8 %start, 1 %entry.condition = icmp ult i8 %start, 255 br i1 %entry.condition, label %loop, label %exit - loop: + loop: %idx = phi i8 [ %start.inc, %entry ], [ %idx.inc, %loop ] %idx.zext = zext i8 %idx to i16 ; CHECK: %idx.zext = zext i8 %idx to i16 @@ -104,6 +105,6 @@ %condition = load volatile i1, ptr %c br i1 %condition, label %exit, label %loop - exit: + exit: ret void } Index: llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll +++ llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll @@ -150,7 +150,7 @@ ; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %N ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N ; CHECK-NEXT: Predicates: -; CHECK: Loop %loop: Trip multiple is 1 +; CHECK: Loop %loop: Trip multiple is 13 ; entry: %c.1 = icmp eq i64 %N, 12 @@ -966,18 +966,18 @@ ; CHECK-LABEL: 'crash' ; CHECK-NEXT: Classifying expressions for: @crash ; CHECK-NEXT: %text.addr.5 = phi ptr [ %incdec.ptr112, %while.cond111 ], [ null, %while.body ] -; CHECK-NEXT: --> {null,+,-1}<%while.cond111> U: full-set S: full-set Exits: <> LoopDispositions: { %while.cond111: Computable, %while.body: Variant } +; CHECK-NEXT: --> {null,+,-1}<%while.cond111> U: full-set S: full-set Exits: <> LoopDispositions: { %while.cond111: Computable, %while.body: Variant } ; CHECK-NEXT: %incdec.ptr112 = getelementptr inbounds i8, ptr %text.addr.5, i64 -1 -; CHECK-NEXT: --> {(-1 + null),+,-1}<%while.cond111> U: full-set S: full-set Exits: <> LoopDispositions: { %while.cond111: Computable, %while.body: Variant } +; CHECK-NEXT: --> {(-1 + null),+,-1}<%while.cond111> U: full-set S: full-set Exits: <> LoopDispositions: { %while.cond111: Computable, %while.body: Variant } ; CHECK-NEXT: %lastout.2271 = phi ptr [ %incdec.ptr126, %while.body125 ], [ %ptr, %while.end117 ] -; CHECK-NEXT: --> {%ptr,+,1}<%while.body125> U: full-set S: full-set Exits: {(-2 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } +; CHECK-NEXT: --> {%ptr,+,1}<%while.body125> U: full-set S: full-set Exits: {(-2 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } ; CHECK-NEXT: %incdec.ptr126 = getelementptr inbounds i8, ptr %lastout.2271, i64 1 -; CHECK-NEXT: --> {(1 + %ptr),+,1}<%while.body125> U: full-set S: full-set Exits: {(-1 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } +; CHECK-NEXT: --> {(1 + %ptr),+,1}<%while.body125> U: full-set S: full-set Exits: {(-1 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } ; CHECK-NEXT: Determining loop execution counts for: @crash -; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> +; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> ; CHECK-NEXT: Loop %while.body125: constant max backedge-taken count is -2 -; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> -; CHECK-NEXT: Loop %while.body125: Predicated backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> +; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> +; CHECK-NEXT: Loop %while.body125: Predicated backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> ; CHECK-NEXT: Predicates: ; CHECK: Loop %while.body125: Trip multiple is 1 ; CHECK-NEXT: Loop %while.cond111: Unpredictable backedge-taken count. Index: llvm/test/Analysis/ScalarEvolution/max-expr-cache.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/max-expr-cache.ll +++ llvm/test/Analysis/ScalarEvolution/max-expr-cache.ll @@ -11,7 +11,7 @@ ; CHECK-LABEL: 'smax' ; CHECK-NEXT: Classifying expressions for: @smax ; CHECK-NEXT: %tmp5 = phi i64 [ %tmp62, %bb61 ], [ 0, %entry ] -; CHECK-NEXT: --> {0,+,1}<%bb4> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } +; CHECK-NEXT: --> {0,+,1}<%bb4> U: full-set S: full-set Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } ; CHECK-NEXT: %tmp6 = trunc i64 %tmp5 to i32 ; CHECK-NEXT: --> {0,+,1}<%bb4> U: full-set S: full-set Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } ; CHECK-NEXT: %tmp7 = shl nsw i32 %tmp6, 8 @@ -85,7 +85,7 @@ ; CHECK-NEXT: %tmp59 = add nsw i64 %tmp54, 1 ; CHECK-NEXT: --> {(1 + undef),+,1}<%bb53> U: full-set S: full-set Exits: (zext i32 (0 smax %tmp49) to i64) LoopDispositions: { %bb53: Computable, %bb4: Variant } ; CHECK-NEXT: %tmp62 = add nuw nsw i64 %tmp5, 1 -; CHECK-NEXT: --> {1,+,1}<%bb4> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } +; CHECK-NEXT: --> {1,+,1}<%bb4> U: full-set S: full-set Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } ; CHECK-NEXT: Determining loop execution counts for: @smax ; CHECK-NEXT: Loop %bb53: backedge-taken count is (-1 + (zext i32 (0 smax %tmp49) to i64) + (-1 * undef)) ; CHECK-NEXT: Loop %bb53: constant max backedge-taken count is -1 @@ -173,7 +173,7 @@ ; CHECK-LABEL: 'umax' ; CHECK-NEXT: Classifying expressions for: @umax ; CHECK-NEXT: %tmp5 = phi i64 [ %tmp62, %bb61 ], [ 0, %entry ] -; CHECK-NEXT: --> {0,+,1}<%bb4> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } +; CHECK-NEXT: --> {0,+,1}<%bb4> U: full-set S: full-set Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } ; CHECK-NEXT: %tmp6 = trunc i64 %tmp5 to i32 ; CHECK-NEXT: --> {0,+,1}<%bb4> U: full-set S: full-set Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } ; CHECK-NEXT: %tmp7 = shl nsw i32 %tmp6, 8 @@ -247,7 +247,7 @@ ; CHECK-NEXT: %tmp59 = add nsw i64 %tmp54, 1 ; CHECK-NEXT: --> {(1 + undef),+,1}<%bb53> U: full-set S: full-set Exits: (zext i32 %tmp49 to i64) LoopDispositions: { %bb53: Computable, %bb4: Variant } ; CHECK-NEXT: %tmp62 = add nuw nsw i64 %tmp5, 1 -; CHECK-NEXT: --> {1,+,1}<%bb4> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } +; CHECK-NEXT: --> {1,+,1}<%bb4> U: full-set S: full-set Exits: <> LoopDispositions: { %bb4: Computable, %bb53: Invariant } ; CHECK-NEXT: Determining loop execution counts for: @umax ; CHECK-NEXT: Loop %bb53: backedge-taken count is (-1 + (zext i32 %tmp49 to i64) + (-1 * undef)) ; CHECK-NEXT: Loop %bb53: constant max backedge-taken count is -1 Index: llvm/test/Analysis/ScalarEvolution/nowrap-preinc-limits.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/nowrap-preinc-limits.ll +++ llvm/test/Analysis/ScalarEvolution/nowrap-preinc-limits.ll @@ -1,45 +1,78 @@ +; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 2 ; RUN: opt -disable-output "-passes=print" < %s 2>&1 | FileCheck %s define void @f(ptr %condition) { -; CHECK-LABEL: Classifying expressions for: @f - entry: +; CHECK-LABEL: 'f' +; CHECK-NEXT: Classifying expressions for: @f +; CHECK-NEXT: %idx = phi i32 [ 0, %entry ], [ %idx.inc, %loop ] +; CHECK-NEXT: --> {0,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %idx.inc = add nsw i32 %idx, 1 +; CHECK-NEXT: --> {1,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %idx.inc2 = add i32 %idx.inc, 1 +; CHECK-NEXT: --> {2,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %idx.inc2.zext = zext i32 %idx.inc2 to i64 +; CHECK-NEXT: --> (zext i32 {2,+,1}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %c = load volatile i1, ptr %condition, align 1 +; CHECK-NEXT: --> %c U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } +; CHECK-NEXT: Determining loop execution counts for: @f +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. +; + entry: br label %loop - loop: + loop: %idx = phi i32 [ 0, %entry ], [ %idx.inc, %loop ] %idx.inc = add nsw i32 %idx, 1 %idx.inc2 = add i32 %idx.inc, 1 %idx.inc2.zext = zext i32 %idx.inc2 to i64 -; CHECK: %idx.inc2.zext = zext i32 %idx.inc2 to i64 -; CHECK-NEXT: --> {2,+,1}<%loop> %c = load volatile i1, ptr %condition br i1 %c, label %loop, label %exit - exit: + exit: ret void } define void @g(ptr %condition) { -; CHECK-LABEL: Classifying expressions for: @g - entry: +; CHECK-LABEL: 'g' +; CHECK-NEXT: Classifying expressions for: @g +; CHECK-NEXT: %idx = phi i32 [ 0, %entry ], [ %idx.inc, %loop ] +; CHECK-NEXT: --> {0,+,3}<%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %idx.inc = add nsw i32 %idx, 3 +; CHECK-NEXT: --> {3,+,3}<%loop> U: [3,-2147483648) S: [3,-2147483648) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %idx.inc2 = add i32 %idx.inc, -1 +; CHECK-NEXT: --> {2,+,3}<%loop> U: [2,-2147483648) S: [2,-2147483648) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %idx.inc2.sext = sext i32 %idx.inc2 to i64 +; CHECK-NEXT: --> {2,+,3}<%loop> U: [2,-9223372036854775808) S: [2,-9223372036854775808) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %cond.gep = getelementptr inbounds i1, ptr %condition, i32 %idx.inc +; CHECK-NEXT: --> {(3 + %condition),+,3}<%loop> U: [3,0) S: [3,0) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %c = load volatile i1, ptr %cond.gep, align 1 +; CHECK-NEXT: --> %c U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } +; CHECK-NEXT: Determining loop execution counts for: @g +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. +; + entry: br label %loop - loop: + loop: %idx = phi i32 [ 0, %entry ], [ %idx.inc, %loop ] %idx.inc = add nsw i32 %idx, 3 %idx.inc2 = add i32 %idx.inc, -1 %idx.inc2.sext = sext i32 %idx.inc2 to i64 -; CHECK: %idx.inc2.sext = sext i32 %idx.inc2 to i64 -; CHECK-NEXT: --> {2,+,3}<%loop> %cond.gep = getelementptr inbounds i1, ptr %condition, i32 %idx.inc %c = load volatile i1, ptr %cond.gep br i1 %c, label %loop, label %exit - exit: + exit: ret void } Index: llvm/test/Analysis/ScalarEvolution/nsw.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/nsw.ll +++ llvm/test/Analysis/ScalarEvolution/nsw.ll @@ -174,9 +174,9 @@ ; CHECK-NEXT: %tmp2 = phi ptr [ %arg, %bb ], [ %tmp5, %bb1 ] ; CHECK-NEXT: --> {%arg,+,4}<%bb1> U: full-set S: full-set Exits: (4 + %arg) LoopDispositions: { %bb1: Computable } ; CHECK-NEXT: %tmp3 = phi i32 [ 0, %bb ], [ %tmp4, %bb1 ] -; CHECK-NEXT: --> {0,+,1}<%bb1> U: [0,-2147483648) S: [0,-2147483648) Exits: 1 LoopDispositions: { %bb1: Computable } +; CHECK-NEXT: --> {0,+,1}<%bb1> U: full-set S: full-set Exits: 1 LoopDispositions: { %bb1: Computable } ; CHECK-NEXT: %tmp4 = add nsw i32 %tmp3, 1 -; CHECK-NEXT: --> {1,+,1}<%bb1> U: [1,0) S: [1,0) Exits: 2 LoopDispositions: { %bb1: Computable } +; CHECK-NEXT: --> {1,+,1}<%bb1> U: full-set S: full-set Exits: 2 LoopDispositions: { %bb1: Computable } ; CHECK-NEXT: %tmp5 = getelementptr inbounds i32, ptr %tmp2, i64 1 ; CHECK-NEXT: --> {(4 + %arg),+,4}<%bb1> U: [4,0) S: [4,0) Exits: (8 + %arg) LoopDispositions: { %bb1: Computable } ; CHECK-NEXT: Determining loop execution counts for: @PR12375 Index: llvm/test/Analysis/ScalarEvolution/pr27315.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/pr27315.ll +++ llvm/test/Analysis/ScalarEvolution/pr27315.ll @@ -1,16 +1,34 @@ +; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 2 ; RUN: opt -disable-output "-passes=print" < %s 2>&1 | FileCheck %s declare i1 @use(i64) define void @f_0() { -; CHECK-LABEL: Classifying expressions for: @f_0 +; CHECK-LABEL: 'f_0' +; CHECK-NEXT: Classifying expressions for: @f_0 +; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc.nowrap, %be ] +; CHECK-NEXT: --> {0,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %iv.inc.maywrap = add i32 %iv, 1 +; CHECK-NEXT: --> {1,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %iv.inc.maywrap.sext = sext i32 %iv.inc.maywrap to i64 +; CHECK-NEXT: --> (sext i32 {1,+,1}<%loop> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %cond0 = call i1 @use(i64 %iv.inc.maywrap.sext) +; CHECK-NEXT: --> %cond0 U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } +; CHECK-NEXT: %iv.inc.nowrap = add nsw i32 %iv, 1 +; CHECK-NEXT: --> {1,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: %be.cond = call i1 @use(i64 0) +; CHECK-NEXT: --> %be.cond U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } +; CHECK-NEXT: Determining loop execution counts for: @f_0 +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** +; CHECK-NEXT: exit count for be: ***COULDNOTCOMPUTE*** +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** +; CHECK-NEXT: symbolic max exit count for be: ***COULDNOTCOMPUTE*** +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. +; -; CHECK: %iv = phi i32 [ 0, %entry ], [ %iv.inc.nowrap, %be ] -; CHECK-NEXT: --> {0,+,1}<%loop> -; CHECK: %iv.inc.maywrap = add i32 %iv, 1 -; CHECK-NEXT: --> {1,+,1}<%loop> -; CHECK: %iv.inc.maywrap.sext = sext i32 %iv.inc.maywrap to i64 -; CHECK-NEXT: --> (sext i32 {1,+,1}<%loop> to i64) entry: br label %loop Index: llvm/test/Analysis/ScalarEvolution/range-signedness.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/range-signedness.ll +++ llvm/test/Analysis/ScalarEvolution/range-signedness.ll @@ -5,9 +5,9 @@ ; CHECK-LABEL: 'x' ; CHECK-NEXT: Classifying expressions for: @x ; CHECK-NEXT: %idx = phi i8 [ 0, %entry ], [ %idx.inc, %loop ] -; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,-128) S: [0,-128) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {0,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %idx.inc = add nsw i8 %idx, 1 -; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {1,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %c = load volatile i1, ptr %cond, align 1 ; CHECK-NEXT: --> %c U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } ; CHECK-NEXT: Determining loop execution counts for: @x Index: llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll +++ llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll @@ -29,7 +29,7 @@ ; CHECK-LABEL: 'smin_simplify_with_guard' ; CHECK-NEXT: Classifying expressions for: @smin_simplify_with_guard ; CHECK-NEXT: %i.011 = phi i32 [ %n, %for.body.lr.ph ], [ %dec, %for.body ] -; CHECK-NEXT: --> {%n,+,-1}<%for.body> U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Computable } +; CHECK-NEXT: --> {%n,+,-1}<%for.body> U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: %dec = add nsw i32 %i.011, -1 ; CHECK-NEXT: --> {(-1 + %n),+,-1}<%for.body> U: full-set S: full-set Exits: -1 LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: Determining loop execution counts for: @smin_simplify_with_guard @@ -66,7 +66,7 @@ ; CHECK-LABEL: 'smin_to_smax' ; CHECK-NEXT: Classifying expressions for: @smin_to_smax ; CHECK-NEXT: %i.011 = phi i32 [ %n, %for.body.lr.ph ], [ %dec, %for.body ] -; CHECK-NEXT: --> {%n,+,-1}<%for.body> U: full-set S: full-set Exits: (0 smin %n) LoopDispositions: { %for.body: Computable } +; CHECK-NEXT: --> {%n,+,-1}<%for.body> U: full-set S: full-set Exits: (0 smin %n) LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: %dec = add nsw i32 %i.011, -1 ; CHECK-NEXT: --> {(-1 + %n),+,-1}<%for.body> U: full-set S: full-set Exits: (-1 + (0 smin %n)) LoopDispositions: { %for.body: Computable } ; CHECK-NEXT: Determining loop execution counts for: @smin_to_smax Index: llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll =================================================================== --- llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll +++ llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll @@ -31,12 +31,10 @@ define void @unsimplified_and2(i32 %n) { ; CHECK-LABEL: 'unsimplified_and2' ; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and2 -; CHECK-NEXT: Loop %loop: backedge-taken count is %n -; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n -; CHECK-NEXT: Predicates: -; CHECK: Loop %loop: Trip multiple is 1 +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. ; entry: br label %loop @@ -147,12 +145,10 @@ define void @unsimplified_or3(i32 %n) { ; CHECK-LABEL: 'unsimplified_or3' ; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or3 -; CHECK-NEXT: Loop %loop: backedge-taken count is %n -; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n -; CHECK-NEXT: Predicates: -; CHECK: Loop %loop: Trip multiple is 1 +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. ; entry: br label %loop @@ -219,12 +215,10 @@ define void @reversed_and2(i32 %n) { ; CHECK-LABEL: 'reversed_and2' ; CHECK-NEXT: Determining loop execution counts for: @reversed_and2 -; CHECK-NEXT: Loop %loop: backedge-taken count is %n -; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n -; CHECK-NEXT: Predicates: -; CHECK: Loop %loop: Trip multiple is 1 +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. ; entry: br label %loop @@ -335,12 +329,10 @@ define void @reversed_or3(i32 %n) { ; CHECK-LABEL: 'reversed_or3' ; CHECK-NEXT: Determining loop execution counts for: @reversed_or3 -; CHECK-NEXT: Loop %loop: backedge-taken count is %n -; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n -; CHECK-NEXT: Predicates: -; CHECK: Loop %loop: Trip multiple is 1 +; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. ; entry: br label %loop Index: llvm/test/Transforms/IndVarSimplify/X86/pr27133.ll =================================================================== --- llvm/test/Transforms/IndVarSimplify/X86/pr27133.ll +++ llvm/test/Transforms/IndVarSimplify/X86/pr27133.ll @@ -8,12 +8,12 @@ ; CHECK-NEXT: entry: ; CHECK-NEXT: br label [[FOR_COND:%.*]] ; CHECK: for.cond: -; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] -; CHECK-NEXT: [[INDVARS1:%.*]] = trunc i64 [[INDVARS_IV]] to i32 -; CHECK-NEXT: invoke void @fn1(i64 [[INDVARS_IV]]) +; CHECK-NEXT: [[C_0:%.*]] = phi i32 [ [[INC:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] +; CHECK-NEXT: [[IDXPROM:%.*]] = sext i32 [[C_0]] to i64 +; CHECK-NEXT: invoke void @fn1(i64 [[IDXPROM]]) ; CHECK-NEXT: to label [[FOR_INC]] unwind label [[CATCH_DISPATCH:%.*]] ; CHECK: catch.dispatch: -; CHECK-NEXT: [[C_0_LCSSA:%.*]] = phi i32 [ [[INDVARS1]], [[FOR_COND]] ] +; CHECK-NEXT: [[C_0_LCSSA:%.*]] = phi i32 [ [[C_0]], [[FOR_COND]] ] ; CHECK-NEXT: [[TMP0:%.*]] = catchswitch within none [label %catch] unwind to caller ; CHECK: catch: ; CHECK-NEXT: [[TMP1:%.*]] = catchpad within [[TMP0]] [ptr null, i32 64, ptr null] @@ -21,7 +21,7 @@ ; CHECK: exit: ; CHECK-NEXT: ret i32 [[C_0_LCSSA]] ; CHECK: for.inc: -; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add nuw i64 [[INDVARS_IV]], 1 +; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[C_0]], 1 ; CHECK-NEXT: br label [[FOR_COND]] ; entry: Index: llvm/test/Transforms/IndVarSimplify/lftr-pr31181.ll =================================================================== --- llvm/test/Transforms/IndVarSimplify/lftr-pr31181.ll +++ llvm/test/Transforms/IndVarSimplify/lftr-pr31181.ll @@ -286,7 +286,7 @@ ; CHECK-NEXT: store volatile i32 [[IV2]], ptr [[PTR]], align 4 ; CHECK-NEXT: br label [[ALWAYS_TAKEN]] ; CHECK: always_taken: -; CHECK-NEXT: [[IV2_INC]] = add nuw nsw i32 [[IV2]], 1 +; CHECK-NEXT: [[IV2_INC]] = add nuw i32 [[IV2]], 1 ; CHECK-NEXT: [[IV_INC]] = add nsw i32 [[IV]], 1 ; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[IV2_INC]], -2147483628 ; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND]], label [[FOR_END:%.*]] @@ -329,7 +329,7 @@ ; CHECK-NEXT: store volatile i32 [[IV2]], ptr [[PTR]], align 4 ; CHECK-NEXT: br label [[ALWAYS_TAKEN]] ; CHECK: always_taken: -; CHECK-NEXT: [[IV2_INC]] = add nsw i32 [[IV2]], 1 +; CHECK-NEXT: [[IV2_INC]] = add i32 [[IV2]], 1 ; CHECK-NEXT: [[IV_INC]] = add nsw i32 [[IV]], 1 ; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[IV2_INC]], -2147483629 ; CHECK-NEXT: br i1 [[EXITCOND]], label [[FOR_COND]], label [[FOR_END:%.*]] Index: llvm/test/Transforms/IndVarSimplify/lftr.ll =================================================================== --- llvm/test/Transforms/IndVarSimplify/lftr.ll +++ llvm/test/Transforms/IndVarSimplify/lftr.ll @@ -229,16 +229,13 @@ ; CHECK-NEXT: [[E:%.*]] = icmp sgt i8 [[N:%.*]], 3 ; CHECK-NEXT: br i1 [[E]], label [[LOOP_PREHEADER:%.*]], label [[EXIT:%.*]] ; CHECK: loop.preheader: -; CHECK-NEXT: [[TMP0:%.*]] = add i8 [[N]], 3 -; CHECK-NEXT: [[TMP1:%.*]] = lshr i8 [[TMP0]], 2 -; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i8 [[TMP1]], 1 ; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK: loop: -; CHECK-NEXT: [[I1:%.*]] = phi i8 [ [[I1_INC:%.*]], [[LOOP]] ], [ 0, [[LOOP_PREHEADER]] ] -; CHECK-NEXT: [[I1_INC]] = add nuw nsw i8 [[I1]], 1 +; CHECK-NEXT: [[I:%.*]] = phi i8 [ [[I_INC:%.*]], [[LOOP]] ], [ 0, [[LOOP_PREHEADER]] ] +; CHECK-NEXT: [[I_INC]] = add nsw i8 [[I]], 4 ; CHECK-NEXT: store volatile i8 0, ptr [[A:%.*]], align 1 -; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i8 [[I1_INC]], [[TMP2]] -; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]] +; CHECK-NEXT: [[C:%.*]] = icmp slt i8 [[I]], [[N]] +; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]] ; CHECK: exit.loopexit: ; CHECK-NEXT: br label [[EXIT]] ; CHECK: exit: Index: llvm/test/Transforms/IndVarSimplify/pr25578.ll =================================================================== --- llvm/test/Transforms/IndVarSimplify/pr25578.ll +++ llvm/test/Transforms/IndVarSimplify/pr25578.ll @@ -1,3 +1,4 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2 ; RUN: opt < %s -passes=indvars -S | FileCheck %s target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" @@ -5,15 +6,39 @@ ; CHECK-LABEL: @foo define void @foo() { +; CHECK-LABEL: define void @foo() { +; CHECK-NEXT: entry: +; CHECK-NEXT: br label [[L1_HEADER:%.*]] +; CHECK: L1_header: +; CHECK-NEXT: br label [[L2_HEADER:%.*]] +; CHECK: L2_header: +; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, [[L1_HEADER]] ], [ [[I_NEXT:%.*]], [[L2_LATCH:%.*]] ] +; CHECK-NEXT: [[I_PROM:%.*]] = sext i32 [[I]] to i64 +; CHECK-NEXT: call void @use(i64 [[I_PROM]]) +; CHECK-NEXT: br label [[L3_HEADER:%.*]] +; CHECK: L3_header: +; CHECK-NEXT: br i1 false, label [[L3_LATCH:%.*]], label [[L2_EXITING_1:%.*]] +; CHECK: L3_latch: +; CHECK-NEXT: br i1 false, label [[L3_HEADER]], label [[L2_EXITING_2:%.*]] +; CHECK: L2_exiting_1: +; CHECK-NEXT: br i1 false, label [[L2_LATCH]], label [[L1_LATCH:%.*]] +; CHECK: L2_exiting_2: +; CHECK-NEXT: br i1 false, label [[L2_LATCH]], label [[L1_LATCH]] +; CHECK: L2_latch: +; CHECK-NEXT: [[I_NEXT]] = add nsw i32 [[I]], 1 +; CHECK-NEXT: br label [[L2_HEADER]] +; CHECK: L1_latch: +; CHECK-NEXT: [[I_LCSSA:%.*]] = phi i32 [ [[I]], [[L2_EXITING_1]] ], [ [[I]], [[L2_EXITING_2]] ] +; CHECK-NEXT: br i1 true, label [[EXIT:%.*]], label [[L1_HEADER]] +; CHECK: exit: +; CHECK-NEXT: ret void +; entry: br label %L1_header L1_header: br label %L2_header -; CHECK: L2_header: -; CHECK: %[[INDVAR:.*]] = phi i64 -; CHECK: %[[TRUNC:.*]] = trunc i64 %[[INDVAR]] to i32 L2_header: %i = phi i32 [ 0, %L1_header ], [ %i_next, %L2_latch ] %i_prom = sext i32 %i to i64 @@ -37,8 +62,6 @@ br label %L2_header L1_latch: -; CHECK: L1_latch: -; CHECK: %i_lcssa = phi i32 [ %[[TRUNC]], %L2_exiting_1 ], [ %[[TRUNC]], %L2_exiting_2 ] %i_lcssa = phi i32 [ %i, %L2_exiting_1 ], [ %i, %L2_exiting_2 ] br i1 undef, label %exit, label %L1_header Index: llvm/test/Transforms/IndVarSimplify/pr55925.ll =================================================================== --- llvm/test/Transforms/IndVarSimplify/pr55925.ll +++ llvm/test/Transforms/IndVarSimplify/pr55925.ll @@ -13,15 +13,14 @@ ; CHECK-NEXT: entry: ; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK: loop: -; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ], [ 0, [[ENTRY:%.*]] ] -; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH]] ] +; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ] ; CHECK-NEXT: [[RES:%.*]] = invoke i32 @foo(i32 returned [[IV]]) ; CHECK-NEXT: to label [[LOOP_LATCH]] unwind label [[EXIT:%.*]] ; CHECK: loop.latch: -; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add i64 [[INDVARS_IV]], 1 +; CHECK-NEXT: [[EXT:%.*]] = zext i32 [[IV]] to i64 +; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[P:%.*]], i64 [[EXT]] ; CHECK-NEXT: [[IV_NEXT]] = add nuw i32 [[IV]], 1 -; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[INDVARS_IV]] to i32 -; CHECK-NEXT: [[TMP1:%.*]] = call i32 @foo(i32 [[TMP0]]) +; CHECK-NEXT: [[TMP0:%.*]] = call i32 @foo(i32 [[IV]]) ; CHECK-NEXT: br label [[LOOP]] ; CHECK: exit: ; CHECK-NEXT: [[LP:%.*]] = landingpad { ptr, i32 } @@ -54,20 +53,19 @@ ; CHECK-NEXT: entry: ; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK: loop: -; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ], [ 0, [[ENTRY:%.*]] ] -; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH]] ] +; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP_LATCH:%.*]] ] ; CHECK-NEXT: br i1 [[C:%.*]], label [[LOOP_INVOKE:%.*]], label [[LOOP_OTHER:%.*]] ; CHECK: loop.invoke: -; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[INDVARS_IV]] to i32 ; CHECK-NEXT: [[RES:%.*]] = invoke i32 @foo(i32 returned [[IV]]) ; CHECK-NEXT: to label [[LOOP_LATCH]] unwind label [[EXIT:%.*]] ; CHECK: loop.other: ; CHECK-NEXT: br label [[LOOP_LATCH]] ; CHECK: loop.latch: -; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ [[TMP0]], [[LOOP_INVOKE]] ], [ 0, [[LOOP_OTHER]] ] -; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add i64 [[INDVARS_IV]], 1 +; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ [[IV]], [[LOOP_INVOKE]] ], [ 0, [[LOOP_OTHER]] ] +; CHECK-NEXT: [[EXT:%.*]] = zext i32 [[IV]] to i64 +; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[P:%.*]], i64 [[EXT]] ; CHECK-NEXT: [[IV_NEXT]] = add nuw i32 [[IV]], 1 -; CHECK-NEXT: [[TMP1:%.*]] = call i32 @foo(i32 [[PHI]]) +; CHECK-NEXT: [[TMP0:%.*]] = call i32 @foo(i32 [[PHI]]) ; CHECK-NEXT: br label [[LOOP]] ; CHECK: exit: ; CHECK-NEXT: [[LP:%.*]] = landingpad { ptr, i32 } Index: llvm/test/Transforms/IndVarSimplify/scev-expander-preserve-lcssa.ll =================================================================== --- llvm/test/Transforms/IndVarSimplify/scev-expander-preserve-lcssa.ll +++ llvm/test/Transforms/IndVarSimplify/scev-expander-preserve-lcssa.ll @@ -437,7 +437,7 @@ ; CHECK-NEXT: br label [[WHILE_COND192]] ; CHECK: while.cond215: ; CHECK-NEXT: [[I_8_IN:%.*]] = phi i32 [ [[I_8:%.*]], [[WHILE_COND215]] ], [ [[I_7_LCSSA]], [[WHILE_COND215_PREHEADER]] ] -; CHECK-NEXT: [[I_8]] = add nuw nsw i32 [[I_8_IN]], 1 +; CHECK-NEXT: [[I_8]] = add nsw i32 [[I_8_IN]], 1 ; CHECK-NEXT: [[IDXPROM216:%.*]] = sext i32 [[I_8]] to i64 ; CHECK-NEXT: [[ARRAYIDX217:%.*]] = getelementptr inbounds [512 x i8], ptr null, i64 0, i64 [[IDXPROM216]] ; CHECK-NEXT: br label [[WHILE_COND215]] Index: llvm/test/Transforms/LoopSimplifyCFG/invalidate-scev-dispositions.ll =================================================================== --- llvm/test/Transforms/LoopSimplifyCFG/invalidate-scev-dispositions.ll +++ llvm/test/Transforms/LoopSimplifyCFG/invalidate-scev-dispositions.ll @@ -72,7 +72,7 @@ ; INDVARS-NEXT: [[IV_NEXT]] = add nuw nsw i16 [[IV]], 1 ; INDVARS-NEXT: br label [[INNER]] ; INDVARS: outer.latch: -; INDVARS-NEXT: [[OUTER_IV_NEXT]] = add nuw nsw i16 [[OUTER_IV]], 1 +; INDVARS-NEXT: [[OUTER_IV_NEXT]] = add nsw i16 [[OUTER_IV]], 1 ; INDVARS-NEXT: [[CMP_2:%.*]] = icmp eq i16 poison, [[OUTER_IV]] ; INDVARS-NEXT: br i1 [[CMP_2]], label [[OUTER_HEADER]], label [[EXIT:%.*]] ; INDVARS: exit: Index: llvm/test/Transforms/LoopStrengthReduce/AMDGPU/lsr-invalid-ptr-extend.ll =================================================================== --- llvm/test/Transforms/LoopStrengthReduce/AMDGPU/lsr-invalid-ptr-extend.ll +++ llvm/test/Transforms/LoopStrengthReduce/AMDGPU/lsr-invalid-ptr-extend.ll @@ -16,22 +16,24 @@ ; CHECK-NEXT: entry: ; CHECK-NEXT: br label [[FOR_BODY:%.*]] ; CHECK: loopexit: -; CHECK-NEXT: [[SCEVGEP13_LCSSA:%.*]] = phi ptr [ [[SCEVGEP13:%.*]], [[FOR_BODY]] ] -; CHECK-NEXT: [[SCEVGEP11_LCSSA:%.*]] = phi ptr addrspace(5) [ [[SCEVGEP11:%.*]], [[FOR_BODY]] ] +; CHECK-NEXT: [[LSR_IV_NEXT4_LCSSA:%.*]] = phi i32 [ [[LSR_IV_NEXT4:%.*]], [[FOR_BODY]] ] +; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[LSR_IV_NEXT4]], -1 +; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[TMP0]] to i64 ; CHECK-NEXT: br label [[FOR_BODY_1:%.*]] ; CHECK: for.body.1: -; CHECK-NEXT: [[LSR_IV5:%.*]] = phi ptr addrspace(5) [ [[SCEVGEP6:%.*]], [[FOR_BODY_1]] ], [ [[SCEVGEP11_LCSSA]], [[LOOPEXIT:%.*]] ] -; CHECK-NEXT: [[LSR_IV1:%.*]] = phi ptr [ [[SCEVGEP2:%.*]], [[FOR_BODY_1]] ], [ [[SCEVGEP13_LCSSA]], [[LOOPEXIT]] ] -; CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr addrspace(5) [[LSR_IV5]], align 8 -; CHECK-NEXT: store ptr [[TMP0]], ptr [[LSR_IV1]], align 8 -; CHECK-NEXT: [[SCEVGEP2]] = getelementptr i8, ptr [[LSR_IV1]], i64 8 -; CHECK-NEXT: [[SCEVGEP6]] = getelementptr i8, ptr addrspace(5) [[LSR_IV5]], i32 8 +; CHECK-NEXT: [[LSR_IV1:%.*]] = phi i32 [ [[LSR_IV_NEXT2:%.*]], [[FOR_BODY_1]] ], [ [[LSR_IV_NEXT4_LCSSA]], [[LOOPEXIT:%.*]] ] +; CHECK-NEXT: [[CONV_1:%.*]] = phi i64 [ [[CONV_2:%.*]], [[FOR_BODY_1]] ], [ [[CONV]], [[LOOPEXIT]] ] +; CHECK-NEXT: [[IDXPROM:%.*]] = trunc i64 [[CONV_1]] to i32 +; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds ptr, ptr addrspace(5) null, i32 [[IDXPROM]] +; CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr addrspace(5) [[ARRAYIDX]], align 8 +; CHECK-NEXT: [[ARRAYIDX_1:%.*]] = getelementptr inbounds ptr, ptr null, i64 [[CONV_1]] +; CHECK-NEXT: store ptr [[TMP1]], ptr [[ARRAYIDX_1]], align 8 +; CHECK-NEXT: [[CONV_2]] = zext i32 [[LSR_IV1]] to i64 +; CHECK-NEXT: [[LSR_IV_NEXT2]] = add i32 [[LSR_IV1]], 1 ; CHECK-NEXT: br label [[FOR_BODY_1]] ; CHECK: for.body: -; CHECK-NEXT: [[LSR_IV12:%.*]] = phi ptr [ [[SCEVGEP13]], [[FOR_BODY]] ], [ null, [[ENTRY:%.*]] ] -; CHECK-NEXT: [[LSR_IV10:%.*]] = phi ptr addrspace(5) [ [[SCEVGEP11]], [[FOR_BODY]] ], [ null, [[ENTRY]] ] -; CHECK-NEXT: [[SCEVGEP11]] = getelementptr i8, ptr addrspace(5) [[LSR_IV10]], i32 64 -; CHECK-NEXT: [[SCEVGEP13]] = getelementptr i8, ptr [[LSR_IV12]], i64 64 +; CHECK-NEXT: [[LSR_IV3:%.*]] = phi i32 [ [[LSR_IV_NEXT4]], [[FOR_BODY]] ], [ 1, [[ENTRY:%.*]] ] +; CHECK-NEXT: [[LSR_IV_NEXT4]] = add i32 [[LSR_IV3]], 8 ; CHECK-NEXT: br i1 false, label [[LOOPEXIT]], label [[FOR_BODY]] ; entry: Index: llvm/test/Transforms/LoopStrengthReduce/X86/sibling-loops.ll =================================================================== --- llvm/test/Transforms/LoopStrengthReduce/X86/sibling-loops.ll +++ llvm/test/Transforms/LoopStrengthReduce/X86/sibling-loops.ll @@ -17,7 +17,7 @@ ; CHECK: do.body: ; CHECK-NEXT: [[I_0:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[DO_BODY]] ] ; CHECK-NEXT: tail call void @goo(i64 [[I_0]], i64 [[I_0]]) -; CHECK-NEXT: [[INC]] = add nuw i64 [[I_0]], 1 +; CHECK-NEXT: [[INC]] = add i64 [[I_0]], 1 ; CHECK-NEXT: [[T0:%.*]] = load i64, ptr @cond, align 8 ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i64 [[T0]], 0 ; CHECK-NEXT: br i1 [[TOBOOL]], label [[DO_BODY2_PREHEADER:%.*]], label [[DO_BODY]] @@ -27,7 +27,7 @@ ; CHECK-NEXT: [[I_1:%.*]] = phi i64 [ [[INC3:%.*]], [[DO_BODY2]] ], [ 0, [[DO_BODY2_PREHEADER]] ] ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[INC]], [[I_1]] ; CHECK-NEXT: tail call void @goo(i64 [[I_1]], i64 [[TMP0]]) -; CHECK-NEXT: [[INC3]] = add nuw i64 [[I_1]], 1 +; CHECK-NEXT: [[INC3]] = add i64 [[I_1]], 1 ; CHECK-NEXT: [[T1:%.*]] = load i64, ptr @cond, align 8 ; CHECK-NEXT: [[TOBOOL6:%.*]] = icmp eq i64 [[T1]], 0 ; CHECK-NEXT: br i1 [[TOBOOL6]], label [[DO_BODY8_PREHEADER:%.*]], label [[DO_BODY2]] Index: llvm/test/Transforms/LoopUnroll/wrong_assert_in_peeling.ll =================================================================== --- llvm/test/Transforms/LoopUnroll/wrong_assert_in_peeling.ll +++ llvm/test/Transforms/LoopUnroll/wrong_assert_in_peeling.ll @@ -9,58 +9,29 @@ ; CHECK-NEXT: br label [[BB1:%.*]] ; CHECK: bb1: ; CHECK-NEXT: [[TMP:%.*]] = phi i32 [ -147, [[BB:%.*]] ], [ [[TMP14:%.*]], [[BB13:%.*]] ] -; CHECK-NEXT: br label [[BB2_PEEL_BEGIN:%.*]] -; CHECK: bb2.peel.begin: -; CHECK-NEXT: br label [[BB2_PEEL:%.*]] -; CHECK: bb2.peel: -; CHECK-NEXT: [[TMP4_PEEL:%.*]] = add nsw i32 undef, [[TMP]] -; CHECK-NEXT: br label [[BB5_PEEL:%.*]] -; CHECK: bb5.peel: -; CHECK-NEXT: [[TMP6_PEEL:%.*]] = icmp eq i32 undef, 33 -; CHECK-NEXT: br i1 [[TMP6_PEEL]], label [[BB7_PEEL:%.*]], label [[BB15_LOOPEXIT2:%.*]] -; CHECK: bb7.peel: -; CHECK-NEXT: [[TMP8_PEEL:%.*]] = sub nsw i32 undef, undef -; CHECK-NEXT: [[TMP9_PEEL:%.*]] = icmp eq i32 [[TMP8_PEEL]], 0 -; CHECK-NEXT: br i1 [[TMP9_PEEL]], label [[BB10_PEEL:%.*]], label [[BB10_PEEL]] -; CHECK: bb10.peel: -; CHECK-NEXT: [[TMP11_PEEL:%.*]] = icmp eq i8 undef, 0 -; CHECK-NEXT: br i1 [[TMP11_PEEL]], label [[BB12_PEEL:%.*]], label [[BB17_LOOPEXIT3:%.*]] -; CHECK: bb12.peel: -; CHECK-NEXT: br i1 false, label [[BB13]], label [[BB2_PEEL_NEXT:%.*]] -; CHECK: bb2.peel.next: -; CHECK-NEXT: br label [[BB2_PEEL_NEXT1:%.*]] -; CHECK: bb2.peel.next1: -; CHECK-NEXT: br label [[BB1_PEEL_NEWPH:%.*]] -; CHECK: bb1.peel.newph: ; CHECK-NEXT: br label [[BB2:%.*]] ; CHECK: bb2: -; CHECK-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP4_PEEL]], [[BB1_PEEL_NEWPH]] ], [ [[TMP4:%.*]], [[BB12:%.*]] ] +; CHECK-NEXT: [[TMP3:%.*]] = phi i32 [ undef, [[BB1]] ], [ [[TMP4:%.*]], [[BB12:%.*]] ] ; CHECK-NEXT: [[TMP4]] = add nsw i32 [[TMP3]], [[TMP]] ; CHECK-NEXT: br label [[BB5:%.*]] ; CHECK: bb5: -; CHECK-NEXT: br i1 undef, label [[BB7:%.*]], label [[BB15_LOOPEXIT:%.*]] +; CHECK-NEXT: [[TMP6:%.*]] = icmp eq i32 undef, 33 +; CHECK-NEXT: br i1 [[TMP6]], label [[BB7:%.*]], label [[BB15:%.*]] ; CHECK: bb7: -; CHECK-NEXT: br i1 undef, label [[BB10:%.*]], label [[BB10]] +; CHECK-NEXT: [[TMP8:%.*]] = sub nsw i32 [[TMP3]], undef +; CHECK-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 0 +; CHECK-NEXT: br i1 [[TMP9]], label [[BB10:%.*]], label [[BB10]] ; CHECK: bb10: -; CHECK-NEXT: br i1 undef, label [[BB12]], label [[BB17_LOOPEXIT:%.*]] +; CHECK-NEXT: [[TMP11:%.*]] = icmp eq i8 undef, 0 +; CHECK-NEXT: br i1 [[TMP11]], label [[BB12]], label [[BB17:%.*]] ; CHECK: bb12: -; CHECK-NEXT: br i1 false, label [[BB13_LOOPEXIT:%.*]], label [[BB2]], !llvm.loop [[LOOP0:![0-9]+]] -; CHECK: bb13.loopexit: -; CHECK-NEXT: br label [[BB13]] +; CHECK-NEXT: br i1 false, label [[BB13]], label [[BB2]] ; CHECK: bb13: ; CHECK-NEXT: [[TMP14]] = add nsw i32 [[TMP]], -1 ; CHECK-NEXT: br label [[BB1]] -; CHECK: bb15.loopexit: -; CHECK-NEXT: br label [[BB15:%.*]] -; CHECK: bb15.loopexit2: -; CHECK-NEXT: br label [[BB15]] ; CHECK: bb15: ; CHECK-NEXT: [[TMP16:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32(i32 17) [ "deopt"() ] ; CHECK-NEXT: ret i32 [[TMP16]] -; CHECK: bb17.loopexit: -; CHECK-NEXT: br label [[BB17:%.*]] -; CHECK: bb17.loopexit3: -; CHECK-NEXT: br label [[BB17]] ; CHECK: bb17: ; CHECK-NEXT: [[TMP18:%.*]] = call i32 (...) @llvm.experimental.deoptimize.i32(i32 6) [ "deopt"() ] ; CHECK-NEXT: ret i32 [[TMP18]]