[Attributor] Attributor call site specific AAValueConstantRange

[kuter]

Summary

This patch makes uses of the context bridges introduced in D83299 to make
AAValueConstantRange call site specific.

[jdoerfert]

Cool! As discussed, merge D83299 and add new call sites for test1.

[kuter]

merge with D83299
add positive and negative tests.

@jdoerfert I have a problem with this patch even though I auto generate tests, llvm-lit fails.
Is this a bug with the update_test_checks.py script ?

[sstefan1]

In D83744#2153411, @kuter wrote:

merge with D83299
add positive and negative tests.

@jdoerfert I have a problem with this patch even though I auto generate tests, llvm-lit fails.
Is this a bug with the update_test_checks.py script ?

Is the output of the script expected? Do all of them fail? Did you maybe specify the wrong opt binary?

[kuter]

In D83744#2150057, @jdoerfert wrote:

Cool! As discussed, merge D83299 and add new call sites for test1.

In D83744#2154282, @sstefan1 wrote:

In D83744#2153411, @kuter wrote:

merge with D83299
add positive and negative tests.

@jdoerfert I have a problem with this patch even though I auto generate tests, llvm-lit fails.
Is this a bug with the update_test_checks.py script ?

Is the output of the script expected? Do all of them fail? Did you maybe specify the wrong opt binary?

In D83744#2154282, @sstefan1 wrote:

In D83744#2153411, @kuter wrote:

merge with D83299
add positive and negative tests.

@jdoerfert I have a problem with this patch even though I auto generate tests, llvm-lit fails.
Is this a bug with the update_test_checks.py script ?

Is the output of the script expected? Do all of them fail? Did you maybe specify the wrong opt binary?

I inspected the output that opt generates and it makes sense.
also the script's output (included in the patch) also makes sense the.

I will double check everything but this is weird.
File check fails to match the first check line.

[uenoku]

llvm/test/Transforms/Attributor/cb_range.ll

3

Could you run for the case of --attributor-enable-call-site-specific=false as a comparison?

[sstefan1]

In D83744#2154384, @kuter wrote:

I inspected the output that opt generates and it makes sense.
also the script's output (included in the patch) also makes sense the.

I will double check everything but this is weird.
File check fails to match the first check line.

I am not sure we can help you much without the actual failure output.

[kuter]

add attributor-enable-call-site-specific=false as a test.
fix the run lines.

@sstefan1 thanks for the help it was because I forgot to add < %s :/

[jdoerfert]

Some minor comments below.

Upload diffs with full context please.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

543

Can we split this in two statements for readability. Also use a C++ cast please. I think we can actually do cast on the AA and then getState() should give the right type. We might need to adjust the state wrapper return type though. Hope this makes some sense.

574

Success

llvm/test/Transforms/Attributor/cb_range.ll

3

we should do this for the old and new PM, as well as the module and CGSCC pass.
so take the 4 run lines we have in other tests, duplicate them so you have them once w/ and once w/o the flag. The check prefixes might need to be adjusted in that case but basically you want check prefixes to overlap so if the code is the same it is shown in the check lines right away.

[kuter]

fix typo.
improve code readability.

[kuter]

In D83744#2158768, @jdoerfert wrote:

Some minor comments below.

Upload diffs with full context please.

I will start using arcanist so I don't make mistakes like this again.

[kuter]

Add test combinations.

[kuter]

fix run lines (there was a mistake in the earlier revision).

[jdoerfert]

LGTM with some comments to be addressed. This is cool :)

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

547

Nit: an 'argument'

553

This should not happen, right? Make it an assert instead.

558

We don't want the value here, do we. We want

const auto &AA =
    A.getAAFor<AAType>(QueryingAttribute, IRPosition::callsite_argument(*CBContext, ArgNo));

which might be better than the plain value result as it has a context instruction (and the attached attributes).

617–623

Use cast<..> and keep it as reference.

[kuter]

small improvements.

There is a probelem with the tests since the last revision, will investigate.

[fhahn]

llvm/test/Transforms/Attributor/cb_range.ll

165

Shouldn't we also check what the range metadata actually contains?

[kuter]

llvm/test/Transforms/Attributor/cb_range.ll

165

