[Attributor] Call site specific AAValueSimplification and AAIsDead.

[kuter]

Summary

This patch makes it possible to do call site specific deductions
for AAValueSimplification and AAIsDead.

[kuter]

Manually requesting review, since the Phabricator wasn't able to built this. From what I can see it was missing the parent revision with the last build.
Pre-merge checks should be ok now.

[jdoerfert]

Can you, maybe as a separate patch, run the update script with the call site deduction enabled *before* this patch and *after* to get the difference on all tests we have?

llvm/lib/Transforms/IPO/Attributor.cpp

532

is this supposed to be static? Please put it with the other "helpers" and add documentation.

llvm/test/Transforms/Attributor/cb_liveness.ll

185

Why are there no check lines for TUNIT w/o ENABLED, and CGSCC w/ ENABLED?

[kuter]

In D84722#2181037, @jdoerfert wrote:

Can you, maybe as a separate patch, run the update script with the call site deduction enabled *before* this patch and *after* to get the difference on all tests we have?

I made D84751.

[kuter]

llvm/test/Transforms/Attributor/cb_liveness.ll

185

Interesting. Will look into it.

[kuter]

• Rebase
• Split the test file into two.
• Remove the unneeded utility function.

[kuter]

Remove the TUNIT__ENABLED blocks that I accidentally left in the test files.
ENABLED suffixes are no longer needed since the test file is in two parts now.

[kuter]

ping

[jdoerfert]

LG, thanks

llvm/lib/Transforms/IPO/Attributor.cpp

case IRP_CALL_SITE_ARGUMENT: {
     Use *U = getAsUsePtr();
     assert(U && "Expected use for a 'call site argument' position!");
     assert(isa<CallBase>(U->getUser()) &&
            "Expected call base user for a 'call site argument' position!");
     assert(cast<CallBase>(U->getUser())->isArgOperand(U) &&
            "Expected call base argument operand for a 'call site argument' "
            "position");
     assert(cast<CallBase>(U->getUser())->getArgOperandNo(U) ==
                unsigned(getArgNo()) &&
            "Argument number mismatch!");
     assert(U->get() == &getAssociatedValue() && "Associated value mismatch!");
     return;
   }
   }
 #endif
 }
 
 Optional<Constant *>
 Attributor::getAssumedConstant(const Value &V, const AbstractAttribute &AA,
                                bool &UsedAssumedInformation) {
   const auto &ValueSimplifyAA = getAAFor<AAValueSimplify>(
-      AA, IRPosition::value(V), /* TrackDependence */ false);
+      AA, IRPosition::value(V, AA.getCallBaseContext()),
+      /* TrackDependence */ false);
   Optional<Value *> SimplifiedV =
       ValueSimplifyAA.getAssumedSimplifiedValue(*this);
   bool IsKnown = ValueSimplifyAA.isKnown();
   UsedAssumedInformation |= !IsKnown;
   if (!SimplifiedV.hasValue()) {
     recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL);
     return llvm::None;
   }
Attributor::getAssumedConstant(const Value &V, const AbstractAttribute &AA,
   if (CI)
     recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL);
   return CI;
 }
 
 Attributor::~Attributor() {
   // The abstract attributes are allocated via the BumpPtrAllocator Allocator,
   // thus we cannot delete them. We can, and want to, destruct them though.
   for (AbstractAttribute *AA : AllAbstractAttributes)
     AA->~AbstractAttribute();
 }
 
 bool Attributor::isAssumedDead(const AbstractAttribute &AA,
                                const AAIsDead *FnLivenessAA,
                                bool CheckBBLivenessOnly, DepClassTy DepClass) {
   const IRPosition &IRP = AA.getIRPosition();
   if (!Functions.count(IRP.getAnchorScope()))
     return false;
   return isAssumedDead(IRP, &AA, FnLivenessAA, CheckBBLivenessOnly, DepClass);
 }
 
