[Attributor] Look through indirect calls

[jdoerfert]

Summary

Through the new Attributor::checkForAllCallees we can look through
indirect calls and visit all potential callees if they are known.

[arsenm]

llvm/lib/Transforms/IPO/Attributor.cpp

1015

Why the compare to 1 for a bool?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

1015

If we have more than 1 potential callee we don't know if it is a "must" callee anymore. I haven't thought enough about this to be sure we need or don't need it but there is the possibility we want to distinguish callees that may be called here from the one that certainly is.

[arsenm]

ping, what is the status of this?

[jdoerfert]

In D112290#4048511, @arsenm wrote:

ping, what is the status of this?

Ready for review :)

[tianshilei1992]

llvm/lib/Transforms/IPO/Attributor.cpp

1006

/*NumCallees=*/ 1?

1015

Probably instead of using NumCallees (I'm not sure if the CB will need the value), can we use something like bool IsUnique?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

1006

will do.

1015

I figured it doesn't cost anything to provide more information. Once can use it for a heuristic, so decide not to spend time if the #callees is larget han some threshold.

[tianshilei1992]

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

2653–2654

I thought the optimistic condition would be we don't have indirect calls such that the "callee" is required.

llvm/lib/Transforms/IPO/Attributor.cpp

1015

I kinda think the interface of the CB just looks a little weird. Essentially the best way is something like ArrayRef<Function *> Callees, and then we can have both information. However, checkForAll* interfaces itself mean doing the check one by one instead of passing an array to the CB.
That being said, I don't have a strong objection to it, but just prefer a clean definition. If in the future we will need the number, we can revise it.

[jdoerfert]

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

2653–2654

It's not about optimistic per se. This is a way to avoid creating AAs that will result in a pessimistic fixpoint right away. With this change, most AAs use checkForAllCallees via AACalleeToCallSite and therefore will be able to cope with "missing"/"non-unique" callees.

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

public:
 
   /// Return true if \p BB is assumed dead.
   ///
   /// If \p LivenessAA is not provided it is queried.
   bool isAssumedDead(const BasicBlock &BB, const AbstractAttribute *QueryingAA,
                      const AAIsDead *FnLivenessAA,
                      DepClassTy DepClass = DepClassTy::OPTIONAL);
 
+  /// Check \p Pred on all potential Callees of \p CB.
+  ///
+  /// This method will evaluate \p Pred on all potential callees of \p CB and
+  /// return true if \p Pred holds every time. The second argument to \p Pred
+  /// indicates if this is a must-be-called callee or a may-be-called callee.
+  /// If some callees might be unknown this function will return false.
+  bool checkForAllCallees(function_ref<bool(const Function &, bool)> Pred,
+                       const AbstractAttribute &QueryingAA, const CallBase &CB);
+
   /// Check \p Pred on all (transitive) uses of \p V.
   ///
   /// This method will evaluate \p Pred on all (transitive) uses of the
   /// associated value and return true if \p Pred holds every time.
   bool checkForAllUses(function_ref<bool(const Use &, bool &)> Pred,
                        const AbstractAttribute &QueryingAA, const Value &V,
                        bool CheckBBLivenessOnly = false,
                        DepClassTy LivenessDepClass = DepClassTy::OPTIONAL);
struct AbstractAttribute : public IRPosition, public AADepGraphNode {
 
   /// This function is used to identify if an \p DGN is of type
   /// AbstractAttribute so that the dyn_cast and cast can use such information
   /// to cast an AADepGraphNode to an AbstractAttribute.
   ///
   /// We eagerly return true here because all AADepGraphNodes except for the
   /// Synthethis Node are of type AbstractAttribute
   static bool classof(const AADepGraphNode *DGN) { return true; }
 
   /// Initialize the state with the information in the Attributor \p A.
   ///
   /// This function is called by the Attributor once all abstract attributes
   /// have been identified. It can and shall be used for task like:
   ///  - identify existing knowledge in the IR and use it for the "known state"
   ///  - perform any work that is not going to change over time, e.g., determine
   ///    a subset of the IR, or attributes in-flight, that have to be looked at
   ///    in the `updateImpl` method.
   virtual void initialize(Attributor &A) {}

llvm/lib/Transforms/IPO/Attributor.cpp

if (FnLivenessAA->isAssumedDead(&BB)) {
     if (QueryingAA)
       recordDependence(*FnLivenessAA, *QueryingAA, DepClass);
     return true;
   }
 
   return false;
 }
 
+bool Attributor::checkForAllCallees(
+    function_ref<bool(const Function &, bool)> Pred,
+    const AbstractAttribute &QueryingAA, const CallBase &CB) {
+  if (const Function *Callee = CB.getCalledFunction())
+    return Pred(*Callee, true);
+
+  const auto &CallEdgesAA = getAAFor<AACallEdges>(
+      QueryingAA, IRPosition::callsite_function(CB), DepClassTy::OPTIONAL);
+  if (CallEdgesAA.hasUnknownCallee())
+    return false;
+
+  const auto &Callees = CallEdgesAA.getOptimisticEdges();
+  for (Function *Callee : Callees)
+    if (!Pred(*Callee, Callees.size() == 1))
+      return false;
+  return true;
+}
+
 bool Attributor::checkForAllUses(function_ref<bool(const Use &, bool &)> Pred,
                                  const AbstractAttribute &QueryingAA,
                                  const Value &V, bool CheckBBLivenessOnly,
                                  DepClassTy LivenessDepClass) {
 
   // Check the trivial case first as it catches void values.
   if (V.use_empty())
     return true;

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

struct AACallSiteReturnedFromReturned : public BaseType {
   /// 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();
-
-    CallBase &CBContext = static_cast<CallBase &>(this->getAnchorValue());
+    CallBase &CB = cast<CallBase>(this->getAnchorValue());
     if (IntroduceCallBaseContext)
-      LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:"
-                        << CBContext << "\n");
+      LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:" << CB
+                        << "\n");
 
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
       IRPosition FnPos = IRPosition::returned(
-        *AssociatedFunction, IntroduceCallBaseContext ? &CBContext : nullptr);
+          Callee, IntroduceCallBaseContext ? &CB : nullptr);
       const AAType &AA = A.getAAFor<AAType>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(S, AA.getState());