The positive and negative checks effectively check the upper and the lower bounds of the ranges

[jdoerfert]

llvm/test/Transforms/Attributor/cb_range.ll

165

We can simply add the check lines manually at the end :)

[kuter]

fix tests.

[kuter]

bug fix.
add range contents as test.

[kuter]

Rebase. Changes in the test run lines.

[kuter]

Split cb_range.ll into two files cb_range_enabled.ll and cb_range_disabled.ll.
This is needed because the combination of prefixes we use triggers a edge case with the
update script.

For more information see D95794 which tries to solve the issue (it doesn't work).
I don't think there is any non O(N!) to fix this edge case.

[RKSimon]

llvm/include/llvm/Transforms/IPO/Attributor.h

1135

@kuter This is breaking some EXPENSIVE_CHECKS builds such as http://lab.llvm.org:8011/#/builders/16/builds/7624

AbstractAttribute isn't defined until later in the header - oddly my MSVC build is quite happy (after my fix at rGe74d6269259e28225a494ce98bd1762cdac1fe89)

[kuter]

llvm/include/llvm/Transforms/IPO/Attributor.h

1135

Thanks , I am aware of this. CMake decided to rebuild everything after I did a git pull.
I am waiting for it to compile right now.

I just assumed that enabling assertions also enabled the expansive checks, I am sorry.
If it still doesn't work after your fix. We can just remove this check for now.

llvm/include/llvm/Transforms/IPO/Attributor.h

 /// A position in the IR is described by an anchor value and an "offset" that
 /// could be the argument number, for call sites and arguments, or an indicator
 /// of the "position kind". The kinds, specified in the Kind enum below, include
 /// the locations in the attribute list, i.a., function scope and return value,
 /// as well as a distinction between call sites and functions. Finally, there
 /// are floating values that do not have a corresponding attribute list
 /// position.
 struct IRPosition {
+  // NOTE: In the future this definition can be changed to support recursive
+  // functions.
   using CallBaseContext = CallBase;
 
   /// The positions we distinguish in the IR.
   enum Kind : char {
     IRP_INVALID,  ///< An invalid position.
     IRP_FLOAT,    ///< A position that is not associated with a spot suitable
                   ///< for attributes. This could be any value or instruction.
     IRP_RETURNED, ///< An attribute for the function return value.
const AAType &getOrCreateAAFor(IRPosition IRP,
                                  bool TrackDependence = false,
                                  DepClassTy DepClass = DepClassTy::OPTIONAL,
                                  bool ForceUpdate = false) {
 #ifdef EXPENSIVE_CHECKS
     // Don't allow callbase information to leak.
     if (auto CBContext = IRP.getCallBaseContext()) {
       assert(
           ((CBContext->getCalledFunction() == IRP.getAnchorScope() ||
             QueryingAA ||
             !QueryingAA.getIRPosition().isAnyCallSitePosition())) &&
           "non callsite positions are not allowed to propagate CallBaseContext "
           "across functions");
     }
 #endif
     if (!shouldPropagateCallBaseContext(IRP))
       IRP = IRP.stripCallBaseContext();
 

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

ChangeStatus clampStateAndIndicateChange(StateType &S, const StateType &R) {
   S ^= R;
   return Assumed == S.getAssumed() ? ChangeStatus::UNCHANGED
                                    : ChangeStatus::CHANGED;
 }
 
 /// Clamp the information known for all returned values of a function
 /// (identified by \p QueryingAA) into \p S.
 template <typename AAType, typename StateType = typename AAType::StateType>
-static void clampReturnedValueStates(Attributor &A, const AAType &QueryingAA,
-                                     StateType &S) {
+static void clampReturnedValueStates(
+    Attributor &A, const AAType &QueryingAA, StateType &S,
+    const IRPosition::CallBaseContext *CBContext = nullptr) {
   LLVM_DEBUG(dbgs() << "[Attributor] Clamp return value states for "
                     << QueryingAA << " into " << S << "\n");
 
   assert((QueryingAA.getIRPosition().getPositionKind() ==
               IRPosition::IRP_RETURNED ||
           QueryingAA.getIRPosition().getPositionKind() ==
               IRPosition::IRP_CALL_SITE_RETURNED) &&
          "Can only clamp returned value states for a function returned or call "
          "site returned position!");
 
   // Use an optional state as there might not be any return values and we want
   // to join (IntegerState::operator&) the state of all there are.
   Optional<StateType> T;
 
   // Callback for each possibly returned value.
   auto CheckReturnValue = [&](Value &RV) -> bool {
-    const IRPosition &RVPos = IRPosition::value(RV);
+    const IRPosition &RVPos = IRPosition::value(RV, CBContext);
     const AAType &AA = A.getAAFor<AAType>(QueryingAA, RVPos);
     LLVM_DEBUG(dbgs() << "[Attributor] RV: " << RV << " AA: " << AA.getAsStr()
                       << " @ " << RVPos << "\n");
     const StateType &AAS = AA.getState();
     if (T.hasValue())
       *T &= AAS;
     else
       T = AAS;
     LLVM_DEBUG(dbgs() << "[Attributor] AA State: " << AAS << " RV State: " << T
                       << "\n");
     return T->isValidState();
   };
 
   if (!A.checkForAllReturnedValues(CheckReturnValue, QueryingAA))
     S.indicatePessimisticFixpoint();
   else if (T.hasValue())
     S ^= *T;
 }
 
 /// Helper class for generic deduction: return value -> returned position.
 template <typename AAType, typename BaseType,
-          typename StateType = typename BaseType::StateType>
+          typename StateType = typename BaseType::StateType,
+          bool PropagateCallBaseContext = false>
 struct AAReturnedFromReturnedValues : public BaseType {
   AAReturnedFromReturnedValues(const IRPosition &IRP, Attributor &A)
       : BaseType(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     StateType S(StateType::getBestState(this->getState()));
-    clampReturnedValueStates<AAType, StateType>(A, *this, S);
+    clampReturnedValueStates<AAType, StateType>(
+        A, *this, S,
+        PropagateCallBaseContext ? this->getCallBaseContext() : nullptr);
     // TODO: If we know we visited all returned values, thus no are assumed
     // dead, we can take the known information from the state T.
     return clampStateAndIndicateChange<StateType>(this->getState(), S);
   }
 };
 
 /// Clamp the information known at all call sites for a given argument
 /// (identified by \p QueryingAA) into \p S.
static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
   bool AllCallSitesKnown;
   if (!A.checkForAllCallSites(CallSiteCheck, QueryingAA, true,
                               AllCallSitesKnown))
     S.indicatePessimisticFixpoint();
   else if (T.hasValue())
     S ^= *T;
 }
 
-/// Helper class for generic deduction: call site argument -> argument position.
+/// This function is the bridge between argument position and the call base
+/// context.
 template <typename AAType, typename BaseType,
           typename StateType = typename AAType::StateType>
+bool getArgumentStateFromCallBaseContext(Attributor &A,
+                                         BaseType &QueryingAttribute,
+                                         IRPosition &Pos, StateType &State) {
+  assert((Pos.getPositionKind() == IRPosition::IRP_ARGUMENT) &&
+         "Expected an 'argument' position !");
+  const CallBase *CBContext = Pos.getCallBaseContext();
+  if (!CBContext)
+    return false;
+
+  int ArgNo = Pos.getCallSiteArgNo();
+  assert(ArgNo >= 0 && "Invalid Arg No!");
+
+  const auto &AA = A.getAAFor<AAType>(
+      QueryingAttribute, IRPosition::callsite_argument(*CBContext, ArgNo));
+  const StateType &CBArgumentState =
+      static_cast<const StateType &>(AA.getState());
+
+  LLVM_DEBUG(dbgs() << "[Attributor] Briding Call site context to argument"
+                    << "Position:" << Pos << "CB Arg state:" << CBArgumentState
+                    << "\n");
+
+  // NOTE: If we want to do call site grouping it should happen here.
+  State ^= CBArgumentState;
+  return true;
+}
+
+/// Helper class for generic deduction: call site argument -> argument position.
+template <typename AAType, typename BaseType,
+          typename StateType = typename AAType::StateType,
+          bool BridgeCallBaseContext = false>
 struct AAArgumentFromCallSiteArguments : public BaseType {
   AAArgumentFromCallSiteArguments(const IRPosition &IRP, Attributor &A)
       : BaseType(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    StateType S(StateType::getBestState(this->getState()));
+    StateType S = StateType::getBestState(this->getState());
+
+    if (BridgeCallBaseContext) {
+      bool Success =
+          getArgumentStateFromCallBaseContext<AAType, BaseType, StateType>(
+              A, *this, this->getIRPosition(), S);
+      if (Success)
+        return clampStateAndIndicateChange<StateType>(this->getState(), S);
+    }
     clampCallSiteArgumentStates<AAType, StateType>(A, *this, S);
+
     // TODO: If we know we visited all incoming values, thus no are assumed
     // dead, we can take the known information from the state T.
     return clampStateAndIndicateChange<StateType>(this->getState(), S);
   }
 };
 
 /// Helper class for generic replication: function returned -> cs returned.
 template <typename AAType, typename BaseType,
-          typename StateType = typename BaseType::StateType>
+          typename StateType = typename BaseType::StateType,
+          bool IntroduceCallBaseContext = false>
 struct AACallSiteReturnedFromReturned : public BaseType {
   AACallSiteReturnedFromReturned(const IRPosition &IRP, Attributor &A)
       : BaseType(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     assert(this->getIRPosition().getPositionKind() ==
                IRPosition::IRP_CALL_SITE_RETURNED &&
            "Can only wrap function returned positions for call site returned "
            "positions!");
     auto &S = this->getState();
 
     const Function *AssociatedFunction =
         this->getIRPosition().getAssociatedFunction();
     if (!AssociatedFunction)
       return S.indicatePessimisticFixpoint();
 
-    IRPosition FnPos = IRPosition::returned(*AssociatedFunction);
+    CallBase &CBContext = static_cast<CallBase &>(this->getAnchorValue());
+    if (IntroduceCallBaseContext)
+      LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:"
+                        << CBContext << "\n");
+
+    IRPosition FnPos = IRPosition::returned(
+        *AssociatedFunction, IntroduceCallBaseContext ? &CBContext : nullptr);
     const AAType &AA = A.getAAFor<AAType>(*this, FnPos);
     return clampStateAndIndicateChange(S, AA.getState());
   }
 };
 
 /// Helper function to accumulate uses.
 template <class AAType, typename StateType = typename AAType::StateType>
 static void followUsesInContext(AAType &AA, Attributor &A,
ChangeStatus manifest(Attributor &A) override {
     }
 
     return Changed;
   }
 };
 
 struct AAValueConstantRangeArgument final
     : AAArgumentFromCallSiteArguments<
-          AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState> {
+          AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState,
+          true /* BridgeCallBaseContext */> {
   using Base = AAArgumentFromCallSiteArguments<
-      AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState>;
+      AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState,
+      true /* BridgeCallBaseContext */>;
   AAValueConstantRangeArgument(const IRPosition &IRP, Attributor &A)
       : Base(IRP, A) {}
 
   /// See AbstractAttribute::initialize(..).
   void initialize(Attributor &A) override {
     if (!getAnchorScope() || getAnchorScope()->isDeclaration()) {
       indicatePessimisticFixpoint();
     } else {
       Base::initialize(A);
     }
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_ARG_ATTR(value_range)
   }
 };
 
 struct AAValueConstantRangeReturned
     : AAReturnedFromReturnedValues<AAValueConstantRange,
-                                   AAValueConstantRangeImpl> {
-  using Base = AAReturnedFromReturnedValues<AAValueConstantRange,
-                                            AAValueConstantRangeImpl>;
+                                   AAValueConstantRangeImpl,
+                                   AAValueConstantRangeImpl::StateType,
+                                   /* PropogateCallBaseContext */ true> {
+  using Base =
+      AAReturnedFromReturnedValues<AAValueConstantRange,
+                                   AAValueConstantRangeImpl,
+                                   AAValueConstantRangeImpl::StateType,
+                                   /* PropogateCallBaseContext */ true>;
   AAValueConstantRangeReturned(const IRPosition &IRP, Attributor &A)
       : Base(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
bool calculateBinaryOperator(
       const Instruction *CtxI,
       SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
     Value *LHS = BinOp->getOperand(0);
     Value *RHS = BinOp->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));
+    auto &LHSAA = A.getAAFor<AAValueConstantRange>(
+        *this, IRPosition::value(*LHS, getCallBaseContext()));
     QuerriedAAs.push_back(&LHSAA);
     auto LHSAARange = LHSAA.getAssumedConstantRange(A, CtxI);
 
-    auto &RHSAA =
-        A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(*RHS));
+    auto &RHSAA = A.getAAFor<AAValueConstantRange>(
+        *this, IRPosition::value(*RHS, getCallBaseContext()));
     QuerriedAAs.push_back(&RHSAA);
     auto RHSAARange = RHSAA.getAssumedConstantRange(A, CtxI);
 
     auto AssumedRange = LHSAARange.binaryOp(BinOp->getOpcode(), RHSAARange);
 
     T.unionAssumed(AssumedRange);
 
     // TODO: Track a known state too.
 
     return T.isValidState();
   }
 
   bool calculateCastInst(
       Attributor &A, CastInst *CastI, IntegerRangeState &T,
       const Instruction *CtxI,
       SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
     assert(CastI->getNumOperands() == 1 && "Expected cast to be unary!");
     // TODO: Allow non integers as well.
     Value &OpV = *CastI->getOperand(0);
     if (!OpV.getType()->isIntegerTy())
       return false;
 
-    auto &OpAA =
-        A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(OpV));
+    auto &OpAA = A.getAAFor<AAValueConstantRange>(
+        *this, IRPosition::value(OpV, getCallBaseContext()));
     QuerriedAAs.push_back(&OpAA);
     T.unionAssumed(
         OpAA.getAssumed().castOp(CastI->getOpcode(), getState().getBitWidth()));
     return T.isValidState();
   }
 
   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));