+const IRPosition::CallBaseContext *getCBContext(const AbstractAttribute *AA) {
+  if (!AA)
+    return nullptr;
+  return AA->getCallBaseContext();
+}
+
 bool Attributor::isAssumedDead(const Use &U,
                                const AbstractAttribute *QueryingAA,
                                const AAIsDead *FnLivenessAA,
                                bool CheckBBLivenessOnly, DepClassTy DepClass) {
   Instruction *UserI = dyn_cast<Instruction>(U.getUser());
   if (!UserI)
     return isAssumedDead(IRPosition::value(*U.get()), QueryingAA, FnLivenessAA,
                          CheckBBLivenessOnly, DepClass);
return isAssumedDead(IRPosition::value(*UserI), QueryingAA, FnLivenessAA,
                        CheckBBLivenessOnly, DepClass);
 }
 
 bool Attributor::isAssumedDead(const Instruction &I,
                                const AbstractAttribute *QueryingAA,
                                const AAIsDead *FnLivenessAA,
                                bool CheckBBLivenessOnly, DepClassTy DepClass) {
   if (!FnLivenessAA)
-    FnLivenessAA = lookupAAFor<AAIsDead>(IRPosition::function(*I.getFunction()),
-                                         QueryingAA,
-                                         /* TrackDependence */ false);
+    FnLivenessAA = lookupAAFor<AAIsDead>(
+        IRPosition::function(*I.getFunction(), getCBContext(QueryingAA)),
 
   // If we have a context instruction and a liveness AA we use it.
   if (FnLivenessAA &&
       FnLivenessAA->getIRPosition().getAnchorScope() == I.getFunction() &&
       FnLivenessAA->isAssumedDead(&I)) {
     if (QueryingAA)
       recordDependence(*FnLivenessAA, *QueryingAA, DepClass);
     return true;
   }
 
   if (CheckBBLivenessOnly)
     return false;
 
-  const AAIsDead &IsDeadAA = getOrCreateAAFor<AAIsDead>(
-      IRPosition::value(I), QueryingAA, /* TrackDependence */ false);
+  const AAIsDead &IsDeadAA =
+      getOrCreateAAFor<AAIsDead>(IRPosition::value(I, getCBContext(QueryingAA)),
+                                 QueryingAA, /* TrackDependence */ false);
   // Don't check liveness for AAIsDead.
   if (QueryingAA == &IsDeadAA)
     return false;
 
   if (IsDeadAA.isAssumedDead()) {
     if (QueryingAA)
       recordDependence(IsDeadAA, *QueryingAA, DepClass);
     return true;
bool Attributor::checkForAllReturnedValuesAndReturnInsts(
   const IRPosition &IRP = QueryingAA.getIRPosition();
   // Since we need to provide return instructions we have to have an exact
   // definition.
   const Function *AssociatedFunction = IRP.getAssociatedFunction();
   if (!AssociatedFunction)
     return false;
 
   // If this is a call site query we use the call site specific return values
   // and liveness information.
   // TODO: use the function scope once we have call site AAReturnedValues.
   const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
   const auto &AARetVal = getAAFor<AAReturnedValues>(QueryingAA, QueryIRP);
   if (!AARetVal.getState().isValidState())
     return false;
 
   return AARetVal.checkForAllReturnedValuesAndReturnInsts(Pred);
 }
 
 bool Attributor::checkForAllReturnedValues(
     function_ref<bool(Value &)> Pred, const AbstractAttribute &QueryingAA) {
 
   const IRPosition &IRP = QueryingAA.getIRPosition();
   const Function *AssociatedFunction = IRP.getAssociatedFunction();
   if (!AssociatedFunction)
     return false;
 
   // TODO: use the function scope once we have call site AAReturnedValues.
-  const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
+  const IRPosition &QueryIRP = IRPosition::function(
+      *AssociatedFunction, QueryingAA.getCallBaseContext());
   const auto &AARetVal = getAAFor<AAReturnedValues>(QueryingAA, QueryIRP);
   if (!AARetVal.getState().isValidState())
     return false;
 
   return AARetVal.checkForAllReturnedValuesAndReturnInsts(
       [&](Value &RV, const SmallSetVector<ReturnInst *, 4> &) {
         return Pred(RV);
       });

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

static bool genericValueTraversal(
     function_ref<bool(Value &, const Instruction *, StateTy &, bool)>
         VisitValueCB,
     const Instruction *CtxI, bool UseValueSimplify = true, int MaxValues = 16,
     function_ref<Value *(Value *)> StripCB = nullptr) {
 
   const AAIsDead *LivenessAA = nullptr;
   if (IRP.getAnchorScope())
     LivenessAA = &A.getAAFor<AAIsDead>(
-        QueryingAA, IRPosition::function(*IRP.getAnchorScope()),
+        QueryingAA,
+        IRPosition::function(*IRP.getAnchorScope(), IRP.getCallBaseContext()),
         /* TrackDependence */ false);
   bool AnyDead = false;
 
   using Item = std::pair<Value *, const Instruction *>;
   SmallSet<Item, 16> Visited;
   SmallVector<Item, 16> Worklist;
   Worklist.push_back({&IRP.getAssociatedValue(), CtxI});
 
if (!A.checkForAllReturnedValues(Pred, *this))
     UniqueRV = nullptr;
 
   return UniqueRV;
 }
 
 bool AAReturnedValuesImpl::checkForAllReturnedValuesAndReturnInsts(
     function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
     const {
   if (!isValidState())
     return false;
 
   // Check all returned values but ignore call sites as long as we have not
   // encountered an overdefined one during an update.
   for (auto &It : ReturnedValues) {
     Value *RV = It.first;
 
     CallBase *CB = dyn_cast<CallBase>(RV);
LLVM_DEBUG({
                << " => " << RVS.RetInsts.size() << "\n";
     });
     return true;
   };
 
   // Helper method to invoke the generic value traversal.
   auto VisitReturnedValue = [&](Value &RV, RVState &RVS,
                                 const Instruction *CtxI) {
-    IRPosition RetValPos = IRPosition::value(RV);
+    IRPosition RetValPos = IRPosition::value(RV, getCallBaseContext());
     return genericValueTraversal<AAReturnedValues, RVState>(
         A, RetValPos, *this, RVS, VisitValueCB, CtxI,
         /* UseValueSimplify */ false);
   };
 
   // Callback for all "return intructions" live in the associated function.
   auto CheckReturnInst = [this, &VisitReturnedValue, &Changed](Instruction &I) {
     ReturnInst &Ret = cast<ReturnInst>(I);
struct AANoCaptureReturned final : AANoCaptureImpl {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     llvm_unreachable("NoCapture is not applicable to function returns!");
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {}
 };
 
 /// NoCapture attribute deduction for a call site return value.
 struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
   AANoCaptureCallSiteReturned(const IRPosition &IRP, Attributor &A)
       : AANoCaptureImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
struct AAValueSimplifyImpl : AAValueSimplify {
   /// \param QueryingValue Value trying to unify with SimplifiedValue
   /// \param AccumulatedSimplifiedValue Current simplification result.
   static bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
                              Value &QueryingValue,
                              Optional<Value *> &AccumulatedSimplifiedValue) {
     // FIXME: Add a typecast support.
 
     auto &ValueSimplifyAA = A.getAAFor<AAValueSimplify>(
-        QueryingAA, IRPosition::value(QueryingValue));
+        QueryingAA,
+        IRPosition::value(QueryingValue, QueryingAA.getCallBaseContext()));
 
     Optional<Value *> QueryingValueSimplified =
         ValueSimplifyAA.getAssumedSimplifiedValue(A);
 
     if (!QueryingValueSimplified.hasValue())
       return true;
 
     if (!QueryingValueSimplified.getValue())
static bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
     AccumulatedSimplifiedValue = QueryingValueSimplified;
     return true;
   }
 
   bool askSimplifiedValueForAAValueConstantRange(Attributor &A) {
     if (!getAssociatedValue().getType()->isIntegerTy())
       return false;
 
+    // This will also pass the call base context.
     const auto &ValueConstantRangeAA =
         A.getAAFor<AAValueConstantRange>(*this, getIRPosition());
 
     Optional<ConstantInt *> COpt =
         ValueConstantRangeAA.getAssumedConstantInt(A);
     if (COpt.hasValue()) {
       if (auto *C = COpt.getValue())
         SimplifiedAssociatedValue = C;
struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
 
   void initialize(Attributor &A) override {
     AAValueSimplifyImpl::initialize(A);
     if (!getAnchorScope() || getAnchorScope()->isDeclaration())
       indicatePessimisticFixpoint();
     if (hasAttr({Attribute::InAlloca, Attribute::Preallocated,
                  Attribute::StructRet, Attribute::Nest},
                 /* IgnoreSubsumingPositions */ true))
       indicatePessimisticFixpoint();
 
     // FIXME: This is a hack to prevent us from propagating function poiner in
     // the new pass manager CGSCC pass as it creates call edges the
     // CallGraphUpdater cannot handle yet.
     Value &V = getAssociatedValue();
     if (V.getType()->isPointerTy() &&
         V.getType()->getPointerElementType()->isFunctionTy() &&
         !A.isModulePass())
       indicatePessimisticFixpoint();
auto PredForCallSite = [&](AbstractCallSite ACS) {
       Value &ArgOp = ACSArgPos.getAssociatedValue();
       if (ACS.isCallbackCall())
         if (auto *C = dyn_cast<Constant>(&ArgOp))
           if (C->isThreadDependent())
             return false;
       return checkAndUpdate(A, *this, ArgOp, SimplifiedAssociatedValue);
     };
 
+    // Generate a answer specific to a call site context.
+    bool Success;
     bool AllCallSitesKnown;
-    if (!A.checkForAllCallSites(PredForCallSite, *this, true,
-                                AllCallSitesKnown))
+    if (hasCallBaseContext()) {
+      AbstractCallSite ACS(&getCallBaseContext()->getCalledOperandUse());
+      Success = PredForCallSite(ACS);
+    } else {
+      Success = A.checkForAllCallSites(PredForCallSite, *this, true,
+                                       AllCallSitesKnown);
+    }
+
+    if (!Success)
       if (!askSimplifiedValueForAAValueConstantRange(A))
         return indicatePessimisticFixpoint();
 
     // If a candicate was found in this update, return CHANGED.
     return HasValueBefore == SimplifiedAssociatedValue.hasValue()
                ? ChangeStatus::UNCHANGED
                : ChangeStatus ::CHANGED;
   }
ChangeStatus manifest(Attributor &A) override {
     auto *C = SimplifiedAssociatedValue.hasValue()
                   ? dyn_cast<Constant>(SimplifiedAssociatedValue.getValue())
                   : UndefValue::get(V.getType());
     if (C) {
       auto PredForReturned =
           [&](Value &V, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
             // We can replace the AssociatedValue with the constant.
             if (&V == C || V.getType() != C->getType() || isa<UndefValue>(V))
               return true;
 
             for (ReturnInst *RI : RetInsts) {
               if (RI->getFunction() != getAnchorScope())
                 continue;
               auto *RC = C;
               if (RC->getType() != RI->getReturnValue()->getType())
                 RC = ConstantExpr::getBitCast(RC,
                                               RI->getReturnValue()->getType());
struct AAValueSimplifyFloating : AAValueSimplifyImpl {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     bool HasValueBefore = SimplifiedAssociatedValue.hasValue();
 
     auto VisitValueCB = [&](Value &V, const Instruction *CtxI, bool &,
                             bool Stripped) -> bool {
-      auto &AA = A.getAAFor<AAValueSimplify>(*this, IRPosition::value(V));
+      auto &AA = A.getAAFor<AAValueSimplify>(
+          *this, IRPosition::value(V, getCallBaseContext()));
       if (!Stripped && this == &AA) {
         // TODO: Look the instruction and check recursively.
 
         LLVM_DEBUG(dbgs() << "[ValueSimplify] Can't be stripped more : " << V
                           << "\n");
         return false;
       }
       return checkAndUpdate(A, *this, V, SimplifiedAssociatedValue);
struct AAValueConstantRangeFloating : AAValueConstantRangeImpl {
   }
 
   bool
   calculateCmpInst(Attributor &A, CmpInst *CmpI, IntegerRangeState &T,
                    const Instruction *CtxI,
                    SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
     Value *LHS = CmpI->getOperand(0);
     Value *RHS = CmpI->getOperand(1);
     // TODO: Allow non integers as well.
     if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
       return false;
 
     auto &LHSAA = A.getAAFor<AAValueConstantRange>(
         *this, IRPosition::value(*LHS, getCallBaseContext()));
     QuerriedAAs.push_back(&LHSAA);
     auto &RHSAA = A.getAAFor<AAValueConstantRange>(
         *this, IRPosition::value(*RHS, getCallBaseContext()));
struct AAValueConstantRangeFloating : AAValueConstantRangeImpl {
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     auto VisitValueCB = [&](Value &V, const Instruction *CtxI,
                             IntegerRangeState &T, bool Stripped) -> bool {
       Instruction *I = dyn_cast<Instruction>(&V);
       if (!I || isa<CallBase>(I)) {
 
         // If the value is not instruction, we query AA to Attributor.
-        const auto &AA =
-            A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(V));
+        const auto &AA = A.getAAFor<AAValueConstantRange>(
+            *this, IRPosition::value(V, getCallBaseContext()));
 
         // Clamp operator is not used to utilize a program point CtxI.
         T.unionAssumed(AA.getAssumedConstantRange(A, CtxI));
 
         return T.isValidState();
       }
 
       SmallVector<const AAValueConstantRange *, 4> QuerriedAAs;

llvm/test/Transforms/Attributor/cb_liveness.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
+
+; call site specific analysis is disabled
+
+; RUN: opt -attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -attributor-enable-call-site-specific-deduction=false -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -attributor-enable-call-site-specific-deduction=false  -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
+; RUN: opt -attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -attributor-enable-call-site-specific-deduction=false -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -attributor-enable-call-site-specific-deduction=false  -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
+
+; call site specific-deduction analysis is enabled
+
+; RUN: opt -attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -attributor-enable-call-site-specific-deduction=true -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM,CHECK_ENABLED,NOT_CGSCC_NPM_ENABLED,NOT_CGSCC_OPM_ENABLED,NOT_TUNIT_NPM_ENABLED,IS__TUNIT_____ENABLED,IS________OPM_ENABLED,IS__TUNIT_OPM_ENABLED
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -attributor-enable-call-site-specific-deduction=true -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM,CHECK_ENABLED,NOT_CGSCC_OPM_ENABLED,NOT_CGSCC_NPM_ENABLED,NOT_TUNIT_OPM_ENABLED,IS__TUNIT_____ENABLED,IS________NPM_ENABLED,IS__TUNIT_NPM_ENABLED
+; RUN: opt -attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -attributor-enable-call-site-specific-deduction=true -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM,CHECK_ENABLED,NOT_TUNIT_NPM_ENABLED,NOT_TUNIT_OPM_ENABLED,NOT_CGSCC_NPM_ENABLED,IS__CGSCC_____ENABLED,IS________OPM_ENABLED,IS__CGSCC_OPM_ENABLED
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -attributor-enable-call-site-specific-deduction=true -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM,CHECK_ENABLED,NOT_TUNIT_NPM_ENABLED,NOT_TUNIT_OPM_ENABLED,NOT_CGSCC_OPM_ENABLED,IS__CGSCC_____ENABLED,IS________NPM_ENABLED,IS__CGSCC_NPM_ENABLED
+
+define dso_local i32 @test_range1(i32 %0) #0 {
+; CHECK-LABEL: define {{[^@]+}}@test_range1
+; CHECK-SAME: (i32 [[TMP0:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne i32 [[TMP0]], 0
+; CHECK-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP4:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    br label [[TMP5:%.*]]
+; CHECK:       4:
+; CHECK-NEXT:    br label [[TMP5]]
+; CHECK:       5:
+; CHECK-NEXT:    [[DOT0:%.*]] = phi i32 [ 100, [[TMP3]] ], [ 0, [[TMP4]] ]
+; CHECK-NEXT:    ret i32 [[DOT0]]
+;
+  %2 = icmp ne i32 %0, 0
+  br i1 %2, label %3, label %4
+
+3:                                                ; preds = %1
+  br label %5
+
+4:                                                ; preds = %1
+  br label %5
+
+5:                                                ; preds = %4, %3
+  %.0 = phi i32 [ 100, %3 ], [ 0, %4 ]
+  ret i32 %.0
+}
+
+define i32 @test_range2(i32 %0) #0 {
+; CHECK-LABEL: define {{[^@]+}}@test_range2
+; CHECK-SAME: (i32 [[TMP0:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne i32 [[TMP0]], 0
+; CHECK-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP4:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    br label [[TMP5:%.*]]
+; CHECK:       4:
+; CHECK-NEXT:    br label [[TMP5]]
+; CHECK:       5:
+; CHECK-NEXT:    [[DOT0:%.*]] = phi i32 [ 100, [[TMP3]] ], [ 200, [[TMP4]] ]
+; CHECK-NEXT:    ret i32 [[DOT0]]
+;
+  %2 = icmp ne i32 %0, 0
+  br i1 %2, label %3, label %4
+
+3:                                                ; preds = %1
+  br label %5
+
+4:                                                ; preds = %1
+  br label %5
+
+5:                                                ; preds = %4, %3
+  %.0 = phi i32 [ 100, %3 ], [ 200, %4 ]
+  ret i32 %.0
+}
+define i32 @test(i32 %0, i32 %1) #0 {
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test
+; IS__TUNIT____-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]])
+; IS__TUNIT____-NEXT:    [[TMP3:%.*]] = icmp ne i32 [[TMP1]], 0
+; IS__TUNIT____-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP6:%.*]]
+; IS__TUNIT____:       4:
+; IS__TUNIT____-NEXT:    [[TMP5:%.*]] = call i32 @test_range1(i32 [[TMP0]]) #1, !range !0
+; IS__TUNIT____-NEXT:    br label [[TMP8:%.*]]
+; IS__TUNIT____:       6:
+; IS__TUNIT____-NEXT:    [[TMP7:%.*]] = call i32 @test_range2(i32 [[TMP0]]) #1, !range !1
+; IS__TUNIT____-NEXT:    br label [[TMP8]]
+; IS__TUNIT____:       8:
+; IS__TUNIT____-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP5]], [[TMP4]] ], [ [[TMP7]], [[TMP6]] ]
+; IS__TUNIT____-NEXT:    ret i32 [[DOT0]]
+;
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test
+; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]])
+; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = icmp ne i32 [[TMP1]], 0
+; IS__CGSCC____-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP6:%.*]]
+; IS__CGSCC____:       4:
+; IS__CGSCC____-NEXT:    [[TMP5:%.*]] = call i32 @test_range1(i32 [[TMP0]])
+; IS__CGSCC____-NEXT:    br label [[TMP8:%.*]]
+; IS__CGSCC____:       6:
+; IS__CGSCC____-NEXT:    [[TMP7:%.*]] = call i32 @test_range2(i32 [[TMP0]])
+; IS__CGSCC____-NEXT:    br label [[TMP8]]
+; IS__CGSCC____:       8:
+; IS__CGSCC____-NEXT:    [[DOT0:%.*]] = phi i32 [ [[TMP5]], [[TMP4]] ], [ [[TMP7]], [[TMP6]] ]
+; IS__CGSCC____-NEXT:    ret i32 [[DOT0]]
+;
+  %3 = icmp ne i32 %1, 0
+  br i1 %3, label %4, label %6
+
+4:                                                ; preds = %2
+  %5 = call i32 @test_range1(i32 %0)
+  br label %8
+
+6:                                                ; preds = %2
+  %7 = call i32 @test_range2(i32 %0)
+  br label %8
+
+8:                                                ; preds = %6, %4
+  %.0 = phi i32 [ %5, %4 ], [ %7, %6 ]
+  ret i32 %.0
+}
+
+define i32 @test_pcheck1(i32 %0) #0 {
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test_pcheck1
+; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]])
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = call i32 @test(i32 [[TMP0]], i32 1)
+; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = icmp slt i32 [[TMP2]], 101
+; IS__CGSCC____-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; IS__CGSCC____-NEXT:    ret i32 [[TMP4]]
+;
+; IS__TUNIT_____ENABLED-LABEL: define {{[^@]+}}@test_pcheck1
+; IS__TUNIT_____ENABLED-SAME: (i32 [[TMP0:%.*]])
+; IS__TUNIT_____ENABLED-NEXT:    ret i32 1
+;
+  %2 = call i32 @test(i32 %0, i32 1)
+  %3 = icmp slt i32 %2, 101
+  %4 = zext i1 %3 to i32
+  ret i32 %4
+}
+
+define i32 @test_pcheck2(i32 %0) #0 {
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test_pcheck2
+; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]])
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = call i32 @test(i32 [[TMP0]], i32 0)
+; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP2]], 99
+; IS__CGSCC____-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; IS__CGSCC____-NEXT:    ret i32 [[TMP4]]
+;
+; IS__TUNIT_____ENABLED-LABEL: define {{[^@]+}}@test_pcheck2
+; IS__TUNIT_____ENABLED-SAME: (i32 [[TMP0:%.*]])
+; IS__TUNIT_____ENABLED-NEXT:    ret i32 1
+;
+  %2 = call i32 @test(i32 %0, i32 0)
+  %3 = icmp sgt i32 %2, 99
+  %4 = zext i1 %3 to i32
+  ret i32 %4
+}
+
+define i32 @test_ncheck1(i32 %0) #0 {
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test_ncheck1
+; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]])
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = call i32 @test(i32 [[TMP0]], i32 1)
+; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP2]], 50
+; IS__CGSCC____-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; IS__CGSCC____-NEXT:    ret i32 [[TMP4]]
+;
+; IS__TUNIT_____ENABLED-LABEL: define {{[^@]+}}@test_ncheck1
+; IS__TUNIT_____ENABLED-SAME: (i32 [[TMP0:%.*]])
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP2:%.*]] = call i32 @test(i32 [[TMP0]], i32 1) #1, !range !0
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP2]], 50
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; IS__TUNIT_____ENABLED-NEXT:    ret i32 [[TMP4]]
+;
+  %2 = call i32 @test(i32 %0, i32 1)
+  %3 = icmp sgt i32 %2, 50
+  %4 = zext i1 %3 to i32
+  ret i32 %4
+}
+
+define i32 @test_ncheck2(i32 %0) #0 {
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test_ncheck2
+; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]])
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = call i32 @test(i32 [[TMP0]], i32 0)
+; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP2]], 150
+; IS__CGSCC____-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; IS__CGSCC____-NEXT:    ret i32 [[TMP4]]
+;
+; IS__TUNIT_____ENABLED-LABEL: define {{[^@]+}}@test_ncheck2
+; IS__TUNIT_____ENABLED-SAME: (i32 [[TMP0:%.*]])
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP2:%.*]] = call i32 @test(i32 [[TMP0]], i32 0) #1, !range !1
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP2]], 150
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP4:%.*]] = zext i1 [[TMP3]] to i32
+; IS__TUNIT_____ENABLED-NEXT:    ret i32 [[TMP4]]
+;
+  %2 = call i32 @test(i32 %0, i32 0)
+  %3 = icmp sgt i32 %2, 150
+  %4 = zext i1 %3 to i32
+  ret i32 %4
+}
+
+attributes #0 = { noinline nounwind sspstrong uwtable}
+
+; IS__TUNIT_____: !0 = !{i32 0, i32 101}
+; IS__TUNIT_____: !1 = !{i32 100, i32 201}