+      Changed |= clampStateAndIndicateChange(S, AA.getState());
+      return true;
+    };
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return S.indicatePessimisticFixpoint();
+    return Changed;
   }
 };
 
 /// Helper function to accumulate uses.
 template <class AAType, typename StateType = typename AAType::StateType>
 static void followUsesInContext(AAType &AA, Attributor &A,
                                 MustBeExecutedContextExplorer &Explorer,
                                 const Instruction *CtxI,
struct AANoUnwindCallSite final : AANoUnwindImpl {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Once we have call site specific value information we can provide
     //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA = A.getAAFor<AANoUnwind>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nounwind); }
 };
 
 /// --------------------- Function Return Values -------------------------------
 
void initialize(Attributor &A) override {
     IsValidState = true;
     ReturnedValues.clear();
 
     Function *F = getAssociatedFunction();
     if (!F || F->isDeclaration()) {
       indicatePessimisticFixpoint();
       return;
     }
-    assert(!F->getReturnType()->isVoidTy() &&
-           "Did not expect a void return type!");
+    if (F->getReturnType()->isVoidTy()) {
+      indicatePessimisticFixpoint();
+      return;
+    }
 
     // The map from instruction opcodes to those instructions in the function.
     auto &OpcodeInstMap = A.getInfoCache().getOpcodeInstMapForFunction(*F);
 
     // Look through all arguments, if one is marked as returned we are done.
     for (Argument &Arg : F->args()) {
       if (Arg.hasReturnedAttr()) {
         auto &ReturnInstSet = ReturnedValues[&Arg];
struct AANoSyncCallSite final : AANoSyncImpl {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Once we have call site specific value information we can provide
     //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA = A.getAAFor<AANoSync>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nosync); }
 };
 
 /// ------------------------ No-Free Attributes ----------------------------
 
struct AANoFreeCallSite final : AANoFreeImpl {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Once we have call site specific value information we can provide
     //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA = A.getAAFor<AANoFree>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nofree); }
 };
 
 /// NoFree attribute for floating values.
 struct AANoFreeFloating : AANoFreeImpl {
struct AANoRecurseFunction final : AANoRecurseImpl {
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse) }
 };
 
 /// NoRecurse attribute deduction for a call sites.
 struct AANoRecurseCallSite final : AANoRecurseImpl {
   AANoRecurseCallSite(const IRPosition &IRP, Attributor &A)
       : AANoRecurseImpl(IRP, A) {}
 
-  /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
-    AANoRecurseImpl::initialize(A);
-    Function *F = getAssociatedFunction();
-    if (!F || F->isDeclaration())
-      indicatePessimisticFixpoint();
-  }
-
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Once we have call site specific value information we can provide
     //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA = A.getAAFor<AANoRecurse>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(norecurse); }
 };
 
 /// -------------------- Undefined-Behavior Attributes ------------------------
 
void initialize(Attributor &A) override {
     if (!F || !A.isFunctionIPOAmendable(*F))
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
       return ChangeStatus::UNCHANGED;
-
     // TODO: Once we have call site specific value information we can provide
     //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA = A.getAAFor<AAWillReturn>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(willreturn); }
 };
 
 /// -------------------AAReachability Attribute--------------------------
 
struct AANoReturnCallSite final : AANoReturnImpl {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Once we have call site specific value information we can provide
     //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(noreturn); }
 };
 
 /// ----------------------- Variable Capturing ---------------------------------
 
void initialize(Attributor &A) override {
     Function *F = getAssociatedFunction();
     if (!F || F->isDeclaration())
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness liveness information and then it makes
+    //       call site specific liveness information and then it makes
     //       sense to specialize attributes for call sites arguments instead of
     //       redirecting requests to the callee argument.
-    Function *F = getAssociatedFunction();
-    const IRPosition &FnPos = IRPosition::function(*F);
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    auto CalleePred = [&](const Function &Callee, bool MustCallee) {
+      const IRPosition &FnPos = IRPosition::function(Callee);
       auto &FnAA =
           A.getAAFor<AAMemoryBehavior>(*this, FnPos, DepClassTy::REQUIRED);
-    return clampStateAndIndicateChange(getState(), FnAA.getState());
+      Changed |= clampStateAndIndicateChange(getState(), FnAA.getState());
+      return true;
+    };
+    CallBase &CB = *cast<CallBase>(getCtxI());
+    if (!A.checkForAllCallees(CalleePred, *this, CB))
+      return indicatePessimisticFixpoint();
+    return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     if (isAssumedReadNone())
       STATS_DECLTRACK_CS_ATTR(readnone)
     else if (isAssumedReadOnly())
       STATS_DECLTRACK_CS_ATTR(readonly)
size_t QueryCount =
         WholeFunction.Reachable.size() + WholeFunction.Unreachable.size();
 
     return "FunctionReachability [" +
            std::to_string(WholeFunction.Reachable.size()) + "," +
            std::to_string(QueryCount) + "]";
   }
 
   void trackStatistics() const override {}
+
 private:
   bool canReachUnknownCallee() const override {
     return WholeFunction.CanReachUnknownCallee;
   }
 
   /// Used to answer if a the whole function can reacha a specific function.
   QuerySet WholeFunction;
 

llvm/test/Transforms/Attributor/IPConstantProp/arg-count-mismatch.ll

 ; Note that -lint will report this as UB, but it passes -verify.
 
 ; This test is just to verify that we do not crash/assert due to mismatch in
 ; argument count between the caller and callee.
 
 ; FIXME we should recognize this as UB and make it an unreachable.
 
 define dso_local i16 @foo(i16 %a) {
-; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@foo
-; NOT_CGSCC_NPM-SAME: (i16 [[A:%.*]]) {
-; NOT_CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
-; NOT_CGSCC_NPM-NEXT:    ret i16 [[CALL]]
+; IS__TUNIT____-LABEL: define {{[^@]+}}@foo
+; IS__TUNIT____-SAME: (i16 [[A:%.*]]) {
+; IS__TUNIT____-NEXT:    [[CALL:%.*]] = call noundef i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
+; IS__TUNIT____-NEXT:    ret i16 [[CALL]]
+;
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@foo
+; IS__CGSCC_OPM-SAME: (i16 [[A:%.*]]) {
+; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
+; IS__CGSCC_OPM-NEXT:    ret i16 [[CALL]]
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@foo
 ; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) #[[ATTR0:[0-9]+]] {
-; IS__CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
+; IS__CGSCC_NPM-NEXT:    [[CALL:%.*]] = call noundef i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
 ; IS__CGSCC_NPM-NEXT:    ret i16 [[CALL]]
 ;
   %call = call i16 bitcast (i16 (i16, i16) * @bar to i16 (i16) *)(i16 %a)
   ret i16 %call
 }
 
 define internal i16 @bar(i16 %p1, i16 %p2) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn

 
 
 ;-------------------------------------------------------------------------------
 ; Additional tests to verify that we still optimize when having a mismatch
 ; in argument count due to varargs (as long as all non-variadic arguments have
 ; been provided),
 
 define dso_local i16 @vararg_tests(i16 %a) {
-; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@vararg_tests
-; NOT_CGSCC_NPM-SAME: (i16 [[A:%.*]]) {
-; NOT_CGSCC_NPM-NEXT:    [[CALL2:%.*]] = call i16 bitcast (i16 (i16, i16, ...)* @vararg_no_prop to i16 (i16)*)(i16 noundef 7)
-; NOT_CGSCC_NPM-NEXT:    [[ADD:%.*]] = add i16 7, [[CALL2]]
-; NOT_CGSCC_NPM-NEXT:    ret i16 [[ADD]]
+; IS__TUNIT____-LABEL: define {{[^@]+}}@vararg_tests
+; IS__TUNIT____-SAME: (i16 [[A:%.*]]) {
+; IS__TUNIT____-NEXT:    ret i16 14
+;
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@vararg_tests
+; IS__CGSCC_OPM-SAME: (i16 [[A:%.*]]) {
+; IS__CGSCC_OPM-NEXT:    [[CALL2:%.*]] = call i16 bitcast (i16 (i16, i16, ...)* @vararg_no_prop to i16 (i16)*)(i16 noundef 7)
+; IS__CGSCC_OPM-NEXT:    [[ADD:%.*]] = add i16 7, [[CALL2]]
+; IS__CGSCC_OPM-NEXT:    ret i16 14
 ;
-; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@vararg_tests
-; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) #[[ATTR0]] {
-; IS__CGSCC_NPM-NEXT:    [[CALL2:%.*]] = call i16 bitcast (i16 (i16, i16, ...)* @vararg_no_prop to i16 (i16)*)(i16 noundef 7)
-; IS__CGSCC_NPM-NEXT:    [[ADD:%.*]] = add i16 7, [[CALL2]]
-; IS__CGSCC_NPM-NEXT:    ret i16 [[ADD]]
+; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) #[[ATTR1]] {
+; IS__CGSCC_NPM-NEXT:    ret i16 14
 ;
   %call1 = call i16 (i16, ...) @vararg_prop(i16 7, i16 8, i16 %a)
   %call2 = call i16 bitcast (i16 (i16, i16, ...) * @vararg_no_prop to i16 (i16) *) (i16 7)
   %add = add i16 %call1, %call2
   ret i16 %add
 }
 
 define internal i16 @vararg_prop(i16 %p1, ...) {
 ; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@vararg_prop
 ; IS__CGSCC_OPM-SAME: (i16 [[P1:%.*]], ...) #[[ATTR0]] {
 ; IS__CGSCC_OPM-NEXT:    ret i16 undef
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@vararg_prop
 ; IS__CGSCC_NPM-SAME: (i16 [[P1:%.*]], ...) #[[ATTR1]] {
 ; IS__CGSCC_NPM-NEXT:    ret i16 undef
 ;
   ret i16 %p1
 }
 
 define internal i16 @vararg_no_prop(i16 %p1, i16 %p2, ...) {
-; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
-; IS__TUNIT____-LABEL: define {{[^@]+}}@vararg_no_prop
-; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR0]] {
-; IS__TUNIT____-NEXT:    ret i16 7
-;
 ; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@vararg_no_prop
 ; IS__CGSCC_OPM-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR0]] {
-; IS__CGSCC_OPM-NEXT:    ret i16 7
+; IS__CGSCC_OPM-NEXT:    ret i16 undef
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@vararg_no_prop
 ; IS__CGSCC_NPM-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR1]] {
-; IS__CGSCC_NPM-NEXT:    ret i16 7
+; IS__CGSCC_NPM-NEXT:    ret i16 undef
 ;
   ret i16 %p1
 }
 
 ;.
 ; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind readnone willreturn }
 ;.
 ; IS__CGSCC_OPM: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind readnone willreturn }
 ;.
 ; IS__CGSCC_NPM: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind readnone }
 ; IS__CGSCC_NPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
 ;.