Index: include/llvm/Analysis/ScalarEvolution.h =================================================================== --- include/llvm/Analysis/ScalarEvolution.h +++ include/llvm/Analysis/ScalarEvolution.h @@ -978,6 +978,20 @@ /// Test whether the condition described by Pred, LHS, and RHS is true /// whenever the condition described by Pred, FoundLHS, and FoundRHS is + /// true. Here LHS is an operation that includes FoundLHS as one of its + /// arguments. + bool isImpliedViaOperations(ICmpInst::Predicate Pred, + const SCEV *LHS, const SCEV *RHS, + const SCEV *FoundLHS, const SCEV *FoundRHS, + unsigned Depth = 0); + + /// Test whether the condition described by Pred, LHS, and RHS is true. + /// Use only simple non-recursive types of checks, such as range analysis etc. + bool isKnownViaSimpleReasoning(ICmpInst::Predicate Pred, + const SCEV *LHS, const SCEV *RHS); + + /// Test whether the condition described by Pred, LHS, and RHS is true + /// whenever the condition described by Pred, FoundLHS, and FoundRHS is /// true. bool isImpliedCondOperandsHelper(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS, const SCEV *FoundLHS, @@ -1123,6 +1137,9 @@ /// return true. For pointer types, this is the pointer-sized integer type. Type *getEffectiveSCEVType(Type *Ty) const; + // Returns a wider type among {Ty1, Ty2}. + Type *getWiderType(Type *Ty1, Type *Ty2) const; + /// Return true if the SCEV is a scAddRecExpr or it contains /// scAddRecExpr. The result will be cached in HasRecMap. /// Index: lib/Analysis/ScalarEvolution.cpp =================================================================== --- lib/Analysis/ScalarEvolution.cpp +++ lib/Analysis/ScalarEvolution.cpp @@ -137,6 +137,11 @@ cl::desc("Maximum depth of recursive SCEV complexity comparisons"), cl::init(32)); +static cl::opt MaxSCEVOperationsImplicationDepth( + "scalar-evolution-max-scev-operations-implication-depth", cl::Hidden, + cl::desc("Maximum depth of recursive SCEV operations implication analysis"), + cl::init(4)); + static cl::opt MaxValueCompareDepth( "scalar-evolution-max-value-compare-depth", cl::Hidden, cl::desc("Maximum depth of recursive value complexity comparisons"), @@ -3418,6 +3423,10 @@ return getDataLayout().getIntPtrType(Ty); } +Type *ScalarEvolution::getWiderType(Type *T1, Type *T2) const { + return getTypeSizeInBits(T1) >= getTypeSizeInBits(T2) ? T1 : T2; +} + const SCEV *ScalarEvolution::getCouldNotCompute() { return CouldNotCompute.get(); } @@ -8533,19 +8542,137 @@ llvm_unreachable("covered switch fell through?!"); } +bool ScalarEvolution::isImpliedViaOperations(ICmpInst::Predicate Pred, + const SCEV *LHS, const SCEV *RHS, + const SCEV *FoundLHS, + const SCEV *FoundRHS, + unsigned Depth) { + // We want to avoid hurting the compile time with analysis of too big trees. + if (Depth > MaxSCEVOperationsImplicationDepth) + return false; + // We only want to work with ICMP_SGT comparison so far. + // TODO: Extend to ICMP_UGT? + if (Pred == ICmpInst::ICMP_SLT) { + Pred = ICmpInst::ICMP_SGT; + std::swap(LHS, RHS); + std::swap(FoundLHS, FoundRHS); + } + if (Pred != ICmpInst::ICMP_SGT) + return false; + + auto GetOpFromSExt = [&](const SCEV *S) { + if (auto *Ext = dyn_cast(S)) + return Ext->getOperand(); + return S; + }; + + // Acquire values from extensions. + auto *OrigFoundLHS = FoundLHS; + LHS = GetOpFromSExt(LHS); + FoundLHS = GetOpFromSExt(FoundLHS); + + // Is a predicate can be proved trivially or using the found context. + auto IsProvedViaContext = [&](ICmpInst::Predicate Pred, + const SCEV *S1, const SCEV *S2) { + return isKnownViaSimpleReasoning(Pred, S1, S2) || + isImpliedViaOperations(Pred, S1, S2, OrigFoundLHS, FoundRHS, + Depth + 1); + }; + + if (auto *LHSAddExpr = dyn_cast(LHS)) { + // Should not overflow. + if (!LHSAddExpr->hasNoSignedWrap()) + return false; + auto *LL = LHSAddExpr->getOperand(0); + auto *LR = LHSAddExpr->getOperand(1); + + // Checks that S1 >= 0 && S2 > RHS, trivially or using the found context. + auto IsSumGreaterThanRHS = [&](const SCEV *S1, const SCEV *S2) { + return IsProvedViaContext(ICmpInst::ICMP_SGT, S2, RHS) && + IsProvedViaContext(Pred, S1, getZero(RHS->getType())); + }; + // Try to prove the following rule: + // (LHS = LL + LR) && (LL >= 0) && (LR > RHS) => (LHS > RHS). + // (LHS = LL + LR) && (LR >= 0) && (LL > RHS) => (LHS > RHS). + if (IsSumGreaterThanRHS(LL, LR) || IsSumGreaterThanRHS(LR, LL)) + return true; + } else if (auto *LHSUnknownExpr = dyn_cast(LHS)) { + Value *LL, *LR; + // FIXME: Once we have SDiv implemented, we can get rid of this matching. + using namespace llvm::PatternMatch; + if (match(LHSUnknownExpr->getValue(), m_SDiv(m_Value(LL), m_Value(LR)))) { + // Rules for division. + // We are going to perform some comparisons with Denominator and its + // derivative expressions. In general case, creating a SCEV for it may + // lead to a complex analysis of the entire graph, and in particular it + // can request trip count recalculation for the same loop. This would + // cache as SCEVCouldNotCompute to avoid the infinite recursion. This is a + // sad thing. To avoid this, we only want to create SCEVs that are + // constants in this section. So we bail if Denominator is not a constant. + if (!isa(LR)) + return false; + + auto *Denominator = cast(getSCEV(LR)); + + // We want to make sure that LHS = FoundLHS / Denominator. If it is so, + // then a SCEV for the numerator already exists and matches with FoundLHS. + auto *Numerator = getExistingSCEV(LL); + + // Make sure that it exists and has the same type. + if (!Numerator || Numerator->getType() != FoundLHS->getType()) + return false; + + // Make sure that the numerator matches with FoundLHs and the denominator + // is positive. + if (!HasSameValue(Numerator, FoundLHS) || !isKnownPositive(Denominator)) + return false; + + // Given that: + // FoundLHS > FoundRHS, LHS = FoundLHS / Denominator, Denominator > 0. + auto *Ty2 = getWiderType(Denominator->getType(), FoundRHS->getType()); + auto *DenominatorExt = getNoopOrSignExtend(Denominator, Ty2); + auto *FoundRHSExt = getNoopOrSignExtend(FoundRHS, Ty2); + + // Try to prove the following rule: + // (Denominator - 1 <= FoundRHS) && (RHS <= 0) => (LHS > RHS). + // For example, given that FoundLHS > 2. It means that FoundLHS is at + // least 3. If we divide it by Denominator <= 3, we will have at least 1. + auto *DenomMinusOne = getMinusSCEV(DenominatorExt, getOne(Ty2)); + if (isKnownNonPositive(RHS) && + IsProvedViaContext(ICmpInst::ICMP_SLE, DenomMinusOne, FoundRHSExt)) + return true; + + // Try to prove the following rule: + // (-Denominator <= FoundRHS) && (RHS < 0) => (LHS > RHS). + // For example, given that FoundLHS > -3. Then FoundLHS is at least -2. + // If we divide it by Denominator >= 3, then: + // 1. If FoundLHS is negative, then the result is 0. + // 2. If FoundLHS is non-negative, then the result is non-negative. + // Anyways, the result is non-negative. + auto *NegDenominator = getNegativeSCEV(DenominatorExt); + if (isKnownNegative(RHS) && + IsProvedViaContext(ICmpInst::ICMP_SLE, NegDenominator, FoundRHSExt)) + return true; + } + } + + return false; +} + +bool +ScalarEvolution::isKnownViaSimpleReasoning(ICmpInst::Predicate Pred, + const SCEV *LHS, const SCEV *RHS) { + return isKnownPredicateViaConstantRanges(Pred, LHS, RHS) || + IsKnownPredicateViaMinOrMax(*this, Pred, LHS, RHS) || + IsKnownPredicateViaAddRecStart(*this, Pred, LHS, RHS) || + isKnownPredicateViaNoOverflow(Pred, LHS, RHS); +} + bool ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS, const SCEV *FoundLHS, const SCEV *FoundRHS) { - auto IsKnownPredicateFull = - [this](ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) { - return isKnownPredicateViaConstantRanges(Pred, LHS, RHS) || - IsKnownPredicateViaMinOrMax(*this, Pred, LHS, RHS) || - IsKnownPredicateViaAddRecStart(*this, Pred, LHS, RHS) || - isKnownPredicateViaNoOverflow(Pred, LHS, RHS); - }; - switch (Pred) { default: llvm_unreachable("Unexpected ICmpInst::Predicate value!"); case ICmpInst::ICMP_EQ: @@ -8555,30 +8682,34 @@ break; case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_SLE: - if (IsKnownPredicateFull(ICmpInst::ICMP_SLE, LHS, FoundLHS) && - IsKnownPredicateFull(ICmpInst::ICMP_SGE, RHS, FoundRHS)) + if (isKnownViaSimpleReasoning(ICmpInst::ICMP_SLE, LHS, FoundLHS) && + isKnownViaSimpleReasoning(ICmpInst::ICMP_SGE, RHS, FoundRHS)) return true; break; case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_SGE: - if (IsKnownPredicateFull(ICmpInst::ICMP_SGE, LHS, FoundLHS) && - IsKnownPredicateFull(ICmpInst::ICMP_SLE, RHS, FoundRHS)) + if (isKnownViaSimpleReasoning(ICmpInst::ICMP_SGE, LHS, FoundLHS) && + isKnownViaSimpleReasoning(ICmpInst::ICMP_SLE, RHS, FoundRHS)) return true; break; case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE: - if (IsKnownPredicateFull(ICmpInst::ICMP_ULE, LHS, FoundLHS) && - IsKnownPredicateFull(ICmpInst::ICMP_UGE, RHS, FoundRHS)) + if (isKnownViaSimpleReasoning(ICmpInst::ICMP_ULE, LHS, FoundLHS) && + isKnownViaSimpleReasoning(ICmpInst::ICMP_UGE, RHS, FoundRHS)) return true; break; case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_UGE: - if (IsKnownPredicateFull(ICmpInst::ICMP_UGE, LHS, FoundLHS) && - IsKnownPredicateFull(ICmpInst::ICMP_ULE, RHS, FoundRHS)) + if (isKnownViaSimpleReasoning(ICmpInst::ICMP_UGE, LHS, FoundLHS) && + isKnownViaSimpleReasoning(ICmpInst::ICMP_ULE, RHS, FoundRHS)) return true; break; } + // Maybe it can be proved via operations? + if (isImpliedViaOperations(Pred, LHS, RHS, FoundLHS, FoundRHS)) + return true; + return false; } Index: test/Analysis/ScalarEvolution/scev-division.ll =================================================================== --- /dev/null +++ test/Analysis/ScalarEvolution/scev-division.ll @@ -0,0 +1,334 @@ +; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s + +declare void @llvm.experimental.guard(i1, ...) + +define void @test01(i32 %a, i32 %n) nounwind { +; Prove that (n > 1) ===> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @test01 +; CHECK: Loop %header: backedge-taken count is (-1 + %n.div.2) +entry: + %cmp1 = icmp sgt i32 %n, 1 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sgt i32 %n.div.2, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test01neg(i32 %a, i32 %n) nounwind { +; Prove that (n > 0) =\=> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @test01neg +; CHECK: Loop %header: backedge-taken count is (-1 + (1 smax %n.div.2)) +entry: + %cmp1 = icmp sgt i32 %n, 0 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sgt i32 %n.div.2, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test02(i32 %a, i32 %n) nounwind { +; Prove that (n >= 2) ===> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @test02 +; CHECK: Loop %header: backedge-taken count is (-1 + %n.div.2) +entry: + %cmp1 = icmp sge i32 %n, 2 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sgt i32 %n.div.2, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test02neg(i32 %a, i32 %n) nounwind { +; Prove that (n >= 1) =\=> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @test02neg +; CHECK: Loop %header: backedge-taken count is (-1 + (1 smax %n.div.2)) +entry: + %cmp1 = icmp sge i32 %n, 1 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sgt i32 %n.div.2, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test03(i32 %a, i32 %n) nounwind { +; Prove that (n > -2) ===> (n / 2 >= 0). +; TODO: We should be able to prove that (n > -2) ===> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @test03 +; CHECK: Loop %header: backedge-taken count is (1 + %n.div.2) +entry: + %cmp1 = icmp sgt i32 %n, -2 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sge i32 %n.div.2, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test03neg(i32 %a, i32 %n) nounwind { +; Prove that (n > -3) =\=> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @test03neg +; CHECK: Loop %header: backedge-taken count is (0 smax (1 + %n.div.2)) +entry: + %cmp1 = icmp sgt i32 %n, -3 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sge i32 %n.div.2, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test04(i32 %a, i32 %n) nounwind { +; Prove that (n >= -1) ===> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @test04 +; CHECK: Loop %header: backedge-taken count is (1 + %n.div.2) +entry: + %cmp1 = icmp sge i32 %n, -1 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sge i32 %n.div.2, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @test04neg(i32 %a, i32 %n) nounwind { +; Prove that (n >= -2) =\=> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @test04neg +; CHECK: Loop %header: backedge-taken count is (0 smax (1 + %n.div.2)) +entry: + %cmp1 = icmp sge i32 %n, -2 + %n.div.2 = sdiv i32 %n, 2 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i32 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i32 %indvar, 1 + %exitcond = icmp sge i32 %n.div.2, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext01(i32 %a, i32 %n) nounwind { +; Prove that (n > 1) ===> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @testext01 +; CHECK: Loop %header: backedge-taken count is (-1 + (sext i32 %n.div.2 to i64)) +entry: + %cmp1 = icmp sgt i32 %n, 1 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sgt i64 %n.div.2.ext, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext01neg(i32 %a, i32 %n) nounwind { +; Prove that (n > 0) =\=> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @testext01neg +; CHECK: Loop %header: backedge-taken count is (-1 + (1 smax (sext i32 %n.div.2 to i64))) +entry: + %cmp1 = icmp sgt i32 %n, 0 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sgt i64 %n.div.2.ext, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext02(i32 %a, i32 %n) nounwind { +; Prove that (n >= 2) ===> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @testext02 +; CHECK: Loop %header: backedge-taken count is (-1 + (sext i32 %n.div.2 to i64)) +entry: + %cmp1 = icmp sge i32 %n, 2 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sgt i64 %n.div.2.ext, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext02neg(i32 %a, i32 %n) nounwind { +; Prove that (n >= 1) =\=> (n / 2 > 0). +; CHECK: Determining loop execution counts for: @testext02neg +; CHECK: Loop %header: backedge-taken count is (-1 + (1 smax (sext i32 %n.div.2 to i64))) +entry: + %cmp1 = icmp sge i32 %n, 1 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sgt i64 %n.div.2.ext, %indvar.next + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext03(i32 %a, i32 %n) nounwind { +; Prove that (n > -2) ===> (n / 2 >= 0). +; TODO: We should be able to prove that (n > -2) ===> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @testext03 +; CHECK: Loop %header: backedge-taken count is (1 + (sext i32 %n.div.2 to i64)) +entry: + %cmp1 = icmp sgt i32 %n, -2 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sge i64 %n.div.2.ext, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext03neg(i32 %a, i32 %n) nounwind { +; Prove that (n > -3) =\=> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @testext03neg +; CHECK: Loop %header: backedge-taken count is (0 smax (1 + (sext i32 %n.div.2 to i64))) +entry: + %cmp1 = icmp sgt i32 %n, -3 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sge i64 %n.div.2.ext, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext04(i32 %a, i32 %n) nounwind { +; Prove that (n >= -1) ===> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @testext04 +; CHECK: Loop %header: backedge-taken count is (1 + (sext i32 %n.div.2 to i64)) +entry: + %cmp1 = icmp sge i32 %n, -1 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sge i64 %n.div.2.ext, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} + +define void @testext04neg(i32 %a, i32 %n) nounwind { +; Prove that (n >= -2) =\=> (n / 2 >= 0). +; CHECK: Determining loop execution counts for: @testext04neg +; CHECK: Loop %header: backedge-taken count is (0 smax (1 + (sext i32 %n.div.2 to i64))) +entry: + %cmp1 = icmp sge i32 %n, -2 + %n.div.2 = sdiv i32 %n, 2 + %n.div.2.ext = sext i32 %n.div.2 to i64 + call void(i1, ...) @llvm.experimental.guard(i1 %cmp1) [ "deopt"() ] + br label %header + +header: + %indvar = phi i64 [ %indvar.next, %header ], [ 0, %entry ] + %indvar.next = add i64 %indvar, 1 + %exitcond = icmp sge i64 %n.div.2.ext, %indvar + br i1 %exitcond, label %header, label %exit + +exit: + ret void +} +