[Attributor] Use assumed information to determine side-effects

[jdoerfert]

Summary

We relied on wouldInstructionBeTriviallyDead before but that functions
does not take assumed information, especially for calls, into account.
The replacement, AAIsDead::isAssumeSideEffectFree, does.

This change makes AAIsDeadCallSiteReturn more complex as we can have
a dead call or only dead users.

The test have been modified to include a side effect where there was
none in order to keep the coverage.

[sstefan1]

Sorry for the delay.

llvm/lib/Transforms/IPO/Attributor.cpp

2856

Few question:

• should isSafeToSpeculativelyExecute also be checked here?
• If we had AASpeculatable this could be replaced with that, right? Or is it better to use this for speculatable deduction?

While I am at it, speculatable could also be used for AAUndefinedBehaviour, rigtht?

Btw, I'll probably start working on speculatable this week.

2906–2911

Shouldn't I always be AssumedSideEffectFree at this point?

3015

typo: separately

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2856

should isSafeToSpeculativelyExecute also be checked here?

I don't think so. We can delete the code if it is side-effect free and has no live users.

If we had AASpeculatable this could be replaced with that, right? Or is it better to use this for speculatable deduction?

So AASpeculatable would derive the speculatable attribute, which allows us and other passes to move code out of control dependences, e.g.,
if (...) do_sth_speculatable(); can become do_sth_speculatable(); if (...) ;

While I am at it, speculatable could also be used for AAUndefinedBehaviour, rigtht?

Let's discuss that on the AAspeculatable patch, I'm not 100% sure right now what you mean.

Btw, I'll probably start working on speculatable this week.

That sounds great!

2906–2911

That's a good point. I'll check why this is here.

[jdoerfert]

Rebase and addressed comments

llvm/lib/Transforms/IPO/Attributor.cpp

2906–2911

It is because we conflate two things here, (1) dead users and (2) no side-effects. The former allows us to drop the returned values even if we have side-effects (for a function/call). I'll added a comment.

[sstefan1]

LGTM

llvm/lib/Transforms/IPO/Attributor.cpp

struct AAIsDeadValueImpl : public AAIsDead {
 
   /// See AAIsDead::isAssumedDead(Instruction *I).
   bool isAssumedDead(const Instruction *I) const override {
     return I == getCtxI() && isAssumedDead();
   }
 
   /// See AAIsDead::isKnownDead(Instruction *I).
   bool isKnownDead(const Instruction *I) const override {
-    return I == getCtxI() && getKnown();
+    return isAssumedDead(I) && getKnown();
   }
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     return isAssumedDead() ? "assumed-dead" : "assumed-live";
   }
-};
-
-struct AAIsDeadFloating : public AAIsDeadValueImpl {
-  AAIsDeadFloating(const IRPosition &IRP) : AAIsDeadValueImpl(IRP) {}
 
-  /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
-    if (Instruction *I = dyn_cast<Instruction>(&getAssociatedValue()))
-      if (!wouldInstructionBeTriviallyDead(I))
-        indicatePessimisticFixpoint();
-    if (isa<UndefValue>(getAssociatedValue()))
-      indicatePessimisticFixpoint();
-  }
-
-  /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override {
+  /// Check if all uses are assumed dead.
+  bool areAllUsesAssumedDead(Attributor &A) {
     auto UsePred = [&](const Use &U, bool &Follow) {
       Instruction *UserI = cast<Instruction>(U.getUser());
       if (CallSite CS = CallSite(UserI)) {
         if (!CS.isArgOperand(&U))
           return false;
         const IRPosition &CSArgPos =
             IRPosition::callsite_argument(CS, CS.getArgumentNo(&U));
         const auto &CSArgIsDead = A.getAAFor<AAIsDead>(*this, CSArgPos);
         return CSArgIsDead.isAssumedDead();
       }
       if (ReturnInst *RI = dyn_cast<ReturnInst>(UserI)) {
         const IRPosition &RetPos = IRPosition::returned(*RI->getFunction());
         const auto &RetIsDeadAA = A.getAAFor<AAIsDead>(*this, RetPos);
         return RetIsDeadAA.isAssumedDead();
       }
       Follow = true;
       return wouldInstructionBeTriviallyDead(UserI);
     };
 
-    if (!A.checkForAllUses(UsePred, *this, getAssociatedValue()))
+    return A.checkForAllUses(UsePred, *this, getAssociatedValue());
+  }
+
+  /// Determine if \p I is assumed to be side-effect free.
+  bool isAssumedSideEffectFree(Attributor &A, Instruction *I) {
+    if (!I || wouldInstructionBeTriviallyDead(I))
+      return true;
+
+    auto *CB = dyn_cast<CallBase>(I);
+    if (!CB || isa<IntrinsicInst>(CB))
+      return false;
+
+    const IRPosition &CallIRP = IRPosition::callsite_function(*CB);
+    const auto &NoUnwindAA = A.getAAFor<AANoUnwind>(*this, CallIRP);
+    if (!NoUnwindAA.isAssumedNoUnwind())
+      return false;
+
+    const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(*this, CallIRP);
+    if (!MemBehaviorAA.isAssumedReadOnly())
+      return false;
+
+    return true;
+  }
+};
+
+struct AAIsDeadFloating : public AAIsDeadValueImpl {
+  AAIsDeadFloating(const IRPosition &IRP) : AAIsDeadValueImpl(IRP) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    if (isa<UndefValue>(getAssociatedValue())) {
+      indicatePessimisticFixpoint();
+      return;
+    }
+
+    Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
+    if (!isAssumedSideEffectFree(A, I))
+      indicatePessimisticFixpoint();
+  }
+
+  /// See AbstractAttribute::updateImpl(...).
+  ChangeStatus updateImpl(Attributor &A) override {
+    Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
+    if (!isAssumedSideEffectFree(A, I))
+      return indicatePessimisticFixpoint();
+
+    if (!areAllUsesAssumedDead(A))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     Value &V = getAssociatedValue();
-    if (auto *I = dyn_cast<Instruction>(&V))
-      if (wouldInstructionBeTriviallyDead(I)) {
+    if (auto *I = dyn_cast<Instruction>(&V)) {
+      // If we get here we basically know the users are all dead. We check if
+      // isAssumedSideEffectFree returns true here again because it might not be
+      // the case and only the users are dead but the instruction (=call) is
+      // still needed.
+      if (isAssumedSideEffectFree(A, I) && !isa<InvokeInst>(I)) {
         A.deleteAfterManifest(*I);
         return ChangeStatus::CHANGED;
       }
-
+    }
     if (V.use_empty())
       return ChangeStatus::UNCHANGED;
 
     UndefValue &UV = *UndefValue::get(V.getType());
     bool AnyChange = A.changeValueAfterManifest(V, UV);
     return AnyChange ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
   }
 
if (A.changeUseAfterManifest(U, UV))
       return ChangeStatus::CHANGED;
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(IsDead) }
 };
 
+struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
+  AAIsDeadCallSiteReturned(const IRPosition &IRP)
+      : AAIsDeadFloating(IRP), IsAssumedSideEffectFree(true) {}
+
+  /// See AAIsDead::isAssumedDead().
+  bool isAssumedDead() const override {
+    return AAIsDeadFloating::isAssumedDead() && IsAssumedSideEffectFree;
+  }
+
+  /// Return true if all users are assumed dead.
+  bool hasOnlyAssumedDeadUses() const { return getAssumed(); }
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    if (isa<UndefValue>(getAssociatedValue())) {
+      indicatePessimisticFixpoint();
+      return;
+    }
+
+    // We track this separately as a secondary state.
+    IsAssumedSideEffectFree = isAssumedSideEffectFree(A, getCtxI());
+  }
+
+  /// See AbstractAttribute::updateImpl(...).
+  ChangeStatus updateImpl(Attributor &A) override {
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+    if (IsAssumedSideEffectFree && !isAssumedSideEffectFree(A, getCtxI())) {
+      IsAssumedSideEffectFree = false;
+      Changed = ChangeStatus::CHANGED;
+    }
+
+    if (!areAllUsesAssumedDead(A))
+      return indicatePessimisticFixpoint();
+    return Changed;
+  }
+
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    if (auto *CI = dyn_cast<CallInst>(&getAssociatedValue()))
+      if (CI->isMustTailCall())
+        return ChangeStatus::UNCHANGED;
+    return AAIsDeadFloating::manifest(A);
+  }
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {
+    if (IsAssumedSideEffectFree)
+      STATS_DECLTRACK_CSRET_ATTR(IsDead)
+    else
+      STATS_DECLTRACK_CSRET_ATTR(UnusedResult)
+  }
+
+  /// See AbstractAttribute::getAsStr().
+  const std::string getAsStr() const override {
+    return isAssumedDead()
+               ? "assumed-dead"
+               : (getAssumed() ? "assumed-dead-users" : "assumed-live");
+  }
+
+private:
+  bool IsAssumedSideEffectFree;
+};
+
 struct AAIsDeadReturned : public AAIsDeadValueImpl {
   AAIsDeadReturned(const IRPosition &IRP) : AAIsDeadValueImpl(IRP) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
 
     bool AllKnownDead = true;
     auto PredForCallSite = [&](AbstractCallSite ACS) {
       if (ACS.isCallbackCall())
         return false;
       const IRPosition &CSRetPos =
           IRPosition::callsite_returned(ACS.getCallSite());
       const auto &RetIsDeadAA = A.getAAFor<AAIsDead>(*this, CSRetPos);
       AllKnownDead &= RetIsDeadAA.isKnownDead();
-      return RetIsDeadAA.isAssumedDead();
+      return static_cast<const AAIsDeadCallSiteReturned &>(RetIsDeadAA)
+          .hasOnlyAssumedDeadUses();
     };
 
     bool AllCallSitesKnown;
     if (!A.checkForAllCallSites(PredForCallSite, *this, true,
                                 AllCallSitesKnown))
       return indicatePessimisticFixpoint();
 
     if (AllCallSitesKnown && AllKnownDead)
ChangeStatus manifest(Attributor &A) override {
     A.checkForAllInstructions(RetInstPred, *this, {Instruction::Ret});
     return AnyChange ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(IsDead) }
 };
 
-struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
-  AAIsDeadCallSiteReturned(const IRPosition &IRP) : AAIsDeadFloating(IRP) {}
-
-  /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {}
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(IsDead) }
-};
-
 struct AAIsDeadFunction : public AAIsDead {
   AAIsDeadFunction(const IRPosition &IRP) : AAIsDead(IRP) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     const Function *F = getAssociatedFunction();
     if (F && !F->isDeclaration()) {
       ToBeExploredFrom.insert(&F->getEntryBlock().front());
if (Arg.getType()->isPointerTy()) {
 
       // Every argument with pointer type might be privatizable (or promotable)
       getOrCreateAAFor<AAPrivatizablePtr>(ArgPos);
     }
   }
 
   auto CallSitePred = [&](Instruction &I) -> bool {
     CallSite CS(&I);
+    IRPosition CSRetPos = IRPosition::callsite_returned(CS);
+
+    // Call sites might be dead if they do not have side effects and no live
+    // users. The return value might be dead if there are no live users.
+    getOrCreateAAFor<AAIsDead>(CSRetPos);
+
     if (Function *Callee = CS.getCalledFunction()) {
       // Skip declerations except if annotations on their call sites were
       // explicitly requested.
       if (!AnnotateDeclarationCallSites && Callee->isDeclaration() &&
           !Callee->hasMetadata(LLVMContext::MD_callback))
         return true;
 
       if (!Callee->getReturnType()->isVoidTy() && !CS->use_empty()) {
 
         IRPosition CSRetPos = IRPosition::callsite_returned(CS);
 
-        // Call site return values might be dead.
-        getOrCreateAAFor<AAIsDead>(CSRetPos);
-
         // Call site return integer values might be limited by a constant range.
-        if (Callee->getReturnType()->isIntegerTy()) {
+        if (Callee->getReturnType()->isIntegerTy())
           getOrCreateAAFor<AAValueConstantRange>(CSRetPos);
-        }
-      }
 
       for (int i = 0, e = CS.getNumArgOperands(); i < e; i++) {
 
         IRPosition CSArgPos = IRPosition::callsite_argument(CS, i);
 
         // Every call site argument might be dead.
         getOrCreateAAFor<AAIsDead>(CSArgPos);
 

llvm/test/Transforms/Attributor/ArgumentPromotion/dbg.ll

;
   call void @sink(i32 %2)
   ret void
 }
 
 %struct.pair = type { i32, i32 }
 
 define internal void @test_byval(%struct.pair* byval %P) {
 ; CHECK-LABEL: define {{[^@]+}}@test_byval()
+; CHECK-NEXT:    call void @sink(i32 0)
 ; CHECK-NEXT:    ret void
 ;
+  call void @sink(i32 0)
   ret void
 }
 
 define void @caller(i32** %Y, %struct.pair* %P) {
 ; CHECK-LABEL: define {{[^@]+}}@caller
 ; CHECK-SAME: (i32** nocapture readonly [[Y:%.*]], %struct.pair* nocapture nofree readonly [[P:%.*]])
 ; CHECK-NEXT:    call void @test(i32** nocapture readonly align 8 [[Y]]), !dbg !4
 ; CHECK-NEXT:    call void @test_byval(), !dbg !5

llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll

entry:
   ret i32 0
 }
 
 ; Function Attrs: nounwind uwtable
 define internal void @callee_t0f(i8* nocapture readnone %tp13, i8* nocapture readnone %tp14, i8* nocapture readnone %tp15, i8* nocapture readnone %tp16, i8* nocapture readnone %tp17, ...) {
 ; CHECK-LABEL: define {{[^@]+}}@callee_t0f
 ; CHECK-SAME: (i8* noalias nocapture nofree nonnull readnone [[TP13:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP14:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP15:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP16:%.*]], i8* noalias nocapture nofree nonnull readnone [[TP17:%.*]], ...)
 ; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @sink(i32 0)
 ; CHECK-NEXT:    ret void
 ;
 entry:
+  call void @sink(i32 0)
   ret void
 }
+
+declare void @sink(i32)

llvm/test/Transforms/Attributor/IPConstantProp/multiple_callbacks.ll

 entry:
   ret i32 %unknown
 }
 
 define internal i32 @cb2(i32 %unknown) {
 ; CHECK-LABEL: define {{[^@]+}}@cb2
 ; CHECK-SAME: (i32 returned [[UNKNOWN:%.*]])
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @cb0(i32 0)
 ; CHECK-NEXT:    ret i32 [[UNKNOWN]]
 ;
 entry:
   %call = call i32 @cb0(i32 0)
   ret i32 %unknown
 }
 
 define internal i32 @cb3(i32 %unknown) {

 ;
 entry:
   ret i32 %unknown
 }
 
 define void @foo() {
 ; CHECK-LABEL: define {{[^@]+}}@foo()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @cb0(i32 0)
-; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @cb3(i32 1)
 ; CHECK-NEXT:    call void @broker(i32 (i32)* nonnull @cb0, i32 (i32)* nonnull @cb1, i32 (i32)* nonnull @cb0, i32 0, i32 1)
 ; CHECK-NEXT:    call void @broker(i32 (i32)* nonnull @cb1, i32 (i32)* nonnull @cb2, i32 (i32)* nonnull @cb2, i32 0, i32 1)
 ; CHECK-NEXT:    call void @broker(i32 (i32)* nonnull @cb3, i32 (i32)* nonnull @cb2, i32 (i32)* nonnull @cb3, i32 0, i32 1)
 ; CHECK-NEXT:    call void @broker(i32 (i32)* nonnull @cb4, i32 (i32)* nonnull @cb4, i32 (i32)* nonnull @cb4, i32 0, i32 1)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %call = call i32 @cb0(i32 0)

llvm/test/Transforms/Attributor/align.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes --turn off
-; RUN: opt -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_MODULE
-; RUN: opt -attributor-cgscc -attributor-manifest-internal -attributor-disable=false -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_CGSCC
-; RUN: opt -passes=attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_MODULE
-; RUN: opt -passes=attributor-cgscc -attributor-manifest-internal -attributor-disable=false -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_CGSCC
+; RUN: opt -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_MODULE
+; RUN: opt -attributor-cgscc -attributor-manifest-internal -attributor-disable=false -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_CGSCC
+; RUN: opt -passes=attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_MODULE
+; RUN: opt -passes=attributor-cgscc -attributor-manifest-internal -attributor-disable=false -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=ATTRIBUTOR,ATTRIBUTOR_CGSCC
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Test cases specifically designed for "align" attribute.
 ; We use FIXME's to indicate problems and missing attributes.
 
 
 ; TEST 1
; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
   ret i8* %6
 }
 
 ; UTC_ARGS: --enable
 
 ; TEST 7
 ; Better than IR information
-define align 4 i32* @test7(i32* align 32 %p) #0 {
+define align 4 i8* @test7() #0 {
 ; ATTRIBUTOR_MODULE-LABEL: define {{[^@]+}}@test7
-; ATTRIBUTOR_MODULE-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]])
-; ATTRIBUTOR_MODULE-NEXT:    ret i32* [[P]]
+; ATTRIBUTOR_MODULE-NEXT:    [[C:%.*]] = tail call i8* @f1(i8* noalias nofree nonnull readnone align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR_MODULE-NEXT:    ret i8* [[C]]
 ;
 ; ATTRIBUTOR_CGSCC-LABEL: define {{[^@]+}}@test7
-; ATTRIBUTOR_CGSCC-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]])
-; ATTRIBUTOR_CGSCC-NEXT:    [[TMP1:%.*]] = tail call i8* @f1(i8* noalias nofree nonnull readnone align 8 dereferenceable(1) @a1)
-; ATTRIBUTOR_CGSCC-NEXT:    ret i32* [[P]]
+; ATTRIBUTOR_CGSCC-SAME: ()
+; ATTRIBUTOR_CGSCC-NEXT:    [[C:%.*]] = tail call nonnull align 8 dereferenceable(1) i8* @f1(i8* noalias nofree nonnull readnone align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR_CGSCC-NEXT:    ret i8* [[C]]
 ;
-  tail call i8* @f1(i8* align 8 dereferenceable(1) @a1)
-  ret i32* %p
+  %c = tail call i8* @f1(i8* align 8 dereferenceable(1) @a1)
+  ret i8* %c
 }
 
 ; TEST 7b
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f1b(i8* readnone %0) local_unnamed_addr #0 {
 ; ATTRIBUTOR_MODULE-LABEL: define {{[^@]+}}@f1b
 ; ATTRIBUTOR_MODULE-SAME: (i8* noalias nofree nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr
 ; ATTRIBUTOR_MODULE-NEXT:    [[TMP2:%.*]] = icmp eq i8* [[TMP0]], null

 ; ATTRIBUTOR: tail call void @test8(i32* noalias readnone align 4 %ptr1, i32* noalias readnone align 4 %ptr1, i32* noalias readnone %ptr0)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
 ; ATTRIBUTOR: tail call void @test8(i32* noalias readnone align 8 %ptr2, i32* noalias readnone align 4 %ptr1, i32* noalias readnone align 4 %ptr1)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
 ; ATTRIBUTOR: tail call void @test8(i32* noalias readnone align 8 %ptr2, i32* noalias readnone align 4 %ptr1, i32* noalias readnone align 4 %ptr1)
   ret void
 }
 