+    auto &LHSAA = A.getAAFor<AAValueConstantRange>(
+        *this, IRPosition::value(*LHS, getCallBaseContext()));
     QuerriedAAs.push_back(&LHSAA);
-    auto &RHSAA =
-        A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(*RHS));
+    auto &RHSAA = A.getAAFor<AAValueConstantRange>(
+        *this, IRPosition::value(*RHS, getCallBaseContext()));
     QuerriedAAs.push_back(&RHSAA);
 
     auto LHSAARange = LHSAA.getAssumedConstantRange(A, CtxI);
     auto RHSAARange = RHSAA.getAssumedConstantRange(A, CtxI);
 
     // If one of them is empty set, we can't decide.
     if (LHSAARange.isEmptySet() || RHSAARange.isEmptySet())
       return true;
AAValueConstantRangeCallSite(const IRPosition &IRP, Attributor &A)
       : AAValueConstantRangeFunction(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(value_range) }
 };
 
 struct AAValueConstantRangeCallSiteReturned
     : AACallSiteReturnedFromReturned<AAValueConstantRange,
-                                     AAValueConstantRangeImpl> {
+                                     AAValueConstantRangeImpl,
+                                     AAValueConstantRangeImpl::StateType,
+                                     /* IntroduceCallBaseContext */ true> {
   AAValueConstantRangeCallSiteReturned(const IRPosition &IRP, Attributor &A)
       : AACallSiteReturnedFromReturned<AAValueConstantRange,
-                                       AAValueConstantRangeImpl>(IRP, A) {}
+                                       AAValueConstantRangeImpl,
+                                       AAValueConstantRangeImpl::StateType,
+                                       /* IntroduceCallBaseContext */ true>(IRP,
+                                                                            A) {
+  }
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     // If it is a load instruction with range metadata, use the metadata.
     if (CallInst *CI = dyn_cast<CallInst>(&getAssociatedValue()))
       if (auto *RangeMD = CI->getMetadata(LLVMContext::MD_range))
         intersectKnown(getConstantRangeFromMetadata(*RangeMD));
 

llvm/test/Transforms/Attributor/cb_range.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 -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM,CHECK_DISABLED,NOT_CGSCC_NPM_DISABLED,NOT_CGSCC_OPM_DISABLED,NOT_TUNIT_NPM_DISABLED,IS__TUNIT_____DISABLED,IS________OPM_DISABLED,IS__TUNIT_OPM_DISABLED
+
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM,CHECK_DISABLED,NOT_CGSCC_OPM_DISABLED,NOT_CGSCC_NPM_DISABLED,NOT_TUNIT_OPM_DISABLED,IS__TUNIT_____DISABLED,IS________NPM_DISABLED,IS__TUNIT_NPM_DISABLED
+
+; RUN: opt -attributor-cgscc -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM,CHECK_DISABLED,NOT_TUNIT_NPM_DISABLED,NOT_TUNIT_OPM_DISABLED,NOT_CGSCC_NPM_DISABLED,IS__CGSCC_____DISABLED,IS________OPM_DISABLED,IS__CGSCC_OPM_DISABLED
+
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM,CHECK_DISABLED,NOT_TUNIT_NPM_DISABLED,NOT_TUNIT_OPM_DISABLED,NOT_CGSCC_OPM_DISABLED,IS__CGSCC_____DISABLED,IS________NPM_DISABLED,IS__CGSCC_NPM_DISABLED
+
+; call site specific analysis is enabled
+
+; RUN: opt -attributor -enable-new-pm=0 -attributor-enable-call-site-specific-deduction=true -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -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-enable-call-site-specific-deduction=true -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -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-enable-call-site-specific-deduction=true -enable-new-pm=0 -attributor-manifest-internal  -attributor-annotate-decl-cs -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
+
+; Some update script generated tests fail in the test1_ncheck function.
+; This is the run line that causes the fail.
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-enable-call-site-specific-deduction=true -attributor-manifest-internal  -attributor-annotate-decl-cs -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 i32 @test_range(i32 %unknown) {
+; CHECK-LABEL: define {{[^@]+}}@test_range
+; CHECK-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp sgt i32 [[UNKNOWN]], 100
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP1]], i32 100, i32 0
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %1 = icmp sgt i32 %unknown, 100
+  %2 = select i1 %1, i32 100, i32 0
+  ret i32 %2
+}
+
+define i32 @test1(i32 %unknown, i32 %b) {
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test1
+; IS__TUNIT____-SAME: (i32 [[UNKNOWN:%.*]], i32 [[B:%.*]]) [[ATTR0:#.*]] {
+; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = call i32 @test_range(i32 [[UNKNOWN]]) [[ATTR0]], [[RNG0:!range !.*]]
+; IS__TUNIT____-NEXT:    [[TMP2:%.*]] = sub nsw i32 [[TMP1]], [[B]]
+; IS__TUNIT____-NEXT:    ret i32 [[TMP2]]
+;
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test1
+; IS__CGSCC____-SAME: (i32 [[UNKNOWN:%.*]], i32 [[B:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = call i32 @test_range(i32 [[UNKNOWN]]) [[ATTR1:#.*]], [[RNG0:!range !.*]]
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = sub nsw i32 [[TMP1]], [[B]]
+; IS__CGSCC____-NEXT:    ret i32 [[TMP2]]
+;
+  %1 = call i32 @test_range(i32 %unknown)
+  %2 = sub nsw i32 %1, %b
+  ret i32 %2
+}
+
+define i32 @test2(i32 %unknown, i32 %b) {
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test2
+; IS__TUNIT____-SAME: (i32 [[UNKNOWN:%.*]], i32 [[B:%.*]]) [[ATTR0]] {
+; IS__TUNIT____-NEXT:    [[TMP1:%.*]] = call i32 @test_range(i32 [[UNKNOWN]]) [[ATTR0]], [[RNG0]]
+; IS__TUNIT____-NEXT:    [[TMP2:%.*]] = add nsw i32 [[TMP1]], [[B]]
+; IS__TUNIT____-NEXT:    ret i32 [[TMP2]]
+;
+; IS__CGSCC____-LABEL: define {{[^@]+}}@test2
+; IS__CGSCC____-SAME: (i32 [[UNKNOWN:%.*]], i32 [[B:%.*]]) [[ATTR0]] {
+; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = call i32 @test_range(i32 [[UNKNOWN]]) [[ATTR1]], [[RNG0]]
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = add nsw i32 [[TMP1]], [[B]]
+; IS__CGSCC____-NEXT:    ret i32 [[TMP2]]
+;
+  %1 = call i32 @test_range(i32 %unknown)
+  %2 = add nsw i32 %1, %b
+  ret i32 %2
+}
+
+; Positive checks
+
+define i32 @test1_pcheck(i32 %unknown) {
+; NOT_CGSCC_NPM_DISABLED-LABEL: define {{[^@]+}}@test1_pcheck
+; NOT_CGSCC_NPM_DISABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; NOT_CGSCC_NPM_DISABLED-NEXT:    [[TMP1:%.*]] = call i32 @test1(i32 [[UNKNOWN]], i32 noundef 20)
+; NOT_CGSCC_NPM_DISABLED-NEXT:    [[TMP2:%.*]] = icmp sle i32 [[TMP1]], 90
+; NOT_CGSCC_NPM_DISABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; NOT_CGSCC_NPM_DISABLED-NEXT:    ret i32 [[TMP3]]
+;
+; IS__CGSCC_NPM_DISABLED-LABEL: define {{[^@]+}}@test1_pcheck
+; IS__CGSCC_NPM_DISABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_NPM_DISABLED-NEXT:    [[TMP1:%.*]] = call i32 @test1(i32 [[UNKNOWN]], i32 noundef 20) [[ATTR1:#.*]], [[RNG1:!range !.*]]
+; IS__CGSCC_NPM_DISABLED-NEXT:    [[TMP2:%.*]] = icmp sle i32 [[TMP1]], 90
+; IS__CGSCC_NPM_DISABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; IS__CGSCC_NPM_DISABLED-NEXT:    ret i32 [[TMP3]]
+;
+; CHECK_ENABLED-LABEL: define {{[^@]+}}@test1_pcheck
+; CHECK_ENABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; CHECK_ENABLED-NEXT:    ret i32 1
+;
+  %1 = call i32 @test1(i32 %unknown, i32 20)
+  %2 = icmp sle i32 %1, 90
+  %3 = zext i1 %2 to i32
+  ret i32 %3
+}
+
+define i32 @test2_pcheck(i32 %unknown) {
+; CHECK_DISABLED-LABEL: define {{[^@]+}}@test2_pcheck
+; CHECK_DISABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; CHECK_DISABLED-NEXT:    [[TMP1:%.*]] = call i32 @test2(i32 [[UNKNOWN]], i32 noundef 20)
+; CHECK_DISABLED-NEXT:    [[TMP2:%.*]] = icmp sge i32 [[TMP1]], 20
+; CHECK_DISABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; CHECK_DISABLED-NEXT:    ret i32 [[TMP3]]
+;
+; CHECK_ENABLED-LABEL: define {{[^@]+}}@test2_pcheck
+; CHECK_ENABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0]] {
+; CHECK_ENABLED-NEXT:    ret i32 1
+;
+  %1 = call i32 @test2(i32 %unknown, i32 20)
+  %2 = icmp sge i32 %1, 20
+  %3 = zext i1 %2 to i32
+  ret i32 %3
+}
+
+; Negative checks
+
+define i32 @test1_ncheck(i32 %unknown) {
+; NOT_CGSCC_NPM_DISABLED-LABEL: define {{[^@]+}}@test1_ncheck
+; NOT_CGSCC_NPM_DISABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0]] {
+; NOT_CGSCC_NPM_DISABLED-NEXT:    [[TMP1:%.*]] = call i32 @test1(i32 [[UNKNOWN]], i32 noundef 20)
+; NOT_CGSCC_NPM_DISABLED-NEXT:    [[TMP2:%.*]] = icmp sle i32 [[TMP1]], 10
+; NOT_CGSCC_NPM_DISABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; NOT_CGSCC_NPM_DISABLED-NEXT:    ret i32 [[TMP3]]
+;
+
+; Test passes if you remove this check block.
+; Or Manually adding a _DISABLED suffix fixes the issue.
+; I added "ignore me" to the end of the check line to disable this for now.
+
+; IS__CGSCC_NPM-LABEL ignore me : define {{[^@]+}}@test1_ncheck
+; IS__CGSCC_NPM-SAME ignore me : (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_NPM-NEXT ignore me :    [[TMP1:%.*]] = call i32 @test1(i32 [[UNKNOWN]], i32 noundef 20) [[ATTR1:#.*]], [[RNG1:!range !.*]]
+; IS__CGSCC_NPM-NEXT ignore me :    [[TMP2:%.*]] = icmp sle i32 [[TMP1]], 10
+; IS__CGSCC_NPM-NEXT ignore me :    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; IS__CGSCC_NPM-NEXT ignore me :    ret i32 [[TMP3]]
+;
+; IS__TUNIT_____ENABLED-LABEL: define {{[^@]+}}@test1_ncheck
+; IS__TUNIT_____ENABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP1:%.*]] = call i32 @test1(i32 [[UNKNOWN]], i32 noundef 20) [[ATTR0]], [[RNG1:!range !.*]]
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP2:%.*]] = icmp sle i32 [[TMP1]], 10
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; IS__TUNIT_____ENABLED-NEXT:    ret i32 [[TMP3]]
+;
+
+; This fails to match in the last run line.
+; This is because IS__CGSCC_NPM-LABEL already processed the function signiture.
+
+; IS__CGSCC_____ENABLED-LABEL: define {{[^@]+}}@test1_ncheck
+; IS__CGSCC_____ENABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_____ENABLED-NEXT:    [[TMP1:%.*]] = call i32 @test1(i32 [[UNKNOWN]], i32 noundef 20) [[ATTR1:#.*]], [[RNG1:!range !.*]]
+; IS__CGSCC_____ENABLED-NEXT:    [[TMP2:%.*]] = icmp sle i32 [[TMP1]], 10
+; IS__CGSCC_____ENABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; IS__CGSCC_____ENABLED-NEXT:    ret i32 [[TMP3]]
+;
+
+  %1 = call i32 @test1(i32 %unknown, i32 20)
+  %2 = icmp sle i32 %1, 10
+  %3 = zext i1 %2 to i32
+  ret i32 %3
+}
+
+define i32 @test2_ncheck(i32 %unknown) {
+; CHECK_DISABLED-LABEL: define {{[^@]+}}@test2_ncheck
+; CHECK_DISABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0]] {
+; CHECK_DISABLED-NEXT:    [[TMP1:%.*]] = call i32 @test2(i32 [[UNKNOWN]], i32 noundef 20)
+; CHECK_DISABLED-NEXT:    [[TMP2:%.*]] = icmp sge i32 [[TMP1]], 30
+; CHECK_DISABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; CHECK_DISABLED-NEXT:    ret i32 [[TMP3]]
+;
+; IS__TUNIT_____ENABLED-LABEL: define {{[^@]+}}@test2_ncheck
+; IS__TUNIT_____ENABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0]] {
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP1:%.*]] = call i32 @test2(i32 [[UNKNOWN]], i32 noundef 20) [[ATTR0]], [[RNG2:!range !.*]]
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP2:%.*]] = icmp sge i32 [[TMP1]], 30
+; IS__TUNIT_____ENABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; IS__TUNIT_____ENABLED-NEXT:    ret i32 [[TMP3]]
+;
+; IS__CGSCC_____ENABLED-LABEL: define {{[^@]+}}@test2_ncheck
+; IS__CGSCC_____ENABLED-SAME: (i32 [[UNKNOWN:%.*]]) [[ATTR0]] {
+; IS__CGSCC_____ENABLED-NEXT:    [[TMP1:%.*]] = call i32 @test2(i32 [[UNKNOWN]], i32 noundef 20) [[ATTR1]], [[RNG2:!range !.*]]
+; IS__CGSCC_____ENABLED-NEXT:    [[TMP2:%.*]] = icmp sge i32 [[TMP1]], 30
+; IS__CGSCC_____ENABLED-NEXT:    [[TMP3:%.*]] = zext i1 [[TMP2]] to i32
+; IS__CGSCC_____ENABLED-NEXT:    ret i32 [[TMP3]]
+;
+  %1 = call i32 @test2(i32 %unknown, i32 20)
+  %2 = icmp sge i32 %1, 30
+  %3 = zext i1 %2 to i32
+  ret i32 %3
+}
+; CHECK: !0 = !{i32 0, i32 101}