Index: lib/Transforms/Scalar/SimpleLoopUnswitch.cpp =================================================================== --- lib/Transforms/Scalar/SimpleLoopUnswitch.cpp +++ lib/Transforms/Scalar/SimpleLoopUnswitch.cpp @@ -72,6 +72,17 @@ UnswitchThreshold("unswitch-threshold", cl::init(50), cl::Hidden, cl::desc("The cost threshold for unswitching a loop.")); +static cl::opt EnableUnswitchCostMultiplier( + "enable-unswitch-cost-multiplier", cl::init(true), cl::Hidden, + cl::desc("Enable unswitch cost multiplier that prohibits exponential " + "explosion in nontrivial unswitch.")); +static cl::opt UnswitchSiblingsToplevelDiv( + "unswitch-siblings-toplevel-div", cl::init(2), cl::Hidden, + cl::desc("Toplevel siblings divisor for cost multiplier.")); +static cl::opt UnswitchCandidatesBottomCap( + "unswitch-candidates-bottom-cap", cl::init(8), cl::Hidden, + cl::desc("Amount of unswitch candidates that are ignored when calculating " + "cost multiplier.")); static cl::opt UnswitchGuards( "simple-loop-unswitch-guards", cl::init(true), cl::Hidden, cl::desc("If enabled, simple loop unswitching will also consider " @@ -2260,6 +2271,56 @@ return CheckBI; } +/// Cost multiplier is a way to limit potentially exponential behavior +/// of loop-unswitch. Cost is multipied in proportion of 2^number of unswitch +/// candidates available. Also accounting for the number of "sibling" loops with +/// the idea to account for previous unswitches that already happened on this +/// cluster of loops. Formula is kept intentionally simple since it is designed +/// to limit the worst case behavior. It is not an attempt to provide a detailed +/// heuristic size prediction. +static int calculateUnswitchCostMultiplier( + Instruction &TI, Loop &L, LoopInfo &LI, + ArrayRef>> + UnswitchCandidates) { + + // Exiting branches (including guards) do not lead to duplication of the loop, thus the cant + // cause exponential behavior during the unswitch. + if (isGuard(&TI) || L.isLoopExiting(TI.getParent())) + return 1; + + auto *ParentL = L.getParentLoop(); + int SiblingsCount = (ParentL ? ParentL->getSubLoopsVector().size() + : std::distance(LI.begin(), LI.end())); + // Ignore up to the "bottom cap" number of unswitch candidates when + // calculating the power-of-two scaling of the cost. The main idea + // with this cap is to allow a small number of unswitches to happen + // and rely more on siblings multiplier (see below) when the number + // of candidates is small. + unsigned CandidatesPower = std::max( + (int)UnswitchCandidates.size() - (int)UnswitchCandidatesBottomCap, 0); + + // Allowing top-level loops to spread a bit more than nested ones. + int SiblingsMultiplier = + std::max((ParentL ? SiblingsCount + : SiblingsCount / (int)UnswitchSiblingsToplevelDiv), + 1); + // Compute the cost multiplier in a way that won't overflow by saturating + // at an upper bound. + int CostMultiplier; + if (CandidatesPower > Log2_32(UnswitchThreshold) || + SiblingsMultiplier > UnswitchThreshold) + CostMultiplier = UnswitchThreshold; + else + CostMultiplier = std::min(SiblingsMultiplier * (1 << CandidatesPower), + (int)UnswitchThreshold); + + LLVM_DEBUG(dbgs() << " Computed multiplier " << CostMultiplier + << " (siblings " << SiblingsMultiplier << " * candidates " + << (1 << CandidatesPower) << ")" + << " for unswitch candidate: " << TI << "\n"); + return CostMultiplier; +} + static bool unswitchBestCondition(Loop &L, DominatorTree &DT, LoopInfo &LI, AssumptionCache &AC, TargetTransformInfo &TTI, @@ -2473,8 +2534,23 @@ int CandidateCost = ComputeUnswitchedCost( TI, /*FullUnswitch*/ !BI || (Invariants.size() == 1 && Invariants[0] == BI->getCondition())); - LLVM_DEBUG(dbgs() << " Computed cost of " << CandidateCost - << " for unswitch candidate: " << TI << "\n"); + // Calculate cost multiplier which is a tool to limit potentially + // exponential behavior of loop-unswitch. + if (EnableUnswitchCostMultiplier) { + int CostMultiplier = + calculateUnswitchCostMultiplier(TI, L, LI, UnswitchCandidates); + assert( + (CostMultiplier > 0 && CostMultiplier <= UnswitchThreshold) && + "cost multiplier needs to be in the range of 1..UnswitchThreshold"); + CandidateCost *= CostMultiplier; + LLVM_DEBUG(dbgs() << " Computed cost of " << CandidateCost + << " (multiplier: " << CostMultiplier << ")" + << " for unswitch candidate: " << TI << "\n"); + } else { + LLVM_DEBUG(dbgs() << " Computed cost of " << CandidateCost + << " for unswitch candidate: " << TI << "\n"); + } + if (!BestUnswitchTI || CandidateCost < BestUnswitchCost) { BestUnswitchTI = &TI; BestUnswitchCost = CandidateCost; Index: test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch-nested.ll =================================================================== --- /dev/null +++ test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch-nested.ll @@ -0,0 +1,138 @@ +; +; There should be just a single copy of each loop - and thus 3 volatile store - +; when strictest mutiplier candidates formula (cap == 0) is enforced: + +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=16 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; +; When we relax the candidates cap (cap == 4) we start getting some unswitches, and that leads +; to siblings multiplier kicking in. +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=4 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | \ +; RUN: sort -b | FileCheck %s --check-prefixes=LOOP-CAP4-DIV1 +; +; NB: sort -b is essential here and below, otherwise blanks might lead to different +; order depending on locale. +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=4 -unswitch-siblings-toplevel-div=2 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | \ +; RUN: sort -b | FileCheck %s --check-prefixes=LOOP-CAP4-DIV2 +; +; +; Get +; 2^(num conds) == 2^5 = 32 +; loop nests when cost multiplier is disabled: +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=false \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | \ +; RUN: sort -b | FileCheck %s --check-prefixes=LOOP32 +; +; Single loop nest, not unswitched +; LOOP1: Loop at depth 1 containing: +; LOOP1: Loop at depth 2 containing: +; LOOP1: Loop at depth 3 containing: +; LOOP1-NOT: Loop at depth {{[0-9]+}} containing: +; +; Half unswitched loop nests, with cap4 and div1 it gets less depth1 loops unswitched +; since they have more cost. +; LOOP-CAP4-DIV1-COUNT-6: Loop at depth 1 containing: +; LOOP-CAP4-DIV1-COUNT-19: Loop at depth 2 containing: +; LOOP-CAP4-DIV1-COUNT-29: Loop at depth 3 containing: +; LOOP-CAP4-DIV1-NOT: Loop at depth {{[0-9]+}} containing: +; +; Half unswitched loop nests, with cap4 and div2 it gets more depth1 loops unswitched +; as div2 kicks in. +; LOOP-CAP4-DIV2-COUNT-11: Loop at depth 1 containing: +; LOOP-CAP4-DIV2-COUNT-22: Loop at depth 2 containing: +; LOOP-CAP4-DIV2-COUNT-29: Loop at depth 3 containing: +; LOOP-CAP4-DIV2-NOT: Loop at depth {{[0-9]+}} containing: +; +; 32 loop nests, fully unswitched +; LOOP32-COUNT-32: Loop at depth 1 containing: +; LOOP32-COUNT-32: Loop at depth 2 containing: +; LOOP32-COUNT-32: Loop at depth 3 containing: +; LOOP32-NOT: Loop at depth {{[0-9]+}} containing: + +declare void @bar() + +define void @loop_nested3_conds5(i32* %addr, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5) { +entry: + %addr1 = getelementptr i32, i32* %addr, i64 0 + %addr2 = getelementptr i32, i32* %addr, i64 1 + %addr3 = getelementptr i32, i32* %addr, i64 2 + br label %outer +outer: + %iv1 = phi i32 [0, %entry], [%iv1.next, %outer_latch] + %iv1.next = add i32 %iv1, 1 + ;; skip nontrivial unswitch + call void @bar() + br label %middle +middle: + %iv2 = phi i32 [0, %outer], [%iv2.next, %middle_latch] + %iv2.next = add i32 %iv2, 1 + ;; skip nontrivial unswitch + call void @bar() + br label %loop +loop: + %iv3 = phi i32 [0, %middle], [%iv3.next, %loop_latch] + %iv3.next = add i32 %iv3, 1 + ;; skip nontrivial unswitch + call void @bar() + br i1 %c1, label %loop_next1_left, label %loop_next1_right +loop_next1_left: + br label %loop_next1 +loop_next1_right: + br label %loop_next1 + +loop_next1: + br i1 %c2, label %loop_next2_left, label %loop_next2_right +loop_next2_left: + br label %loop_next2 +loop_next2_right: + br label %loop_next2 + +loop_next2: + br i1 %c3, label %loop_next3_left, label %loop_next3_right +loop_next3_left: + br label %loop_next3 +loop_next3_right: + br label %loop_next3 + +loop_next3: + br i1 %c4, label %loop_next4_left, label %loop_next4_right +loop_next4_left: + br label %loop_next4 +loop_next4_right: + br label %loop_next4 + +loop_next4: + br i1 %c5, label %loop_latch_left, label %loop_latch_right +loop_latch_left: + br label %loop_latch +loop_latch_right: + br label %loop_latch + +loop_latch: + store volatile i32 0, i32* %addr1 + %test_loop = icmp slt i32 %iv3, 50 + br i1 %test_loop, label %loop, label %middle_latch +middle_latch: + store volatile i32 0, i32* %addr2 + %test_middle = icmp slt i32 %iv2, 50 + br i1 %test_middle, label %middle, label %outer_latch +outer_latch: + store volatile i32 0, i32* %addr3 + %test_outer = icmp slt i32 %iv1, 50 + br i1 %test_outer, label %outer, label %exit +exit: + ret void +} Index: test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch-nested2.ll =================================================================== --- /dev/null +++ test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch-nested2.ll @@ -0,0 +1,148 @@ +; +; Here all the branches we unswitch are exiting from the inner loop. +; That means we should not be getting exponential behavior on inner-loop unswitch. +; In fact there should be just a single version of inner-loop, +; with possibly some outer loop copies. +; +; There should be just a single copy of each loop when strictest mutiplier candidates +; formula (cap == 0) is enforced: + +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=16 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; +; When we relax the candidates cap (cap == 2) we start getting some unswitches +; in outer loops, which leads to siblings multiplier kicking in. +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=3 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | \ +; RUN: sort -b | FileCheck %s --check-prefixes=LOOP-CAP3-DIV1 +; +; NB: sort -b is essential here and below, otherwise blanks might lead to different +; order depending on locale. +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=3 -unswitch-siblings-toplevel-div=2 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | \ +; RUN: sort -b | FileCheck %s --check-prefixes=LOOP-CAP3-DIV2 +; +; With disabled cost-multiplier we get maximal possible amount of unswitches. +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=false \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | \ +; RUN: sort -b | FileCheck %s --check-prefixes=LOOP-MAX +; +; Single loop nest, not unswitched +; LOOP1: Loop at depth 1 containing: +; LOOP1-NOT: Loop at depth 1 containing: +; LOOP1: Loop at depth 2 containing: +; LOOP1-NOT: Loop at depth 2 containing: +; LOOP1: Loop at depth 3 containing: +; LOOP1-NOT: Loop at depth 3 containing: +; +; Half unswitched loop nests, with cap4 and div1 it gets less depth1 loops unswitched +; since they have more cost. +; LOOP-CAP3-DIV1-COUNT-4: Loop at depth 1 containing: +; LOOP-CAP3-DIV1-NOT: Loop at depth 1 containing: +; LOOP-CAP3-DIV1-COUNT-1: Loop at depth 2 containing: +; LOOP-CAP3-DIV1-NOT: Loop at depth 2 containing: +; LOOP-CAP3-DIV1-COUNT-1: Loop at depth 3 containing: +; LOOP-CAP3-DIV1-NOT: Loop at depth 3 containing: +; +; Half unswitched loop nests, with cap4 and div2 it gets more depth1 loops unswitched +; as div2 kicks in. +; LOOP-CAP3-DIV2-COUNT-6: Loop at depth 1 containing: +; LOOP-CAP3-DIV2-NOT: Loop at depth 1 containing: +; LOOP-CAP3-DIV2-COUNT-1: Loop at depth 2 containing: +; LOOP-CAP3-DIV2-NOT: Loop at depth 2 containing: +; LOOP-CAP3-DIV2-COUNT-1: Loop at depth 3 containing: +; LOOP-CAP3-DIV2-NOT: Loop at depth 3 containing: +; +; Maximally unswitched (copy of the outer loop per each condition) +; LOOP-MAX-COUNT-6: Loop at depth 1 containing: +; LOOP-MAX-NOT: Loop at depth 1 containing: +; LOOP-MAX-COUNT-1: Loop at depth 2 containing: +; LOOP-MAX-NOT: Loop at depth 2 containing: +; LOOP-MAX-COUNT-1: Loop at depth 3 containing: +; LOOP-MAX-NOT: Loop at depth 3 containing: + +declare void @bar() + +define void @loop_nested3_conds5(i32* %addr, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5) { +entry: + %addr1 = getelementptr i32, i32* %addr, i64 0 + %addr2 = getelementptr i32, i32* %addr, i64 1 + %addr3 = getelementptr i32, i32* %addr, i64 2 + br label %outer +outer: + %iv1 = phi i32 [0, %entry], [%iv1.next, %outer_latch] + %iv1.next = add i32 %iv1, 1 + ;; skip nontrivial unswitch + call void @bar() + br label %middle +middle: + %iv2 = phi i32 [0, %outer], [%iv2.next, %middle_latch] + %iv2.next = add i32 %iv2, 1 + ;; skip nontrivial unswitch + call void @bar() + br label %loop +loop: + %iv3 = phi i32 [0, %middle], [%iv3.next, %loop_latch] + %iv3.next = add i32 %iv3, 1 + ;; skip nontrivial unswitch + call void @bar() + br i1 %c1, label %loop_next1_left, label %outer_latch +loop_next1_left: + br label %loop_next1 +loop_next1_right: + br label %loop_next1 + +loop_next1: + br i1 %c2, label %loop_next2_left, label %outer_latch +loop_next2_left: + br label %loop_next2 +loop_next2_right: + br label %loop_next2 + +loop_next2: + br i1 %c3, label %loop_next3_left, label %outer_latch +loop_next3_left: + br label %loop_next3 +loop_next3_right: + br label %loop_next3 + +loop_next3: + br i1 %c4, label %loop_next4_left, label %outer_latch +loop_next4_left: + br label %loop_next4 +loop_next4_right: + br label %loop_next4 + +loop_next4: + br i1 %c5, label %loop_latch_left, label %outer_latch +loop_latch_left: + br label %loop_latch +loop_latch_right: + br label %loop_latch + +loop_latch: + store volatile i32 0, i32* %addr1 + %test_loop = icmp slt i32 %iv3, 50 + br i1 %test_loop, label %loop, label %middle_latch +middle_latch: + store volatile i32 0, i32* %addr2 + %test_middle = icmp slt i32 %iv2, 50 + br i1 %test_middle, label %middle, label %outer_latch +outer_latch: + store volatile i32 0, i32* %addr3 + %test_outer = icmp slt i32 %iv1, 50 + br i1 %test_outer, label %outer, label %exit +exit: + ret void +} Index: test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch.ll =================================================================== --- /dev/null +++ test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch.ll @@ -0,0 +1,80 @@ +; +; There should be just a single copy of loop - and thus single volatile store - +; when strictest mutiplier candidates formula (cap == 0) is enforced: +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=8 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; With relaxed candidates multiplier (cap == 8) we should allow some unswitches +; to happen until siblings multiplier starts kicking in: +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=8 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP5 +; +; With relaxed candidates multiplier (cap == 8) and with relaxed siblings +; multiplier for top-level loops (toplevel-div == 8) we should get +; 2^(num conds) == 2^5 == 32 +; copies of the loop: +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=8 -unswitch-siblings-toplevel-div=8 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP32 +; +; Similarly get +; 2^(num conds) == 2^5 == 32 +; copies of the loop when cost multiplier is disabled: +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=false \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP32 +; +; +; Single loop, not unswitched +; LOOP1: Loop at depth 1 containing: +; LOOP1-NOT: Loop at depth 1 containing: + +; 5 loops, unswitched 4 times +; LOOP5-COUNT-5: Loop at depth 1 containing: +; LOOP5-NOT: Loop at depth 1 containing: + +; 32 loops, fully unswitched +; LOOP32-COUNT-32: Loop at depth 1 containing: +; LOOP32-NOT: Loop at depth 1 containing: + +define void @loop_simple5(i32* %addr, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5) { +entry: + br label %loop +loop: + %iv = phi i32 [0, %entry], [%iv.next, %loop_latch] + %iv.next = add i32 %iv, 1 + br i1 %c1, label %loop_next1, label %loop_next1_right +loop_next1_right: + br label %loop_next1 +loop_next1: + br i1 %c2, label %loop_next2, label %loop_next2_right +loop_next2_right: + br label %loop_next2 +loop_next2: + br i1 %c3, label %loop_next3, label %loop_next3_right +loop_next3_right: + br label %loop_next3 +loop_next3: + br i1 %c4, label %loop_next4, label %loop_next4_right +loop_next4_right: + br label %loop_next4 +loop_next4: + br i1 %c5, label %loop_latch, label %loop_latch_right +loop_latch_right: + br label %loop_latch +loop_latch: + store volatile i32 0, i32* %addr + %test_loop = icmp slt i32 %iv, 50 + br i1 %test_loop, label %loop, label %exit +exit: + ret void +} Index: test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch2.ll =================================================================== --- /dev/null +++ test/Transforms/SimpleLoopUnswitch/exponential-nontrivial-unswitch2.ll @@ -0,0 +1,56 @@ +; +; Here all the branches are exiting ones. Checking that we dont have +; exponential behavior with any kind of controlling heuristics here. +; +; There we should have just a single loop. +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=0 -unswitch-siblings-toplevel-div=8 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=8 -unswitch-siblings-toplevel-div=1 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=true \ +; RUN: -unswitch-candidates-bottom-cap=8 -unswitch-siblings-toplevel-div=8 \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; RUN: opt < %s -enable-nontrivial-unswitch -enable-unswitch-cost-multiplier=false \ +; RUN: -passes='loop(unswitch),print' -disable-output 2>&1 | FileCheck %s --check-prefixes=LOOP1 +; +; +; Single loop, not unswitched +; LOOP1: Loop at depth 1 containing: +; LOOP1-NOT: Loop at depth 1 containing: + +declare void @bar() + +define void @loop_simple5(i32* %addr, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5) { +entry: + br label %loop +loop: + %iv = phi i32 [0, %entry], [%iv.next, %loop_latch] + %iv.next = add i32 %iv, 1 + ;; disabling trivial unswitch + call void @bar() + br i1 %c1, label %loop_next1, label %exit +loop_next1: + br i1 %c2, label %loop_next2, label %exit +loop_next2: + br i1 %c3, label %loop_next3, label %exit +loop_next3: + br i1 %c4, label %loop_next4, label %exit +loop_next4: + br i1 %c5, label %loop_latch, label %exit +loop_latch: + store volatile i32 0, i32* %addr + %test_loop = icmp slt i32 %iv, 50 + br i1 %test_loop, label %loop, label %exit +exit: + ret void +}