-declare void @user_i32_ptr(i32*) readnone nounwind
+declare void @user_i32_ptr(i32* nocapture readnone) nounwind
 define internal void @test8(i32* %a, i32* %b, i32* %c) {
 ; ATTRIBUTOR_MODULE: define internal void @test8(i32* noalias nocapture readnone align 4 %a, i32* noalias nocapture readnone align 4 %b, i32* noalias nocapture readnone %c)
 ; ATTRIBUTOR_CGSCC: define internal void @test8(i32* nocapture readnone align 4 %a, i32* nocapture readnone align 4 %b, i32* nocapture readnone %c)
   call void @user_i32_ptr(i32* %a)
   call void @user_i32_ptr(i32* %b)
   call void @user_i32_ptr(i32* %c)
   ret void
 }

llvm/test/Transforms/Attributor/liveness.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt -attributor --attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,MODULE,ALL_BUT_OLD_CGSCCC
 ; RUN: opt -attributor-cgscc --attributor-disable=false -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
 ; RUN: opt -passes=attributor --attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,MODULE,ALL_BUT_OLD_CGSCCC
 ; RUN: opt -passes='attributor-cgscc' --attributor-disable=false -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC,ALL_BUT_OLD_CGSCCC
 ; UTC_ARGS: --disable
 
 ; ALL_BUT_OLD_CGSCCC: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
 @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
 
-declare void @no_return_call() nofree noreturn nounwind readnone
+declare void @no_return_call() nofree noreturn nounwind nosync
 
 declare void @normal_call() readnone
 
 declare i32 @foo()
 
 declare i32 @foo_nounwind() nounwind
 
 declare i32 @foo_noreturn_nounwind() noreturn nounwind

 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
   ret i8* %6
 }
 
 declare void @sink() nofree nosync nounwind willreturn
 define void @test_unreachable() {
 ; CHECK:       define void @test_unreachable()
+; CHECK-NEXT:    call void @sink()
 ; CHECK-NEXT:    call void @test_unreachable()
 ; CHECK-NEXT:    unreachable
 ; CHECK-NEXT:  }
+  call void @sink()
   call void @test_unreachable()
   unreachable
 }
 
 define linkonce_odr void @non_exact1() {
   call void @non_dead_a0()
   call void @non_dead_a1()
   call void @non_dead_a2()

 ; CHECK-NEXT:   call void @non_dead_d11()
 ; CHECK-NEXT:   call void @non_dead_d12()
 ; CHECK-NEXT:   call void @non_dead_d13()
 ; CHECK-NEXT:   call void @non_dead_d14()
 ; CHECK-NEXT:   call void @non_dead_d15()
 ; CHECK-NEXT:   %nr = call i32 @foo_noreturn()
 ; CHECK-NEXT:   unreachable
 
-define internal void @non_dead_a0() { ret void }
-define internal void @non_dead_a1() { ret void }
-define internal void @non_dead_a2() { ret void }
-define internal void @non_dead_a3() { ret void }
-define internal void @non_dead_a4() { ret void }
-define internal void @non_dead_a5() { ret void }
-define internal void @non_dead_a6() { ret void }
-define internal void @non_dead_a7() { ret void }
-define internal void @non_dead_a8() { ret void }
-define internal void @non_dead_a9() { ret void }
-define internal void @non_dead_a10() { ret void }
-define internal void @non_dead_a11() { ret void }
-define internal void @non_dead_a12() { ret void }
-define internal void @non_dead_a13() { ret void }
-define internal void @non_dead_a14() { ret void }
-define internal void @non_dead_a15() { ret void }
-define internal void @non_dead_b0() { ret void }
-define internal void @non_dead_b1() { ret void }
-define internal void @non_dead_b2() { ret void }
-define internal void @non_dead_b3() { ret void }
-define internal void @non_dead_b4() { ret void }
-define internal void @non_dead_b5() { ret void }
-define internal void @non_dead_b6() { ret void }
-define internal void @non_dead_b7() { ret void }
-define internal void @non_dead_b8() { ret void }
-define internal void @non_dead_b9() { ret void }
-define internal void @non_dead_b10() { ret void }
-define internal void @non_dead_b11() { ret void }
-define internal void @non_dead_b12() { ret void }
-define internal void @non_dead_b13() { ret void }
-define internal void @non_dead_b14() { ret void }
-define internal void @non_dead_b15() { ret void }
-define internal void @non_dead_c0() { ret void }
-define internal void @non_dead_c1() { ret void }
-define internal void @non_dead_c2() { ret void }
-define internal void @non_dead_c3() { ret void }
-define internal void @non_dead_c4() { ret void }
-define internal void @non_dead_c5() { ret void }
-define internal void @non_dead_c6() { ret void }
-define internal void @non_dead_c7() { ret void }
-define internal void @non_dead_c8() { ret void }
-define internal void @non_dead_c9() { ret void }
-define internal void @non_dead_c10() { ret void }
-define internal void @non_dead_c11() { ret void }
-define internal void @non_dead_c12() { ret void }
-define internal void @non_dead_c13() { ret void }
-define internal void @non_dead_c14() { ret void }
-define internal void @non_dead_c15() { ret void }
-define internal void @non_dead_d0() { ret void }
-define internal void @non_dead_d1() { ret void }
-define internal void @non_dead_d2() { ret void }
-define internal void @non_dead_d3() { ret void }
-define internal void @non_dead_d4() { ret void }
-define internal void @non_dead_d5() { ret void }
-define internal void @non_dead_d6() { ret void }
-define internal void @non_dead_d7() { ret void }
-define internal void @non_dead_d8() { ret void }
-define internal void @non_dead_d9() { ret void }
-define internal void @non_dead_d10() { ret void }
-define internal void @non_dead_d11() { ret void }
-define internal void @non_dead_d12() { ret void }
-define internal void @non_dead_d13() { ret void }
-define internal void @non_dead_d14() { ret void }
-define internal void @non_dead_d15() { ret void }
+define internal void @non_dead_a0() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a1() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a2() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a3() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a4() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a5() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a6() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a7() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a8() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a9() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a10() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a11() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a12() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a13() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a14() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_a15() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b0() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b1() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b2() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b3() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b4() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b5() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b6() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b7() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b8() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b9() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b10() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b11() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b12() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b13() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b14() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_b15() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c0() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c1() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c2() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c3() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c4() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c5() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c6() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c7() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c8() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c9() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c10() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c11() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c12() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c13() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c14() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_c15() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d0() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d1() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d2() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d3() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d4() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d5() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d6() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d7() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d8() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d9() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d10() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d11() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d12() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d13() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d14() {
+  call void @sink()
+  ret void
+}
+define internal void @non_dead_d15() {
+  call void @sink()
+  ret void
+}
 define internal void @dead_e0() { call void @dead_e1() ret void }
 define internal void @dead_e1() { call void @dead_e2() ret void }
 define internal void @dead_e2() { ret void }
 
 ; CHECK: define internal void @non_dead_a0()
 ; CHECK: define internal void @non_dead_a1()
 ; CHECK: define internal void @non_dead_a2()
 ; CHECK: define internal void @non_dead_a3()

 ; CHECK: define internal void @non_dead_d8()
 ; CHECK: define internal void @non_dead_d9()
 ; CHECK: define internal void @non_dead_d10()
 ; CHECK: define internal void @non_dead_d11()
 ; CHECK: define internal void @non_dead_d12()
 ; CHECK: define internal void @non_dead_d13()
 ; CHECK: define internal void @non_dead_d14()
 ; Verify we actually deduce information for these functions.
-; MODULE: Function Attrs: nofree nosync nounwind readnone willreturn
+; MODULE: Function Attrs: nofree nosync nounwind willreturn
 ; MODULE-NEXT: define internal void @non_dead_d15()
 ; MODULE-NOT: define internal void @dead_e
-; CGSCC: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; CGSCC: Function Attrs: nofree nosync nounwind willreturn
 ; CGSCC-NEXT: define internal void @non_dead_d15()
 
 declare void @blowup() noreturn
 define void @live_with_dead_entry() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK:      define void @live_with_dead_entry(
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   invoke void @blowup()
 ; CHECK-NEXT:           to label %live_with_dead_entry.dead unwind label %lpad
lp2:
   br label %live_with_dead_entry
 live_with_dead_entry:
   ret void
 }
 
 ; MODULE: define internal void @useless_arg_sink()
 ; CGSCC: define internal void @useless_arg_sink(i32*{{.*}} %a)
 define internal void @useless_arg_sink(i32* %a) {
+  call void @sink()
   ret void
 }
 
 ; MODULE: define internal void @useless_arg_almost_sink()
 ; CGSCC: define internal void @useless_arg_almost_sink(i32*{{.*}} %a)
 define internal void @useless_arg_almost_sink(i32* %a) {
 ; MODULE: call void @useless_arg_sink()
-; CGSCC: call void @useless_arg_sink(i32* noalias nofree readnone %a)
+; CGSCC: call void @useless_arg_sink(i32* noalias nocapture nofree readnone %a)
   call void @useless_arg_sink(i32* %a)
   ret void
 }
 
 ; Check we do not annotate the function interface of this weak function.
 ; CHECK: define weak_odr void @useless_arg_ext(i32* %a)
 define weak_odr void @useless_arg_ext(i32* %a) {
 ; MODULE: call void @useless_arg_almost_sink()

llvm/test/Transforms/Attributor/misc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt -S -attributor -attributor-disable=false < %s | FileCheck %s --check-prefixes=ALL,CHECK
 ; RUN: opt -S -aa-pipeline='basic-aa' -passes=attributor -attributor-disable=false -attributor-annotate-decl-cs < %s | FileCheck %s --check-prefixes=ALL,DECL_CS
 ;
 ; Mostly check we do not crash on these uses
 
 define internal void @internal(void (i8*)* %fp) {
 ; CHECK-LABEL: define {{[^@]+}}@internal
 ; CHECK-SAME: (void (i8*)* [[FP:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; CHECK-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
+; CHECK-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; CHECK-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; CHECK-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; CHECK-NEXT:    call void @callback2(void (i8*)* bitcast (void (i32*)* @foo to void (i8*)*))
 ; CHECK-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; CHECK-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; CHECK-NEXT:    ret void
 ;
 ; DECL_CS-LABEL: define {{[^@]+}}@internal
 ; DECL_CS-SAME: (void (i8*)* [[FP:%.*]])
 ; DECL_CS-NEXT:  entry:
 ; DECL_CS-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; DECL_CS-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; DECL_CS-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
+; DECL_CS-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; DECL_CS-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; DECL_CS-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* nonnull bitcast (void (i32*)* @foo to void (i8*)*))
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; DECL_CS-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; DECL_CS-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; DECL_CS-NEXT:    ret void
 ;

 }
 
 define void @external(void (i8*)* %fp) {
 ; CHECK-LABEL: define {{[^@]+}}@external
 ; CHECK-SAME: (void (i8*)* [[FP:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; CHECK-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
+; CHECK-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; CHECK-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; CHECK-NEXT:    call void @callback2(void (i8*)* bitcast (void (i32*)* @foo to void (i8*)*))
 ; CHECK-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; CHECK-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; CHECK-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; CHECK-NEXT:    call void @internal(void (i8*)* [[FP]])
 ; CHECK-NEXT:    ret void
 ;
 ; DECL_CS-LABEL: define {{[^@]+}}@external
 ; DECL_CS-SAME: (void (i8*)* [[FP:%.*]])
 ; DECL_CS-NEXT:  entry:
 ; DECL_CS-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; DECL_CS-NEXT:    [[TMP:%.*]] = bitcast i32* [[A]] to i8*
-; DECL_CS-NEXT:    call void @foo(i32* noalias nofree nonnull readnone align 4 dereferenceable(4) undef)
+; DECL_CS-NEXT:    call void @foo(i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[A]])
 ; DECL_CS-NEXT:    call void @callback1(void (i32*)* nonnull @foo)
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* nonnull bitcast (void (i32*)* @foo to void (i8*)*))
 ; DECL_CS-NEXT:    call void @callback2(void (i8*)* [[FP]])
 ; DECL_CS-NEXT:    call void [[FP]](i8* bitcast (void (i32*)* @foo to i8*))
 ; DECL_CS-NEXT:    [[TMP1:%.*]] = bitcast i32* [[A]] to i8*
 ; DECL_CS-NEXT:    call void [[FP]](i8* [[TMP1]])
 ; DECL_CS-NEXT:    call void @internal(void (i8*)* [[FP]])
 ; DECL_CS-NEXT:    ret void
entry:
   %tmp1 = bitcast i32* %a to i8*
   call void %fp(i8* %tmp1)
   call void @internal(void (i8*)* %fp)
   ret void
 }
 
 define internal void @foo(i32* %a) {
 ; ALL-LABEL: define {{[^@]+}}@foo
-; ALL-SAME: (i32* nocapture nofree readnone [[A:%.*]])
+; ALL-SAME: (i32* nocapture nofree nonnull writeonly dereferenceable(4) [[A:%.*]])
 ; ALL-NEXT:  entry:
+; ALL-NEXT:    store i32 0, i32* %a
 ; ALL-NEXT:    ret void
 ;
 entry:
+  store i32 0, i32* %a
   ret void
 }
 
 declare void @callback1(void (i32*)*)
 declare void @callback2(void (i8*)*)

llvm/test/Transforms/Attributor/noalias.ll

5:                                                ; preds = %1, %4
   ret i8* %2
 }
 
 ; TEST 9
 ; Simple Argument Test
 declare void @use_i8(i8* nocapture)
 define internal void @test9a(i8* %a, i8* %b) {
 ; CHECK: define internal void @test9a()
+  call void @use_i8(i8* null)
   ret void
 }
 define internal void @test9b(i8* %a, i8* %b) {
 ; FIXME: %b should be noalias
 ; CHECK: define internal void @test9b(i8* noalias nocapture %a, i8* nocapture %b)
   call void @use_i8(i8* %a)
   call void @use_i8(i8* %b)
   ret void

llvm/test/Transforms/Attributor/nonnull.ll

 declare i8* @unknown()
 define void @test13_helper() {
   %nonnullptr = tail call i8* @ret_nonnull()
   %maybenullptr = tail call i8* @unknown()
   tail call void @test13(i8* %nonnullptr, i8* %nonnullptr, i8* %maybenullptr)
   tail call void @test13(i8* %nonnullptr, i8* %maybenullptr, i8* %nonnullptr)
   ret void
 }
-declare void @use_i8_ptr(i8* nofree) readnone nounwind
+declare void @use_i8_ptr(i8* nofree nocapture readnone) nounwind
 define internal void @test13(i8* %a, i8* %b, i8* %c) {
 ; ATTRIBUTOR: define internal void @test13(i8* noalias nocapture nofree nonnull readnone %a, i8* noalias nocapture nofree readnone %b, i8* noalias nocapture nofree readnone %c)
   call void @use_i8_ptr(i8* %a)
   call void @use_i8_ptr(i8* %b)
   call void @use_i8_ptr(i8* %c)
   ret void
 }
 

 
 ; ATTRIBUTOR: define nonnull align 4 i32* @g1()
 ; ATTRIBUTOR:   ret i32* inttoptr (i64 4 to i32*)
 define i32* @g1() {
  %c = call i32* @g2()
   ret i32* %c
 }
 
-declare void @use_i32_ptr(i32*) readnone nounwind
+declare void @use_i32_ptr(i32* readnone nocapture) nounwind
 ; ATTRIBUTOR: define internal void @called_by_weak(i32* noalias nocapture nonnull readnone %a)
 define internal void @called_by_weak(i32* %a) {
   call void @use_i32_ptr(i32* %a)
   ret void
 }
 
 ; Check we do not annotate the function interface of this weak function.
 ; ATTRIBUTOR: define weak_odr void @weak_caller(i32* nonnull %a)

llvm/test/Transforms/Attributor/noreturn_async.ll

-; RUN: opt -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s
+; RUN: opt -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s
 ;
 ; This file is the same as noreturn_sync.ll but with a personality which
 ; indicates that the exception handler *can* catch asynchronous exceptions. As
 ; a consequence, invokes to noreturn and nounwind functions are not translated
 ; to calls followed by an unreachable but the unwind edge is considered live.
 ;
 ; https://reviews.llvm.org/D59978#inline-586873
 ;

 @"?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA" = linkonce_odr dso_local global i64 0, align 8
 
 
 define dso_local void @"?overflow@@YAXXZ"() {
 entry:
 ; CHECK:      Function Attrs: nofree noreturn nosync nounwind
 ; CHECK-NEXT: define
 ; CHECK-NEXT:   entry:
+; CHECK-NEXT:   {{.*}}@printf{{.*}}
 ; CHECK-NEXT:   call void @"?overflow@@YAXXZ"()
 ; CHECK-NEXT:   unreachable
+  %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @"??_C@_0BC@NKPAGFFJ@Exception?5caught?6?$AA@", i64 0, i64 0)) nofree nosync nounwind
   call void @"?overflow@@YAXXZ"()
   %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @"??_C@_0BC@NKPAGFFJ@Exception?5caught?6?$AA@", i64 0, i64 0))
   ret void
 }
 
 
 ; CHECK-NOT:    nounwind
 ; CHECK-NOT:    noreturn

llvm/test/Transforms/Attributor/noreturn_sync.ll

-; RUN: opt -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s
+; RUN: opt -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s
 ;
 ; This file is the same as noreturn_async.ll but with a personality which
 ; indicates that the exception handler *cannot* catch asynchronous exceptions.
 ; As a consequence, invokes to noreturn and nounwind functions are translated
 ; to calls followed by an unreachable.
 ;
 ; https://reviews.llvm.org/D59978#inline-586873
 ;

 @"?_OptionsStorage@?1??__local_stdio_printf_options@@9@4_KA" = linkonce_odr dso_local global i64 0, align 8
 
 
 define dso_local void @"?overflow@@YAXXZ"() {
 entry:
 ; CHECK:      Function Attrs: nofree noreturn nosync nounwind
 ; CHECK-NEXT: define
 ; CHECK-NEXT:   entry:
+; CHECK-NEXT:   {{.*}}@printf{{.*}}
 ; CHECK-NEXT:   call void @"?overflow@@YAXXZ"()
 ; CHECK-NEXT:   unreachable
+  %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @"??_C@_0BC@NKPAGFFJ@Exception?5caught?6?$AA@", i64 0, i64 0)) nofree nosync nounwind
   call void @"?overflow@@YAXXZ"()
   %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @"??_C@_0BC@NKPAGFFJ@Exception?5caught?6?$AA@", i64 0, i64 0))
   ret void
 }
 
 
 ; CHECK:       Function Attrs: nofree noreturn nosync nounwind
 ; CHECK-NEXT:   @"?catchoverflow@@YAHXZ"()

llvm/test/Transforms/Attributor/read_write_returned_arguments_scc.ll

 }
 
 ; Verify that we see only expected attribute sets, the above lines only check
 ; for a subset relation.
 ;
 ; CHECK-NOT: attributes #
 ; CHECK: attributes #{{.*}} = { nofree nosync nounwind }
 ; CHECK: attributes #{{.*}} = { nofree norecurse nosync nounwind }
-; CHECK: attributes #{{.*}} = { nosync }
+; CHECK: attributes #{{.*}} = { nosync nounwind }
 ; CHECK-NOT: attributes #

llvm/test/Transforms/Attributor/willreturn.ll

 ; mutual recursion
 ; void mutual_recursion1(){
 ;    mutual_recursion2();
 ; }
 ; void mutual_recursion2(){
 ;     mutual_recursion1();
 ; }
 
-; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
+declare void @sink() nounwind willreturn nosync nofree
+
+; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 ; ATTRIBUTOR-NOT: willreturn
 ; ATTRIBUTOR-NEXT: define void @mutual_recursion1(i1 %c)
 define void @mutual_recursion1(i1 %c) #0 {
   br i1 %c, label %rec, label %end
 rec:
+  call void @sink()
   call void @mutual_recursion2(i1 %c)
   br label %end
 end:
   ret void
 }
 
 
-; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
+; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 ; ATTRIBUTOR-NOT: willreturn
 ; ATTRIBUTOR-NEXT: define void @mutual_recursion2(i1 %c)
 define void @mutual_recursion2(i1 %c) #0 {
   call void @mutual_recursion1(i1 %c)
   ret void
 }