[Attributor] Conditinoally delete fns

[wsmoses]

Summary

Allow the attributor to delete functions only if requested

[jdoerfert]

Attributor::deleteAfterManifest also needs to be updated or removed (together with the use).

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

1665

Nit: .

llvm/lib/Transforms/IPO/Attributor.cpp

1221

Early exit out of this function if we don't delete, all what is happening here is not necessary then.

[sstefan1]

llvm/test/Transforms/Attributor/nodelete.ll

2

Maybe generate this with update_test_checks.py? I guess it would be easier to update and also for consistency.

[jdoerfert]

llvm/test/Transforms/Attributor/nodelete.ll

2

I missed this. Use the same run lines as other tests and the update test script please.

[wsmoses]

WIP: update code per comments, still needs test fixes

[wsmoses]

Update tests

[wsmoses]

Recreate test using script

[wsmoses]

llvm/test/Transforms/Attributor/nodelete.ll

2

Using the same line as others reveals a similar issue for non cgss mode. Is it preferable to leave those tests disabled for the moment (like below) or to also disable function removal for that mode?

[sstefan1]

llvm/test/Transforms/Attributor/nodelete.ll

2

I guess we should do that while we are at it.

[wsmoses]

Fix attributor nodelete test

[jdoerfert]

LGTM

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

 struct Attributor {
   /// Constructor
   ///
   /// \param Functions The set of functions we are deriving attributes for.
   /// \param InfoCache Cache to hold various information accessible for
   ///                  the abstract attributes.
   /// \param CGUpdater Helper to update an underlying call graph.
   /// \param Allowed If not null, a set limiting the attribute opportunities.
+  /// \param DeleteFns Whether to delete functions
   Attributor(SetVector<Function *> &Functions, InformationCache &InfoCache,
              CallGraphUpdater &CGUpdater,
-             DenseSet<const char *> *Allowed = nullptr)
+             DenseSet<const char *> *Allowed = nullptr, bool DeleteFns = true)
       : Allocator(InfoCache.Allocator), Functions(Functions),
-        InfoCache(InfoCache), CGUpdater(CGUpdater), Allowed(Allowed) {}
+        InfoCache(InfoCache), CGUpdater(CGUpdater), Allowed(Allowed),
+        DeleteFns(DeleteFns) {}
 
   ~Attributor();
 
   /// Run the analyses until a fixpoint is reached or enforced (timeout).
   ///
   /// The attributes registered with this Attributor can be used after as long
   /// as the Attributor is not destroyed (it owns the attributes now).
   ///
struct Attributor {
   /// triggers deletion of trivially dead istructions.
   void deleteAfterManifest(Instruction &I) { ToBeDeletedInsts.insert(&I); }
 
   /// Record that \p BB is deleted after information was manifested. This also
   /// triggers deletion of trivially dead istructions.
   void deleteAfterManifest(BasicBlock &BB) { ToBeDeletedBlocks.insert(&BB); }
 
   /// Record that \p F is deleted after information was manifested.
-  void deleteAfterManifest(Function &F) { ToBeDeletedFunctions.insert(&F); }
+  void deleteAfterManifest(Function &F) {
+    if (DeleteFns)
+      ToBeDeletedFunctions.insert(&F);
+  }
 
   /// If \p V is assumed to be a constant, return it, if it is unclear yet,
   /// return None, otherwise return `nullptr`.
   Optional<Constant *> getAssumedConstant(const Value &V,
                                           const AbstractAttribute &AA,
                                           bool &UsedAssumedInformation);
 
   /// Return true if \p AA (or its context instruction) is assumed dead.
private:
   /// abstract attribute. Since the inner vectors are actually allocated on the
   /// stack we can be generous with their size.
   using DependenceVector = SmallVector<DepInfo, 8>;
   SmallVector<DependenceVector *, 16> DependenceStack;
 
   /// If not null, a set limiting the attribute opportunities.
   const DenseSet<const char *> *Allowed;
 
+  /// Whether to delete functions.
+  const bool DeleteFns;
+
   /// A set to remember the functions we already assume to be live and visited.
   DenseSet<const Function *> VisitedFunctions;
 
   /// Uses we replace with a new value after manifest is done. We will remove
   /// then trivially dead instructions as well.
   DenseMap<Use *, Value *> ToBeChangedUses;
 
   /// Instructions we replace with `unreachable` insts after manifest is done.

llvm/lib/Transforms/IPO/Attributor.cpp

for (unsigned u = NumFinalAAs; u < DG.SyntheticRoot.Deps.size(); ++u)
              << "\n";
     llvm_unreachable("Expected the final number of abstract attributes to "
                      "remain unchanged!");
   }
   return ManifestChange;
 }
 
 void Attributor::identifyDeadInternalFunctions() {
+  // Early exit if we don't intend to delete functions.
+  if (!DeleteFns)
+    return;
+
   // Identify dead internal functions and delete them. This happens outside
   // the other fixpoint analysis as we might treat potentially dead functions
   // as live to lower the number of iterations. If they happen to be dead, the
   // below fixpoint loop will identify and eliminate them.
   SmallVector<Function *, 8> InternalFns;
   for (Function *F : Functions)
     if (F->hasLocalLinkage())
       InternalFns.push_back(F);
for (unsigned u = 0, e = InternalFns.size(); u < e; ++u) {
       InternalFns[u] = nullptr;
       FoundLiveInternal = true;
     }
   }
 
   for (unsigned u = 0, e = InternalFns.size(); u < e; ++u)
     if (Function *F = InternalFns[u])
       ToBeDeletedFunctions.insert(F);
 }
 
 ChangeStatus Attributor::cleanupIR() {
   TimeTraceScope TimeScope("Attributor::cleanupIR");
   // Delete stuff at the end to avoid invalid references and a nice order.
   LLVM_DEBUG(dbgs() << "\n[Attributor] Delete at least "
                     << ToBeDeletedFunctions.size() << " functions and "
                     << ToBeDeletedBlocks.size() << " blocks and "
                     << ToBeDeletedInsts.size() << " instructions and "

 
 /// ----------------------------------------------------------------------------
 ///                       Pass (Manager) Boilerplate
 /// ----------------------------------------------------------------------------
 
 static bool runAttributorOnFunctions(InformationCache &InfoCache,
                                      SetVector<Function *> &Functions,
                                      AnalysisGetter &AG,
-                                     CallGraphUpdater &CGUpdater) {
+                                     CallGraphUpdater &CGUpdater,
+                                     bool DeleteFns) {
   if (Functions.empty())
     return false;
 
   LLVM_DEBUG(dbgs() << "[Attributor] Run on module with " << Functions.size()
                     << " functions.\n");
 
   // Create an Attributor and initially empty information cache that is filled
   // while we identify default attribute opportunities.
-  Attributor A(Functions, InfoCache, CGUpdater);
+  Attributor A(Functions, InfoCache, CGUpdater, /* Allowed */ nullptr,
+               DeleteFns);
 
   // Create shallow wrappers for all functions that are not IPO amendable
   if (AllowShallowWrappers)
     for (Function *F : Functions)
       if (!A.isFunctionIPOAmendable(*F))
         Attributor::createShallowWrapper(*F);
 
   // Internalize non-exact functions
PreservedAnalyses AttributorPass::run(Module &M, ModuleAnalysisManager &AM) {
 
   SetVector<Function *> Functions;
   for (Function &F : M)
     Functions.insert(&F);
 
   CallGraphUpdater CGUpdater;
   BumpPtrAllocator Allocator;
   InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ nullptr);
-  if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater)) {
+  if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater,
+                               /* DeleteFns */ true)) {
     // FIXME: Think about passes we will preserve and add them here.
     return PreservedAnalyses::none();
   }
   return PreservedAnalyses::all();
 }
 
 PreservedAnalyses AttributorCGSCCPass::run(LazyCallGraph::SCC &C,
                                            CGSCCAnalysisManager &AM,
PreservedAnalyses AttributorCGSCCPass::run(LazyCallGraph::SCC &C,
   if (Functions.empty())
     return PreservedAnalyses::all();
 
   Module &M = *Functions.back()->getParent();
   CallGraphUpdater CGUpdater;
   CGUpdater.initialize(CG, C, AM, UR);
   BumpPtrAllocator Allocator;
   InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ &Functions);
-  if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater)) {
+  if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater,
+                               /* DeleteFns */ false)) {
     // FIXME: Think about passes we will preserve and add them here.
     PreservedAnalyses PA;
     PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
     return PA;
   }
   return PreservedAnalyses::all();
 }
 
bool runOnModule(Module &M) override {
     AnalysisGetter AG;
     SetVector<Function *> Functions;
     for (Function &F : M)
       Functions.insert(&F);
 
     CallGraphUpdater CGUpdater;
     BumpPtrAllocator Allocator;
     InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ nullptr);
-    return runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater);
+    return runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater,
+                                    /* DeleteFns*/ true);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     // FIXME: Think about passes we will preserve and add them here.
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 };
 
bool runOnSCC(CallGraphSCC &SCC) override {
 
     AnalysisGetter AG;
     CallGraph &CG = const_cast<CallGraph &>(SCC.getCallGraph());
     CallGraphUpdater CGUpdater;
     CGUpdater.initialize(CG, SCC);
     Module &M = *Functions.back()->getParent();
     BumpPtrAllocator Allocator;
     InformationCache InfoCache(M, AG, Allocator, /* CGSCC */ &Functions);
-    return runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater);
+    return runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater,
+                                    /* DeleteFns */ false);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     // FIXME: Think about passes we will preserve and add them here.
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     CallGraphSCCPass::getAnalysisUsage(AU);
   }
 };

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -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
 ; 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
 
 
 define internal void @dead() {
+; IS__CGSCC____-LABEL: define {{[^@]+}}@dead() {
+; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = call i32 @test(i32* noalias noundef align 536870912 null)
+; IS__CGSCC____-NEXT:    ret void
+;
   call i32 @test(i32* null, i32* null)
   ret void
 }
 
 define internal i32 @test(i32* %X, i32* %Y) {
 ; IS__CGSCC_OPM: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test
-; IS__CGSCC_OPM-SAME: (i32* noalias nocapture nofree noundef writeonly align 4 [[X:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_OPM-SAME: (i32* noalias nocapture nofree noundef writeonly align 4 [[X:%.*]]) #[[ATTR0:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; IS__CGSCC_OPM:       live:
 ; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[X]], align 4
 ; IS__CGSCC_OPM-NEXT:    ret i32 undef
 ; IS__CGSCC_OPM:       dead:
 ; IS__CGSCC_OPM-NEXT:    unreachable
 ;
 ; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test
-; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[X:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef writeonly align 4 [[X:%.*]]) #[[ATTR0:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; IS__CGSCC_NPM:       live:
 ; IS__CGSCC_NPM-NEXT:    store i32 0, i32* [[X]], align 4
 ; IS__CGSCC_NPM-NEXT:    ret i32 undef
 ; IS__CGSCC_NPM:       dead:
 ; IS__CGSCC_NPM-NEXT:    unreachable
 ;
   br i1 true, label %live, label %dead
 live:
   store i32 0, i32* %X
   ret i32 0
 dead:
   call i32 @caller(i32* null)
   call void @dead()
   ret i32 1
 }
 
 define internal i32 @caller(i32* %B) {
 ; IS__CGSCC_OPM: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@caller
-; IS__CGSCC_OPM-SAME: () [[ATTR1:#.*]] {
+; IS__CGSCC_OPM-SAME: () #[[ATTR1:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; IS__CGSCC_OPM-NEXT:    store i32 1, i32* [[A]], align 4
-; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A]]) [[ATTR3:#.*]]
+; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A]]) #[[ATTR3:[0-9]+]]
 ; IS__CGSCC_OPM-NEXT:    ret i32 undef
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@caller
-; IS__CGSCC_NPM-SAME: () [[ATTR1:#.*]] {
+; IS__CGSCC_NPM-SAME: () #[[ATTR1:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; IS__CGSCC_NPM-NEXT:    store i32 1, i32* [[A]], align 4
-; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A]]) [[ATTR2:#.*]]
+; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A]]) #[[ATTR2:[0-9]+]]
 ; IS__CGSCC_NPM-NEXT:    ret i32 undef
 ;
   %A = alloca i32
   store i32 1, i32* %A
   %C = call i32 @test(i32* %A, i32* %B)
   ret i32 %C
 }
 
 define i32 @callercaller() {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@callercaller
-; IS__TUNIT____-SAME: () [[ATTR0:#.*]] {
+; IS__TUNIT____-SAME: () #[[ATTR0:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; IS__TUNIT____-NEXT:    store i32 2, i32* [[B]], align 4
 ; IS__TUNIT____-NEXT:    ret i32 0
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@callercaller
-; IS__CGSCC____-SAME: () [[ATTR1:#.*]] {
-; IS__CGSCC____-NEXT:    [[B:%.*]] = alloca i32, align 4
-; IS__CGSCC____-NEXT:    store i32 2, i32* [[B]], align 4
-; IS__CGSCC____-NEXT:    ret i32 0
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@callercaller
+; IS__CGSCC_OPM-SAME: () #[[ATTR2:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    [[B:%.*]] = alloca i32, align 4
+; IS__CGSCC_OPM-NEXT:    store i32 2, i32* [[B]], align 4
+; IS__CGSCC_OPM-NEXT:    ret i32 0
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@callercaller
+; IS__CGSCC_NPM-SAME: () #[[ATTR1]] {
+; IS__CGSCC_NPM-NEXT:    [[B:%.*]] = alloca i32, align 4
+; IS__CGSCC_NPM-NEXT:    store i32 2, i32* [[B]], align 4
+; IS__CGSCC_NPM-NEXT:    ret i32 0
 ;
   %B = alloca i32
   store i32 2, i32* %B
   %X = call i32 @caller(i32* %B)
   ret i32 %X
 }
 
+; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind readnone willreturn }
+;.
+; IS__CGSCC_OPM: attributes #[[ATTR0]] = { argmemonly nofree nosync nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR1]] = { nofree nosync nounwind readnone willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind readnone willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn writeonly }
+;.
+; IS__CGSCC_NPM: attributes #[[ATTR0]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn writeonly }

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=9 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -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
 ; 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
 
 
 define internal void @dead() {
+; IS__CGSCC____-LABEL: define {{[^@]+}}@dead() {
+; IS__CGSCC____-NEXT:    [[TMP1:%.*]] = call i32 @test(i32* noalias noundef align 536870912 null)
+; IS__CGSCC____-NEXT:    ret void
+;
   call i32 @test(i32* null, i32* null)
   ret void
 }
 
 define internal i32 @test(i32* %X, i32* %Y) {
 ; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test
-; NOT_CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef writeonly align 4 [[X:%.*]]) [[ATTR0:#.*]] {
+; NOT_CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef writeonly align 4 [[X:%.*]]) #[[ATTR0:[0-9]+]] {
 ; NOT_CGSCC_NPM-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; NOT_CGSCC_NPM:       live:
 ; NOT_CGSCC_NPM-NEXT:    store i32 0, i32* [[X]], align 4
 ; NOT_CGSCC_NPM-NEXT:    ret i32 undef
 ; NOT_CGSCC_NPM:       dead:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ;
 ; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test
-; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[X:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef writeonly align 4 [[X:%.*]]) #[[ATTR0:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:    br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
 ; IS__CGSCC_NPM:       live:
 ; IS__CGSCC_NPM-NEXT:    store i32 0, i32* [[X]], align 4
 ; IS__CGSCC_NPM-NEXT:    ret i32 undef
 ; IS__CGSCC_NPM:       dead:
 ; IS__CGSCC_NPM-NEXT:    unreachable
 ;
   br i1 true, label %live, label %dead
 live:
   store i32 0, i32* %X
   ret i32 0
 dead:
   call i32 @caller(i32* null)
   call void @dead()
   ret i32 1
 }
 
 define internal i32 @caller(i32* %B) {
 ; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@caller
-; NOT_CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) [[ATTR0]] {
+; NOT_CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
 ; NOT_CGSCC_NPM-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; NOT_CGSCC_NPM-NEXT:    store i32 1, i32* [[A]], align 4
-; NOT_CGSCC_NPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) [[ATTR2:#.*]]
+; NOT_CGSCC_NPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]]
 ; NOT_CGSCC_NPM-NEXT:    ret i32 undef
 ;
 ; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@caller
-; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) [[ATTR0]] {
+; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC_NPM-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; IS__CGSCC_NPM-NEXT:    store i32 1, i32* [[A]], align 4
-; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) [[ATTR2:#.*]]
+; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = call i32 @test(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]]
 ; IS__CGSCC_NPM-NEXT:    ret i32 undef
 ;
   %A = alloca i32
   store i32 1, i32* %A
   %C = call i32 @test(i32* %B, i32* %A)
   ret i32 %C
 }
 
 define i32 @callercaller() {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@callercaller
-; IS__TUNIT____-SAME: () [[ATTR1:#.*]] {
+; IS__TUNIT____-SAME: () #[[ATTR1:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; IS__TUNIT____-NEXT:    store i32 2, i32* [[B]], align 4
-; IS__TUNIT____-NEXT:    [[X:%.*]] = call i32 @caller(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) [[ATTR2:#.*]]
+; IS__TUNIT____-NEXT:    [[X:%.*]] = call i32 @caller(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2]]
 ; IS__TUNIT____-NEXT:    ret i32 0
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@callercaller
-; IS__CGSCC_OPM-SAME: () [[ATTR1:#.*]] {
+; IS__CGSCC_OPM-SAME: () #[[ATTR1:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; IS__CGSCC_OPM-NEXT:    store i32 2, i32* [[B]], align 4
-; IS__CGSCC_OPM-NEXT:    [[X:%.*]] = call i32 @caller(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) [[ATTR3:#.*]]
+; IS__CGSCC_OPM-NEXT:    [[X:%.*]] = call i32 @caller(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR3:[0-9]+]]
 ; IS__CGSCC_OPM-NEXT:    ret i32 0
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@callercaller
-; IS__CGSCC_NPM-SAME: () [[ATTR1:#.*]] {
+; IS__CGSCC_NPM-SAME: () #[[ATTR1:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; IS__CGSCC_NPM-NEXT:    store i32 2, i32* [[B]], align 4
-; IS__CGSCC_NPM-NEXT:    [[X:%.*]] = call i32 @caller(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) [[ATTR3:#.*]]
+; IS__CGSCC_NPM-NEXT:    [[X:%.*]] = call i32 @caller(i32* noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR3:[0-9]+]]
 ; IS__CGSCC_NPM-NEXT:    ret i32 0
 ;
   %B = alloca i32
   store i32 2, i32* %B
   %X = call i32 @caller(i32* %B)
   ret i32 %X
 }
 
+; IS__TUNIT____: attributes #[[ATTR0]] = { argmemonly nofree nosync nounwind willreturn writeonly }
+; IS__TUNIT____: attributes #[[ATTR1]] = { nofree nosync nounwind readnone willreturn }
+; IS__TUNIT____: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn writeonly }
+;.
+; IS__CGSCC_OPM: attributes #[[ATTR0]] = { argmemonly nofree nosync nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR1]] = { nofree nosync nounwind readnone willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR3]] = { nounwind willreturn writeonly }
+;.
+; IS__CGSCC_NPM: attributes #[[ATTR0]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR3]] = { nounwind willreturn writeonly }

llvm/test/Transforms/Attributor/IPConstantProp/dangling-block-address.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; 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
 ; 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
 ; 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
 ; 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
 ; PR5569
 
 ; IPSCCP should prove that the blocks are dead and delete them, and
 ; properly handle the dangling blockaddress constants.
 
-; NOT_CGSCC_OPM: @bar.l = internal constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
-; IS__CGSCC_OPM: @bar.l = internal constant [2 x i8*] [i8* blockaddress(@bar, %lab0), i8* blockaddress(@bar, %end)]
+; NOT_CGSCC____: @bar.l = internal constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
+; IS__CGSCC____: @bar.l = internal constant [2 x i8*] [i8* blockaddress(@bar, %lab0), i8* blockaddress(@bar, %end)]
 
 @code = global [5 x i32] [i32 0, i32 0, i32 0, i32 0, i32 1], align 4 ; <[5 x i32]*> [#uses=0]
 @bar.l = internal constant [2 x i8*] [i8* blockaddress(@bar, %lab0), i8* blockaddress(@bar, %end)] ; <[2 x i8*]*> [#uses=1]
 
 define internal void @foo(i32 %x) nounwind readnone {
 ; IS__CGSCC____: Function Attrs: nounwind readnone
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@foo
-; IS__CGSCC____-SAME: (i32 [[X:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC____-SAME: (i32 [[X:%.*]]) #[[ATTR0:[0-9]+]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; IS__CGSCC____-NEXT:    store volatile i32 -1, i32* [[B]], align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
 entry:
   %b = alloca i32, align 4                        ; <i32*> [#uses=1]
   store volatile i32 -1, i32* %b
   ret void
 }
 
 define internal void @bar(i32* nocapture %pc) nounwind readonly {
 ; IS__CGSCC_OPM: Function Attrs: nounwind readonly
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@bar
-; IS__CGSCC_OPM-SAME: (i32* nocapture [[PC:%.*]]) [[ATTR1:#.*]] {
+; IS__CGSCC_OPM-SAME: (i32* nocapture [[PC:%.*]]) #[[ATTR1:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    br label [[INDIRECTGOTO:%.*]]
 ; IS__CGSCC_OPM:       lab0:
 ; IS__CGSCC_OPM-NEXT:    [[INDVAR_NEXT:%.*]] = add i32 [[INDVAR:%.*]], 1
 ; IS__CGSCC_OPM-NEXT:    br label [[INDIRECTGOTO]]
 ; IS__CGSCC_OPM:       end:
 ; IS__CGSCC_OPM-NEXT:    ret void
 ; IS__CGSCC_OPM:       indirectgoto:
 ; IS__CGSCC_OPM-NEXT:    [[INDVAR]] = phi i32 [ [[INDVAR_NEXT]], [[LAB0:%.*]] ], [ 0, [[ENTRY:%.*]] ]
 ; IS__CGSCC_OPM-NEXT:    [[PC_ADDR_0:%.*]] = getelementptr i32, i32* [[PC]], i32 [[INDVAR]]
 ; IS__CGSCC_OPM-NEXT:    [[TMP1_PN:%.*]] = load i32, i32* [[PC_ADDR_0]], align 4
 ; IS__CGSCC_OPM-NEXT:    [[INDIRECT_GOTO_DEST_IN:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* @bar.l, i32 0, i32 [[TMP1_PN]]
 ; IS__CGSCC_OPM-NEXT:    [[INDIRECT_GOTO_DEST:%.*]] = load i8*, i8** [[INDIRECT_GOTO_DEST_IN]], align 8
 ; IS__CGSCC_OPM-NEXT:    indirectbr i8* [[INDIRECT_GOTO_DEST]], [label [[LAB0]], label %end]
 ;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@bar
+; IS__CGSCC_NPM-SAME: (i32* noalias nocapture nofree nonnull readonly align 536870912 dereferenceable(4294967295) [[PC:%.*]]) #[[ATTR1:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:  entry:
+; IS__CGSCC_NPM-NEXT:    br label [[INDIRECTGOTO:%.*]]
+; IS__CGSCC_NPM:       lab0:
+; IS__CGSCC_NPM-NEXT:    [[INDVAR_NEXT:%.*]] = add i32 [[INDVAR:%.*]], 1
+; IS__CGSCC_NPM-NEXT:    br label [[INDIRECTGOTO]]
+; IS__CGSCC_NPM:       end:
+; IS__CGSCC_NPM-NEXT:    ret void
+; IS__CGSCC_NPM:       indirectgoto:
+; IS__CGSCC_NPM-NEXT:    [[INDVAR]] = phi i32 [ [[INDVAR_NEXT]], [[LAB0:%.*]] ], [ 0, [[ENTRY:%.*]] ]
+; IS__CGSCC_NPM-NEXT:    [[PC_ADDR_0:%.*]] = getelementptr i32, i32* undef, i32 [[INDVAR]]
+; IS__CGSCC_NPM-NEXT:    [[TMP1_PN:%.*]] = load i32, i32* [[PC_ADDR_0]], align 4
+; IS__CGSCC_NPM-NEXT:    [[INDIRECT_GOTO_DEST_IN:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* @bar.l, i32 0, i32 [[TMP1_PN]]
+; IS__CGSCC_NPM-NEXT:    [[INDIRECT_GOTO_DEST:%.*]] = load i8*, i8** [[INDIRECT_GOTO_DEST_IN]], align 8
+; IS__CGSCC_NPM-NEXT:    indirectbr i8* [[INDIRECT_GOTO_DEST]], [label [[LAB0]], label %end]
+;
 entry:
   br label %indirectgoto
 
 lab0:                                             ; preds = %indirectgoto
   %indvar.next = add i32 %indvar, 1               ; <i32> [#uses=1]
   br label %indirectgoto
 
 end:                                              ; preds = %indirectgoto
   ret void
 
 indirectgoto:                                     ; preds = %lab0, %entry
   %indvar = phi i32 [ %indvar.next, %lab0 ], [ 0, %entry ] ; <i32> [#uses=2]
   %pc.addr.0 = getelementptr i32, i32* %pc, i32 %indvar ; <i32*> [#uses=1]
   %tmp1.pn = load i32, i32* %pc.addr.0                 ; <i32> [#uses=1]
   %indirect.goto.dest.in = getelementptr inbounds [2 x i8*], [2 x i8*]* @bar.l, i32 0, i32 %tmp1.pn ; <i8**> [#uses=1]
   %indirect.goto.dest = load i8*, i8** %indirect.goto.dest.in ; <i8*> [#uses=1]
   indirectbr i8* %indirect.goto.dest, [label %lab0, label %end]
 }
 
 define i32 @main() nounwind readnone {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@main
-; IS__TUNIT____-SAME: () [[ATTR0:#.*]] {
+; IS__TUNIT____-SAME: () #[[ATTR0:[0-9]+]] {
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    ret i32 0
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@main
-; IS__CGSCC____-SAME: () [[ATTR1:#.*]] {
+; IS__CGSCC____-SAME: () #[[ATTR2:[0-9]+]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    ret i32 0
 ;
 entry:
   ret i32 0
 }
+; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind readnone willreturn }
+;.
+; IS__CGSCC_OPM: attributes #[[ATTR0]] = { nounwind readnone }
+; IS__CGSCC_OPM: attributes #[[ATTR1]] = { nounwind readonly }
+; IS__CGSCC_OPM: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind readnone willreturn }
+;.
+; IS__CGSCC_NPM: attributes #[[ATTR0]] = { nounwind readnone }
+; IS__CGSCC_NPM: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind readnone }
+; IS__CGSCC_NPM: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind readnone willreturn }

llvm/test/Transforms/Attributor/align.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -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
 ; 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
 
 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
+;;
 define i32* @test1(i32* align 8 %0) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test1
-; IS__TUNIT____-SAME: (i32* nofree readnone returned align 8 "no-capture-maybe-returned" [[TMP0:%.*]]) [[ATTR0:#.*]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone returned align 8 "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    ret i32* [[TMP0]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test1
-; IS__CGSCC____-SAME: (i32* nofree readnone returned align 8 "no-capture-maybe-returned" [[TMP0:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone returned align 8 "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    ret i32* [[TMP0]]
 ;
   ret i32* %0
 }
 
 ; TEST 2
 define i32* @test2(i32* %0) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test2
-; IS__TUNIT____-SAME: (i32* nofree readnone returned "no-capture-maybe-returned" [[TMP0:%.*]]) [[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone returned "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:    ret i32* [[TMP0]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test2
-; IS__CGSCC____-SAME: (i32* nofree readnone returned "no-capture-maybe-returned" [[TMP0:%.*]]) [[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone returned "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:    ret i32* [[TMP0]]
 ;
   ret i32* %0
 }
 
 ; TEST 3
 define i32* @test3(i32* align 8 %0, i32* align 4 %1, i1 %2) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test3
-; IS__TUNIT____-SAME: (i32* nofree readnone align 8 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 4 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) [[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone align 8 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 4 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:    [[RET:%.*]] = select i1 [[TMP2]], i32* [[TMP0]], i32* [[TMP1]]
 ; IS__TUNIT____-NEXT:    ret i32* [[RET]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test3
-; IS__CGSCC____-SAME: (i32* nofree readnone align 8 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 4 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) [[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone align 8 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 4 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:    [[RET:%.*]] = select i1 [[TMP2]], i32* [[TMP0]], i32* [[TMP1]]
 ; IS__CGSCC____-NEXT:    ret i32* [[RET]]
 ;
   %ret = select i1 %2, i32* %0, i32* %1
   ret i32* %ret
 }
 
 ; TEST 4
 define i32* @test4(i32* align 32 %0, i32* align 32 %1, i1 %2) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test4
-; IS__TUNIT____-SAME: (i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) [[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:    [[RET:%.*]] = select i1 [[TMP2]], i32* [[TMP0]], i32* [[TMP1]]
 ; IS__TUNIT____-NEXT:    ret i32* [[RET]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test4
-; IS__CGSCC____-SAME: (i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) [[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP0:%.*]], i32* nofree readnone align 32 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:    [[RET:%.*]] = select i1 [[TMP2]], i32* [[TMP0]], i32* [[TMP1]]
 ; IS__CGSCC____-NEXT:    ret i32* [[RET]]
 ;
   %ret = select i1 %2, i32* %0, i32* %1
   ret i32* %ret
 }
 
 ; TEST 5

 ;
   %ret = tail call i32* @align8()
   ret i32* %ret
 }
 
 ; TEST 6
 ; SCC
 define i32* @test6_1() #0 {
-; NOT_CGSCC_OPM: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test6_1
-; NOT_CGSCC_OPM-SAME: () [[ATTR1:#.*]] {
-; NOT_CGSCC_OPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_2() [[ATTR11:#.*]]
-; NOT_CGSCC_OPM-NEXT:    unreachable
+; IS__TUNIT____: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test6_1
+; IS__TUNIT____-SAME: () #[[ATTR1:[0-9]+]] {
+; IS__TUNIT____-NEXT:    [[RET:%.*]] = tail call i32* @test6_2() #[[ATTR11:[0-9]+]]
+; IS__TUNIT____-NEXT:    unreachable
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test6_1
-; IS__CGSCC_OPM-SAME: () [[ATTR1:#.*]] {
-; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_2() [[ATTR12:#.*]]
+; IS__CGSCC_OPM-SAME: () #[[ATTR1:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_2() #[[ATTR13:[0-9]+]]
 ; IS__CGSCC_OPM-NEXT:    unreachable
 ;
+; IS__CGSCC_NPM: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test6_1
+; IS__CGSCC_NPM-SAME: () #[[ATTR1:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_2() #[[ATTR12:[0-9]+]]
+; IS__CGSCC_NPM-NEXT:    unreachable
+;
   %ret = tail call i32* @test6_2()
   ret i32* %ret
 }
 
 define i32* @test6_2() #0 {
-; NOT_CGSCC_OPM: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test6_2
-; NOT_CGSCC_OPM-SAME: () [[ATTR1]] {
-; NOT_CGSCC_OPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_1() [[ATTR11]]
-; NOT_CGSCC_OPM-NEXT:    unreachable
+; IS__TUNIT____: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test6_2
+; IS__TUNIT____-SAME: () #[[ATTR1]] {
+; IS__TUNIT____-NEXT:    [[RET:%.*]] = tail call i32* @test6_1() #[[ATTR11]]
+; IS__TUNIT____-NEXT:    unreachable
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test6_2
-; IS__CGSCC_OPM-SAME: () [[ATTR1]] {
-; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_1() [[ATTR12]]
+; IS__CGSCC_OPM-SAME: () #[[ATTR1]] {
+; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_1() #[[ATTR13]]
 ; IS__CGSCC_OPM-NEXT:    unreachable
 ;
+; IS__CGSCC_NPM: Function Attrs: nofree noinline noreturn nosync nounwind readnone uwtable
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test6_2
+; IS__CGSCC_NPM-SAME: () #[[ATTR1]] {
+; IS__CGSCC_NPM-NEXT:    [[RET:%.*]] = tail call i32* @test6_1() #[[ATTR12]]
+; IS__CGSCC_NPM-NEXT:    unreachable
+;
   %ret = tail call i32* @test6_1()
   ret i32* %ret
 }
 
 
 ; char a1 __attribute__((aligned(8)));
 ; char a2 __attribute__((aligned(16)));
 ;

 
 @a1 = common global i8 0, align 8
 @a2 = common global i8 0, align 16
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f1(i8* readnone %0) local_unnamed_addr #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@f1
-; IS__TUNIT____-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr [[ATTR0]] {
+; IS__TUNIT____-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:    br label [[TMP3:%.*]]
 ; IS__TUNIT____:       2:
 ; IS__TUNIT____-NEXT:    unreachable
 ; IS__TUNIT____:       3:
 ; IS__TUNIT____-NEXT:    ret i8* [[TMP0]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@f1
-; IS__CGSCC_OPM-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr [[ATTR2:#.*]] {
+; IS__CGSCC_OPM-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    br label [[TMP3:%.*]]
 ; IS__CGSCC_OPM:       2:
 ; IS__CGSCC_OPM-NEXT:    unreachable
 ; IS__CGSCC_OPM:       3:
-; IS__CGSCC_OPM-NEXT:    ret i8* undef
+; IS__CGSCC_OPM-NEXT:    ret i8* @a1
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f1
-; IS__CGSCC_NPM-SAME: () local_unnamed_addr [[ATTR0:#.*]] {
+; IS__CGSCC_NPM-SAME: () local_unnamed_addr #[[ATTR0]] {
 ; IS__CGSCC_NPM-NEXT:    br label [[TMP2:%.*]]
 ; IS__CGSCC_NPM:       1:
 ; IS__CGSCC_NPM-NEXT:    unreachable
 ; IS__CGSCC_NPM:       2:
 ; IS__CGSCC_NPM-NEXT:    ret i8* undef
 ;
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
   %4 = tail call i8* @f2(i8* nonnull @a1)
   %l = load i8, i8* %4
   br label %5
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
   ret i8* %6
 }
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f2(i8* readnone %0) local_unnamed_addr #0 {
+; IS__CGSCC_OPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@f2
+; IS__CGSCC_OPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR3:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    br label [[TMP2:%.*]]
+; IS__CGSCC_OPM:       2:
+; IS__CGSCC_OPM-NEXT:    [[TMP3:%.*]] = tail call i8* @f1(i8* noalias nonnull readnone align 536870912 dereferenceable(4294967295) undef)
+; IS__CGSCC_OPM-NEXT:    br label [[TMP5:%.*]]
+; IS__CGSCC_OPM:       4:
+; IS__CGSCC_OPM-NEXT:    unreachable
+; IS__CGSCC_OPM:       5:
+; IS__CGSCC_OPM-NEXT:    ret i8* [[TMP3]]
+;
+; IS__CGSCC_NPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f2
+; IS__CGSCC_NPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    br label [[TMP2:%.*]]
+; IS__CGSCC_NPM:       2:
+; IS__CGSCC_NPM-NEXT:    [[TMP3:%.*]] = tail call i8* @f1()
+; IS__CGSCC_NPM-NEXT:    br label [[TMP5:%.*]]
+; IS__CGSCC_NPM:       4:
+; IS__CGSCC_NPM-NEXT:    unreachable
+; IS__CGSCC_NPM:       5:
+; IS__CGSCC_NPM-NEXT:    ret i8* @a1
+;
   %2 = icmp eq i8* %0, null
   br i1 %2, label %5, label %3
 
 ; <label>:3:                                      ; preds = %1
 
   %4 = tail call i8* @f1(i8* nonnull %0)
   br label %7
 
 ; <label>:5:                                      ; preds = %1
   %6 = tail call i8* @f3(i8* nonnull @a2)
   br label %7
 
 ; <label>:7:                                      ; preds = %5, %3
   %8 = phi i8* [ %4, %3 ], [ %6, %5 ]
   ret i8* %8
 }
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f3(i8* readnone %0) local_unnamed_addr #0 {
+; IS__CGSCC_OPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@f3
+; IS__CGSCC_OPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR3]] {
+; IS__CGSCC_OPM-NEXT:    br label [[TMP3:%.*]]
+; IS__CGSCC_OPM:       2:
+; IS__CGSCC_OPM-NEXT:    unreachable
+; IS__CGSCC_OPM:       3:
+; IS__CGSCC_OPM-NEXT:    ret i8* @a1
+;
+; IS__CGSCC_NPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f3
+; IS__CGSCC_NPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR2]] {
+; IS__CGSCC_NPM-NEXT:    br label [[TMP3:%.*]]
+; IS__CGSCC_NPM:       2:
+; IS__CGSCC_NPM-NEXT:    unreachable
+; IS__CGSCC_NPM:       3:
+; IS__CGSCC_NPM-NEXT:    ret i8* @a1
+;
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
   %4 = tail call i8* @f1(i8* nonnull @a2)
   br label %5
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
   ret i8* %6
 }
 
 ; TEST 7
 ; Better than IR information
 define align 4 i8* @test7() #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test7
-; IS__TUNIT____-SAME: () [[ATTR0]] {
-; IS__TUNIT____-NEXT:    [[C:%.*]] = tail call i8* @f1(i8* noalias nofree noundef nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" @a1) [[ATTR9:#.*]]
+; IS__TUNIT____-SAME: () #[[ATTR0]] {
+; IS__TUNIT____-NEXT:    [[C:%.*]] = tail call i8* @f1(i8* noalias nofree noundef nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" @a1) #[[ATTR9:[0-9]+]]
 ; IS__TUNIT____-NEXT:    ret i8* [[C]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test7
-; IS__CGSCC____-SAME: () [[ATTR0]] {
+; IS__CGSCC____-SAME: () #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:    ret i8* @a1
 ;
   %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 {
 ; IS__CGSCC_OPM: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@f1b
-; IS__CGSCC_OPM-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr [[ATTR2]] {
+; IS__CGSCC_OPM-SAME: (i8* noalias nofree nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR2]] {
 ; IS__CGSCC_OPM-NEXT:    br label [[TMP3:%.*]]
 ; IS__CGSCC_OPM:       2:
 ; IS__CGSCC_OPM-NEXT:    unreachable
 ; IS__CGSCC_OPM:       3:
-; IS__CGSCC_OPM-NEXT:    ret i8* undef
+; IS__CGSCC_OPM-NEXT:    ret i8* @a1
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f1b
-; IS__CGSCC_NPM-SAME: () local_unnamed_addr [[ATTR0]] {
+; IS__CGSCC_NPM-SAME: () local_unnamed_addr #[[ATTR0]] {
 ; IS__CGSCC_NPM-NEXT:    br label [[TMP2:%.*]]
 ; IS__CGSCC_NPM:       1:
 ; IS__CGSCC_NPM-NEXT:    unreachable
 ; IS__CGSCC_NPM:       2:
 ; IS__CGSCC_NPM-NEXT:    ret i8* undef
 ;
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
   %4 = tail call i8* @f2b(i8* nonnull @a1)
   %l = load i8, i8* %4
   store i8 %l, i8* @a1
   br label %5
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
   ret i8* %6
 }
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f2b(i8* readnone %0) local_unnamed_addr #0 {
 ;
+; IS__CGSCC_OPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@f2b
+; IS__CGSCC_OPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR3]] {
+; IS__CGSCC_OPM-NEXT:    br label [[TMP2:%.*]]
+; IS__CGSCC_OPM:       2:
+; IS__CGSCC_OPM-NEXT:    [[TMP3:%.*]] = tail call i8* @f1b(i8* noalias nonnull readnone align 536870912 dereferenceable(4294967295) undef)
+; IS__CGSCC_OPM-NEXT:    br label [[TMP5:%.*]]
+; IS__CGSCC_OPM:       4:
+; IS__CGSCC_OPM-NEXT:    unreachable
+; IS__CGSCC_OPM:       5:
+; IS__CGSCC_OPM-NEXT:    ret i8* [[TMP3]]
+;
+; IS__CGSCC_NPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f2b
+; IS__CGSCC_NPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR2]] {
+; IS__CGSCC_NPM-NEXT:    br label [[TMP2:%.*]]
+; IS__CGSCC_NPM:       2:
+; IS__CGSCC_NPM-NEXT:    [[TMP3:%.*]] = tail call i8* @f1b()
+; IS__CGSCC_NPM-NEXT:    br label [[TMP5:%.*]]
+; IS__CGSCC_NPM:       4:
+; IS__CGSCC_NPM-NEXT:    unreachable
+; IS__CGSCC_NPM:       5:
+; IS__CGSCC_NPM-NEXT:    ret i8* @a1
+;
   %2 = icmp eq i8* %0, null
   br i1 %2, label %5, label %3
 
 ; <label>:3:                                      ; preds = %1
 
   %4 = tail call i8* @f1b(i8* nonnull %0)
   br label %7
 
 ; <label>:5:                                      ; preds = %1
   %6 = tail call i8* @f3b(i8* nonnull @a2)
   br label %7
 
 ; <label>:7:                                      ; preds = %5, %3
   %8 = phi i8* [ %4, %3 ], [ %6, %5 ]
   ret i8* %8
 }
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f3b(i8* readnone %0) local_unnamed_addr #0 {
 ;
+; IS__CGSCC_OPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@f3b
+; IS__CGSCC_OPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR3]] {
+; IS__CGSCC_OPM-NEXT:    br label [[TMP3:%.*]]
+; IS__CGSCC_OPM:       2:
+; IS__CGSCC_OPM-NEXT:    unreachable
+; IS__CGSCC_OPM:       3:
+; IS__CGSCC_OPM-NEXT:    ret i8* @a1
+;
+; IS__CGSCC_NPM: Function Attrs: noinline nounwind uwtable
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f3b
+; IS__CGSCC_NPM-SAME: (i8* nonnull readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR2]] {
+; IS__CGSCC_NPM-NEXT:    br label [[TMP3:%.*]]
+; IS__CGSCC_NPM:       2:
+; IS__CGSCC_NPM-NEXT:    unreachable
+; IS__CGSCC_NPM:       3:
+; IS__CGSCC_NPM-NEXT:    ret i8* @a1
+;
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
   %4 = tail call i8* @f1b(i8* nonnull @a2)
   br label %5
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
   ret i8* %6
 }
 
 define align 4 i32* @test7b(i32* align 32 %p) #0 {
 ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test7b
-; IS__TUNIT____-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) [[ATTR0]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR0]] {
 ; IS__TUNIT____-NEXT:    ret i32* [[P]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test7b
-; IS__CGSCC____-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) [[ATTR0]] {
+; IS__CGSCC____-SAME: (i32* nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR0]] {
 ; IS__CGSCC____-NEXT:    ret i32* [[P]]
 ;
   tail call i8* @f1b(i8* align 8 dereferenceable(1) @a1)
   ret i32* %p
 }
 
 ; TEST 8
 define void @test8_helper() {
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test8_helper() {
-; NOT_CGSCC_OPM-NEXT:    [[PTR0:%.*]] = tail call i32* @unknown()
-; NOT_CGSCC_OPM-NEXT:    [[PTR1:%.*]] = tail call align 4 i32* @unknown()
-; NOT_CGSCC_OPM-NEXT:    [[PTR2:%.*]] = tail call align 8 i32* @unknown()
-; NOT_CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone [[PTR0]]) [[ATTR2:#.*]]
-; NOT_CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    ret void
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test8_helper() {
+; IS__TUNIT____-NEXT:    [[PTR0:%.*]] = tail call i32* @unknown()
+; IS__TUNIT____-NEXT:    [[PTR1:%.*]] = tail call align 4 i32* @unknown()
+; IS__TUNIT____-NEXT:    [[PTR2:%.*]] = tail call align 8 i32* @unknown()
+; IS__TUNIT____-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone [[PTR0]]) #[[ATTR2:[0-9]+]]
+; IS__TUNIT____-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test8_helper() {
 ; IS__CGSCC_OPM-NEXT:    [[PTR0:%.*]] = tail call i32* @unknown()
 ; IS__CGSCC_OPM-NEXT:    [[PTR1:%.*]] = tail call align 4 i32* @unknown()
 ; IS__CGSCC_OPM-NEXT:    [[PTR2:%.*]] = tail call align 8 i32* @unknown()
-; IS__CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone [[PTR0]]) [[ATTR3:#.*]]
-; IS__CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) [[ATTR3]]
-; IS__CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) [[ATTR3]]
+; IS__CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone [[PTR0]]) #[[ATTR4:[0-9]+]]
+; IS__CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR4]]
+; IS__CGSCC_OPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR4]]
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test8_helper() {
+; IS__CGSCC_NPM-NEXT:    [[PTR0:%.*]] = tail call i32* @unknown()
+; IS__CGSCC_NPM-NEXT:    [[PTR1:%.*]] = tail call align 4 i32* @unknown()
+; IS__CGSCC_NPM-NEXT:    [[PTR2:%.*]] = tail call align 8 i32* @unknown()
+; IS__CGSCC_NPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone [[PTR0]]) #[[ATTR3:[0-9]+]]
+; IS__CGSCC_NPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    ret void
+;
   %ptr0 = tail call i32* @unknown()
   %ptr1 = tail call align 4 i32* @unknown()
   %ptr2 = tail call align 8 i32* @unknown()
 
   tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
   ret void
 }
 
 declare void @user_i32_ptr(i32* nocapture readnone) nounwind
 define internal void @test8(i32* %a, i32* %b, i32* %c) {
-; NOT_CGSCC_OPM: Function Attrs: nounwind
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test8
-; NOT_CGSCC_OPM-SAME: (i32* noalias nocapture readnone align 4 [[A:%.*]], i32* noalias nocapture readnone align 4 [[B:%.*]], i32* noalias nocapture readnone [[C:%.*]]) [[ATTR2]] {
-; NOT_CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone [[C]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    ret void
+; IS__TUNIT____: Function Attrs: nounwind
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test8
+; IS__TUNIT____-SAME: (i32* noalias nocapture readnone align 4 [[A:%.*]], i32* noalias nocapture readnone align 4 [[B:%.*]], i32* noalias nocapture readnone [[C:%.*]]) #[[ATTR2]] {
+; IS__TUNIT____-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone [[C]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test8
-; IS__CGSCC_OPM-SAME: (i32* noalias nocapture readnone align 4 [[A:%.*]], i32* noalias nocapture readnone align 4 [[B:%.*]], i32* noalias nocapture readnone [[C:%.*]]) [[ATTR3]] {
-; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]]) [[ATTR3]]
-; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]]) [[ATTR3]]
-; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone [[C]]) [[ATTR3]]
+; IS__CGSCC_OPM-SAME: (i32* noalias nocapture readnone align 4 [[A:%.*]], i32* noalias nocapture readnone align 4 [[B:%.*]], i32* noalias nocapture readnone [[C:%.*]]) #[[ATTR4]] {
+; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]]) #[[ATTR4]]
+; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]]) #[[ATTR4]]
+; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone [[C]]) #[[ATTR4]]
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
+; IS__CGSCC_NPM: Function Attrs: nounwind
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test8
+; IS__CGSCC_NPM-SAME: (i32* noalias nocapture readnone align 4 [[A:%.*]], i32* noalias nocapture readnone align 4 [[B:%.*]], i32* noalias nocapture readnone [[C:%.*]]) #[[ATTR3]] {
+; IS__CGSCC_NPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture readnone [[C]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    ret void
+;
   call void @user_i32_ptr(i32* %a)
   call void @user_i32_ptr(i32* %b)
   call void @user_i32_ptr(i32* %c)
   ret void
 }
 
 declare void @test9_helper(i32* %A)
 define void @test9_traversal(i1 %cnd, i32* align 4 %B, i32* align 8 %C) {

 
 ; FIXME: This will work with an upcoming patch (D66618 or similar)
 ;             define align 32 i32* @test10a(i32* align 32 "no-capture-maybe-returned" %p)
 ; FIXME: This will work with an upcoming patch (D66618 or similar)
 ;             store i32 1, i32* %r, align 32
 ; FIXME: This will work with an upcoming patch (D66618 or similar)
 ;             store i32 -1, i32* %g1, align 32
 define i32* @test10a(i32* align 32 %p) {
-; NOT_CGSCC_OPM: Function Attrs: nofree nosync nounwind
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test10a
-; NOT_CGSCC_OPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) [[ATTR3:#.*]] {
-; NOT_CGSCC_OPM-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
-; NOT_CGSCC_OPM-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
-; NOT_CGSCC_OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
-; NOT_CGSCC_OPM:       t:
-; NOT_CGSCC_OPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10a(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) [[ATTR3]]
-; NOT_CGSCC_OPM-NEXT:    store i32 1, i32* [[R]], align 32
-; NOT_CGSCC_OPM-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
-; NOT_CGSCC_OPM-NEXT:    br label [[E:%.*]]
-; NOT_CGSCC_OPM:       f:
-; NOT_CGSCC_OPM-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 8
-; NOT_CGSCC_OPM-NEXT:    store i32 -1, i32* [[G1]], align 32
-; NOT_CGSCC_OPM-NEXT:    br label [[E]]
-; NOT_CGSCC_OPM:       e:
-; NOT_CGSCC_OPM-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
-; NOT_CGSCC_OPM-NEXT:    ret i32* [[PHI]]
+; IS__TUNIT____: Function Attrs: nofree nosync nounwind
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test10a
+; IS__TUNIT____-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR3:[0-9]+]] {
+; IS__TUNIT____-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
+; IS__TUNIT____-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
+; IS__TUNIT____-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__TUNIT____:       t:
+; IS__TUNIT____-NEXT:    [[R:%.*]] = call align 32 i32* @test10a(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) #[[ATTR3]]
+; IS__TUNIT____-NEXT:    store i32 1, i32* [[R]], align 32
+; IS__TUNIT____-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
+; IS__TUNIT____-NEXT:    br label [[E:%.*]]
+; IS__TUNIT____:       f:
+; IS__TUNIT____-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 8
+; IS__TUNIT____-NEXT:    store i32 -1, i32* [[G1]], align 32
+; IS__TUNIT____-NEXT:    br label [[E]]
+; IS__TUNIT____:       e:
+; IS__TUNIT____-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
+; IS__TUNIT____-NEXT:    ret i32* [[PHI]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree nosync nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test10a
-; IS__CGSCC_OPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) [[ATTR4:#.*]] {
+; IS__CGSCC_OPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR5:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
 ; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; IS__CGSCC_OPM:       t:
-; IS__CGSCC_OPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10a(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) [[ATTR4]]
+; IS__CGSCC_OPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10a(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) #[[ATTR5]]
 ; IS__CGSCC_OPM-NEXT:    store i32 1, i32* [[R]], align 32
 ; IS__CGSCC_OPM-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
 ; IS__CGSCC_OPM-NEXT:    br label [[E:%.*]]
 ; IS__CGSCC_OPM:       f:
 ; IS__CGSCC_OPM-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 8
 ; IS__CGSCC_OPM-NEXT:    store i32 -1, i32* [[G1]], align 32
 ; IS__CGSCC_OPM-NEXT:    br label [[E]]
 ; IS__CGSCC_OPM:       e:
 ; IS__CGSCC_OPM-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
 ; IS__CGSCC_OPM-NEXT:    ret i32* [[PHI]]
 ;
+; IS__CGSCC_NPM: Function Attrs: nofree nosync nounwind
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test10a
+; IS__CGSCC_NPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR4:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
+; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__CGSCC_NPM:       t:
+; IS__CGSCC_NPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10a(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) #[[ATTR4]]
+; IS__CGSCC_NPM-NEXT:    store i32 1, i32* [[R]], align 32
+; IS__CGSCC_NPM-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
+; IS__CGSCC_NPM-NEXT:    br label [[E:%.*]]
+; IS__CGSCC_NPM:       f:
+; IS__CGSCC_NPM-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 8
+; IS__CGSCC_NPM-NEXT:    store i32 -1, i32* [[G1]], align 32
+; IS__CGSCC_NPM-NEXT:    br label [[E]]
+; IS__CGSCC_NPM:       e:
+; IS__CGSCC_NPM-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
+; IS__CGSCC_NPM-NEXT:    ret i32* [[PHI]]
+;
   %l = load i32, i32* %p
   %c = icmp eq i32 %l, 0
   br i1 %c, label %t, label %f
 t:
   %r = call i32* @test10a(i32* %p)
   store i32 1, i32* %r
   %g0 = getelementptr i32, i32* %p, i32 8
   br label %e
 f:
   %g1 = getelementptr i32, i32* %p, i32 8
   store i32 -1, i32* %g1
   br label %e
 e:
   %phi = phi i32* [%g0, %t], [%g1, %f]
   ret i32* %phi
 }
 
 ; FIXME: This will work with an upcoming patch (D66618 or similar)
 ;             define align 32 i32* @test10b(i32* align 32 "no-capture-maybe-returned" %p)
 ; FIXME: This will work with an upcoming patch (D66618 or similar)
 ;             store i32 1, i32* %r, align 32
 ; FIXME: This will work with an upcoming patch (D66618 or similar)
 ;             store i32 -1, i32* %g1, align 32
 define i32* @test10b(i32* align 32 %p) {
-; NOT_CGSCC_OPM: Function Attrs: nofree nosync nounwind
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test10b
-; NOT_CGSCC_OPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) [[ATTR3]] {
-; NOT_CGSCC_OPM-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
-; NOT_CGSCC_OPM-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
-; NOT_CGSCC_OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
-; NOT_CGSCC_OPM:       t:
-; NOT_CGSCC_OPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10b(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) [[ATTR3]]
-; NOT_CGSCC_OPM-NEXT:    store i32 1, i32* [[R]], align 32
-; NOT_CGSCC_OPM-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
-; NOT_CGSCC_OPM-NEXT:    br label [[E:%.*]]
-; NOT_CGSCC_OPM:       f:
-; NOT_CGSCC_OPM-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 -8
-; NOT_CGSCC_OPM-NEXT:    store i32 -1, i32* [[G1]], align 32
-; NOT_CGSCC_OPM-NEXT:    br label [[E]]
-; NOT_CGSCC_OPM:       e:
-; NOT_CGSCC_OPM-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
-; NOT_CGSCC_OPM-NEXT:    ret i32* [[PHI]]
+; IS__TUNIT____: Function Attrs: nofree nosync nounwind
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test10b
+; IS__TUNIT____-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR3]] {
+; IS__TUNIT____-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
+; IS__TUNIT____-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
+; IS__TUNIT____-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__TUNIT____:       t:
+; IS__TUNIT____-NEXT:    [[R:%.*]] = call align 32 i32* @test10b(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) #[[ATTR3]]
+; IS__TUNIT____-NEXT:    store i32 1, i32* [[R]], align 32
+; IS__TUNIT____-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
+; IS__TUNIT____-NEXT:    br label [[E:%.*]]
+; IS__TUNIT____:       f:
+; IS__TUNIT____-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 -8
+; IS__TUNIT____-NEXT:    store i32 -1, i32* [[G1]], align 32
+; IS__TUNIT____-NEXT:    br label [[E]]
+; IS__TUNIT____:       e:
+; IS__TUNIT____-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
+; IS__TUNIT____-NEXT:    ret i32* [[PHI]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree nosync nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test10b
-; IS__CGSCC_OPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) [[ATTR4]] {
+; IS__CGSCC_OPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR5]] {
 ; IS__CGSCC_OPM-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
 ; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; IS__CGSCC_OPM:       t:
-; IS__CGSCC_OPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10b(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) [[ATTR4]]
+; IS__CGSCC_OPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10b(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) #[[ATTR5]]
 ; IS__CGSCC_OPM-NEXT:    store i32 1, i32* [[R]], align 32
 ; IS__CGSCC_OPM-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
 ; IS__CGSCC_OPM-NEXT:    br label [[E:%.*]]
 ; IS__CGSCC_OPM:       f:
 ; IS__CGSCC_OPM-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 -8
 ; IS__CGSCC_OPM-NEXT:    store i32 -1, i32* [[G1]], align 32
 ; IS__CGSCC_OPM-NEXT:    br label [[E]]
 ; IS__CGSCC_OPM:       e:
 ; IS__CGSCC_OPM-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
 ; IS__CGSCC_OPM-NEXT:    ret i32* [[PHI]]
 ;
+; IS__CGSCC_NPM: Function Attrs: nofree nosync nounwind
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test10b
+; IS__CGSCC_NPM-SAME: (i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR4]] {
+; IS__CGSCC_NPM-NEXT:    [[L:%.*]] = load i32, i32* [[P]], align 32
+; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = icmp eq i32 [[L]], 0
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
+; IS__CGSCC_NPM:       t:
+; IS__CGSCC_NPM-NEXT:    [[R:%.*]] = call align 32 i32* @test10b(i32* nofree noundef nonnull align 32 dereferenceable(4) "no-capture-maybe-returned" [[P]]) #[[ATTR4]]
+; IS__CGSCC_NPM-NEXT:    store i32 1, i32* [[R]], align 32
+; IS__CGSCC_NPM-NEXT:    [[G0:%.*]] = getelementptr i32, i32* [[P]], i32 8
+; IS__CGSCC_NPM-NEXT:    br label [[E:%.*]]
+; IS__CGSCC_NPM:       f:
+; IS__CGSCC_NPM-NEXT:    [[G1:%.*]] = getelementptr i32, i32* [[P]], i32 -8
+; IS__CGSCC_NPM-NEXT:    store i32 -1, i32* [[G1]], align 32
+; IS__CGSCC_NPM-NEXT:    br label [[E]]
+; IS__CGSCC_NPM:       e:
+; IS__CGSCC_NPM-NEXT:    [[PHI:%.*]] = phi i32* [ [[G0]], [[T]] ], [ [[G1]], [[F]] ]
+; IS__CGSCC_NPM-NEXT:    ret i32* [[PHI]]
+;
   %l = load i32, i32* %p
   %c = icmp eq i32 %l, 0
   br i1 %c, label %t, label %f
 t:
   %r = call i32* @test10b(i32* %p)
   store i32 1, i32* %r
   %g0 = getelementptr i32, i32* %p, i32 8
   br label %e
 f:
   %g1 = getelementptr i32, i32* %p, i32 -8
   store i32 -1, i32* %g1
   br label %e
 e:
   %phi = phi i32* [%g0, %t], [%g1, %f]
   ret i32* %phi
 }
 
 
 define i64 @test11(i32* %p) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind readonly willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test11
-; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) [[ATTR4:#.*]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR4:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__TUNIT____-NEXT:    [[RET:%.*]] = load i64, i64* [[P_CAST]], align 8
 ; IS__TUNIT____-NEXT:    ret i64 [[RET]]
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test11
-; IS__CGSCC____-SAME: (i32* nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) [[ATTR4:#.*]] {
-; IS__CGSCC____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; IS__CGSCC____-NEXT:    [[RET:%.*]] = load i64, i64* [[P_CAST]], align 8
-; IS__CGSCC____-NEXT:    ret i64 [[RET]]
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test11
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR6:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = load i64, i64* [[P_CAST]], align 8
+; IS__CGSCC_OPM-NEXT:    ret i64 [[RET]]
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test11
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR5:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[RET:%.*]] = load i64, i64* [[P_CAST]], align 8
+; IS__CGSCC_NPM-NEXT:    ret i64 [[RET]]
 ;
   %p-cast = bitcast i32* %p to i64*
   %ret = load i64, i64* %p-cast, align 8
   ret i64 %ret
 }
 
 ; TEST 12
 ; Test for deduction using must-be-executed-context and GEP instruction
 
 ; FXIME: %p should have nonnull
 define i64 @test12-1(i32* align 4 %p) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind readonly willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test12-1
-; IS__TUNIT____-SAME: (i32* nocapture nofree readonly align 16 [[P:%.*]]) [[ATTR4]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR4]] {
 ; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
 ; IS__TUNIT____-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX1]], align 16
 ; IS__TUNIT____-NEXT:    ret i64 [[RET]]
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test12-1
-; IS__CGSCC____-SAME: (i32* nocapture nofree readonly align 16 [[P:%.*]]) [[ATTR4]] {
-; IS__CGSCC____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; IS__CGSCC____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
-; IS__CGSCC____-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
-; IS__CGSCC____-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX1]], align 16
-; IS__CGSCC____-NEXT:    ret i64 [[RET]]
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test12-1
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR6]] {
+; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
+; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
+; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX1]], align 16
+; IS__CGSCC_OPM-NEXT:    ret i64 [[RET]]
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test12-1
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR5]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
+; IS__CGSCC_NPM-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX1]], align 16
+; IS__CGSCC_NPM-NEXT:    ret i64 [[RET]]
 ;
   %p-cast = bitcast i32* %p to i64*
   %arrayidx0 = getelementptr i64, i64* %p-cast, i64 1
   %arrayidx1 = getelementptr i64, i64* %arrayidx0, i64 3
   %ret = load i64, i64* %arrayidx1, align 16
   ret i64 %ret
 }
 
 define i64 @test12-2(i32* align 4 %p) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind readonly willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test12-2
-; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) [[ATTR4]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR4]] {
 ; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
 ; IS__TUNIT____-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX0]], align 16
 ; IS__TUNIT____-NEXT:    ret i64 [[RET]]
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test12-2
-; IS__CGSCC____-SAME: (i32* nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) [[ATTR4]] {
-; IS__CGSCC____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; IS__CGSCC____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
-; IS__CGSCC____-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX0]], align 16
-; IS__CGSCC____-NEXT:    ret i64 [[RET]]
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test12-2
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR6]] {
+; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
+; IS__CGSCC_OPM-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX0]], align 16
+; IS__CGSCC_OPM-NEXT:    ret i64 [[RET]]
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test12-2
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR5]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
+; IS__CGSCC_NPM-NEXT:    [[RET:%.*]] = load i64, i64* [[ARRAYIDX0]], align 16
+; IS__CGSCC_NPM-NEXT:    ret i64 [[RET]]
 ;
   %p-cast = bitcast i32* %p to i64*
   %arrayidx0 = getelementptr i64, i64* %p-cast, i64 0
   %ret = load i64, i64* %arrayidx0, align 16
   ret i64 %ret
 }
 
 ; FXIME: %p should have nonnull
 define void @test12-3(i32* align 4 %p) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test12-3
-; IS__TUNIT____-SAME: (i32* nocapture nofree writeonly align 16 [[P:%.*]]) [[ATTR5:#.*]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR5:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
 ; IS__TUNIT____-NEXT:    store i64 0, i64* [[ARRAYIDX1]], align 16
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test12-3
-; IS__CGSCC____-SAME: (i32* nocapture nofree writeonly align 16 [[P:%.*]]) [[ATTR5:#.*]] {
-; IS__CGSCC____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; IS__CGSCC____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
-; IS__CGSCC____-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
-; IS__CGSCC____-NEXT:    store i64 0, i64* [[ARRAYIDX1]], align 16
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test12-3
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
+; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
+; IS__CGSCC_OPM-NEXT:    store i64 0, i64* [[ARRAYIDX1]], align 16
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test12-3
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR6:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
+; IS__CGSCC_NPM-NEXT:    store i64 0, i64* [[ARRAYIDX1]], align 16
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   %p-cast = bitcast i32* %p to i64*
   %arrayidx0 = getelementptr i64, i64* %p-cast, i64 1
   %arrayidx1 = getelementptr i64, i64* %arrayidx0, i64 3
   store i64 0, i64* %arrayidx1, align 16
   ret void
 }
 
 define void @test12-4(i32* align 4 %p) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test12-4
-; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) [[ATTR5]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR5]] {
 ; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
 ; IS__TUNIT____-NEXT:    store i64 0, i64* [[ARRAYIDX0]], align 16
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test12-4
-; IS__CGSCC____-SAME: (i32* nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) [[ATTR5]] {
-; IS__CGSCC____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; IS__CGSCC____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
-; IS__CGSCC____-NEXT:    store i64 0, i64* [[ARRAYIDX0]], align 16
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test12-4
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR7]] {
+; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
+; IS__CGSCC_OPM-NEXT:    store i64 0, i64* [[ARRAYIDX0]], align 16
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test12-4
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR6]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
+; IS__CGSCC_NPM-NEXT:    store i64 0, i64* [[ARRAYIDX0]], align 16
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   %p-cast = bitcast i32* %p to i64*
   %arrayidx0 = getelementptr i64, i64* %p-cast, i64 0
   store i64 0, i64* %arrayidx0, align 16
   ret void
 }
 
 declare void @use(i64*) willreturn nounwind
 
 define void @test12-5(i32* align 4 %p) {
-; NOT_CGSCC_OPM: Function Attrs: nounwind willreturn
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test12-5
-; NOT_CGSCC_OPM-SAME: (i32* align 16 [[P:%.*]]) [[ATTR6:#.*]] {
-; NOT_CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; NOT_CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
-; NOT_CGSCC_OPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
-; NOT_CGSCC_OPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX1]]) [[ATTR6]]
-; NOT_CGSCC_OPM-NEXT:    ret void
+; IS__TUNIT____: Function Attrs: nounwind willreturn
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test12-5
+; IS__TUNIT____-SAME: (i32* align 16 [[P:%.*]]) #[[ATTR6:[0-9]+]] {
+; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
+; IS__TUNIT____-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
+; IS__TUNIT____-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX1]]) #[[ATTR6]]
+; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test12-5
-; IS__CGSCC_OPM-SAME: (i32* align 16 [[P:%.*]]) [[ATTR7:#.*]] {
+; IS__CGSCC_OPM-SAME: (i32* align 16 [[P:%.*]]) #[[ATTR8:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
 ; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
-; IS__CGSCC_OPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX1]]) [[ATTR7]]
+; IS__CGSCC_OPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX1]]) #[[ATTR8]]
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
+; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test12-5
+; IS__CGSCC_NPM-SAME: (i32* align 16 [[P:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 1
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr i64, i64* [[ARRAYIDX0]], i64 3
+; IS__CGSCC_NPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX1]]) #[[ATTR7]]
+; IS__CGSCC_NPM-NEXT:    ret void
+;
   %p-cast = bitcast i32* %p to i64*
   %arrayidx0 = getelementptr i64, i64* %p-cast, i64 1
   %arrayidx1 = getelementptr i64, i64* %arrayidx0, i64 3
   tail call void @use(i64* align 16 %arrayidx1)
   ret void
 }
 
 define void @test12-6(i32* align 4 %p) {
-; NOT_CGSCC_OPM: Function Attrs: nounwind willreturn
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test12-6
-; NOT_CGSCC_OPM-SAME: (i32* align 16 [[P:%.*]]) [[ATTR6]] {
-; NOT_CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
-; NOT_CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
-; NOT_CGSCC_OPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX0]]) [[ATTR6]]
-; NOT_CGSCC_OPM-NEXT:    ret void
+; IS__TUNIT____: Function Attrs: nounwind willreturn
+; IS__TUNIT____-LABEL: define {{[^@]+}}@test12-6
+; IS__TUNIT____-SAME: (i32* align 16 [[P:%.*]]) #[[ATTR6]] {
+; IS__TUNIT____-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__TUNIT____-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
+; IS__TUNIT____-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX0]]) #[[ATTR6]]
+; IS__TUNIT____-NEXT:    ret void
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test12-6
-; IS__CGSCC_OPM-SAME: (i32* align 16 [[P:%.*]]) [[ATTR7]] {
+; IS__CGSCC_OPM-SAME: (i32* align 16 [[P:%.*]]) #[[ATTR8]] {
 ; IS__CGSCC_OPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
 ; IS__CGSCC_OPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
-; IS__CGSCC_OPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX0]]) [[ATTR7]]
+; IS__CGSCC_OPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX0]]) #[[ATTR8]]
 ; IS__CGSCC_OPM-NEXT:    ret void
 ;
+; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test12-6
+; IS__CGSCC_NPM-SAME: (i32* align 16 [[P:%.*]]) #[[ATTR7]] {
+; IS__CGSCC_NPM-NEXT:    [[P_CAST:%.*]] = bitcast i32* [[P]] to i64*
+; IS__CGSCC_NPM-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr i64, i64* [[P_CAST]], i64 0
+; IS__CGSCC_NPM-NEXT:    tail call void @use(i64* align 16 [[ARRAYIDX0]]) #[[ATTR7]]
+; IS__CGSCC_NPM-NEXT:    ret void
+;
   %p-cast = bitcast i32* %p to i64*
   %arrayidx0 = getelementptr i64, i64* %p-cast, i64 0
   tail call void @use(i64* align 16 %arrayidx0)
   ret void
 }
 
 define void @test13(i1 %c, i32* align 32 %dst) #0 {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree noinline nosync nounwind uwtable willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test13
-; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR7:#.*]] {
+; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR7:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
 ; IS__TUNIT____:       truebb:
 ; IS__TUNIT____-NEXT:    br label [[END:%.*]]
 ; IS__TUNIT____:       falsebb:
 ; IS__TUNIT____-NEXT:    br label [[END]]
 ; IS__TUNIT____:       end:
 ; IS__TUNIT____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ]
 ; IS__TUNIT____-NEXT:    store i32 0, i32* [[PTR]], align 32
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree noinline norecurse nosync nounwind uwtable willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test13
-; IS__CGSCC____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR7:#.*]] {
-; IS__CGSCC____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
-; IS__CGSCC____:       truebb:
-; IS__CGSCC____-NEXT:    br label [[END:%.*]]
-; IS__CGSCC____:       falsebb:
-; IS__CGSCC____-NEXT:    br label [[END]]
-; IS__CGSCC____:       end:
-; IS__CGSCC____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ]
-; IS__CGSCC____-NEXT:    store i32 0, i32* [[PTR]], align 32
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree noinline norecurse nosync nounwind uwtable willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test13
+; IS__CGSCC_OPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_OPM:       truebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_OPM:       falsebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END]]
+; IS__CGSCC_OPM:       end:
+; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ]
+; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[PTR]], align 32
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree noinline norecurse nosync nounwind uwtable willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test13
+; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_NPM:       truebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_NPM:       falsebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END]]
+; IS__CGSCC_NPM:       end:
+; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ]
+; IS__CGSCC_NPM-NEXT:    store i32 0, i32* [[PTR]], align 32
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   br i1 %c, label %truebb, label %falsebb
 truebb:
   br label %end
 falsebb:
   br label %end
 end:
   %ptr = phi i32* [ %dst, %truebb ], [ null, %falsebb ]
   store i32 0, i32* %ptr
   ret void
 }
 
 define void @test13-1(i1 %c, i32* align 32 %dst) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test13-1
-; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR8:#.*]] {
+; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
 ; IS__TUNIT____:       truebb:
 ; IS__TUNIT____-NEXT:    br label [[END:%.*]]
 ; IS__TUNIT____:       falsebb:
 ; IS__TUNIT____-NEXT:    br label [[END]]
 ; IS__TUNIT____:       end:
 ; IS__TUNIT____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to i32*), [[FALSEBB]] ]
 ; IS__TUNIT____-NEXT:    store i32 0, i32* [[PTR]], align 16
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test13-1
-; IS__CGSCC____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR8:#.*]] {
-; IS__CGSCC____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
-; IS__CGSCC____:       truebb:
-; IS__CGSCC____-NEXT:    br label [[END:%.*]]
-; IS__CGSCC____:       falsebb:
-; IS__CGSCC____-NEXT:    br label [[END]]
-; IS__CGSCC____:       end:
-; IS__CGSCC____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to i32*), [[FALSEBB]] ]
-; IS__CGSCC____-NEXT:    store i32 0, i32* [[PTR]], align 16
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test13-1
+; IS__CGSCC_OPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR10:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_OPM:       truebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_OPM:       falsebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END]]
+; IS__CGSCC_OPM:       end:
+; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to i32*), [[FALSEBB]] ]
+; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[PTR]], align 16
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test13-1
+; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_NPM:       truebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_NPM:       falsebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END]]
+; IS__CGSCC_NPM:       end:
+; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to i32*), [[FALSEBB]] ]
+; IS__CGSCC_NPM-NEXT:    store i32 0, i32* [[PTR]], align 16
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   br i1 %c, label %truebb, label %falsebb
 truebb:
   br label %end
 falsebb:
   br label %end
 end:
   %ptr = phi i32* [ %dst, %truebb ], [ inttoptr (i64 48 to i32*), %falsebb ]
   store i32 0, i32* %ptr
   ret void
 }
 
 define void @test13-2(i1 %c, i32* align 32 %dst) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test13-2
-; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR8]] {
+; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8]] {
 ; IS__TUNIT____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
 ; IS__TUNIT____:       truebb:
 ; IS__TUNIT____-NEXT:    br label [[END:%.*]]
 ; IS__TUNIT____:       falsebb:
 ; IS__TUNIT____-NEXT:    br label [[END]]
 ; IS__TUNIT____:       end:
 ; IS__TUNIT____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to i32*), [[FALSEBB]] ]
 ; IS__TUNIT____-NEXT:    store i32 0, i32* [[PTR]], align 32
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test13-2
-; IS__CGSCC____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR8]] {
-; IS__CGSCC____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
-; IS__CGSCC____:       truebb:
-; IS__CGSCC____-NEXT:    br label [[END:%.*]]
-; IS__CGSCC____:       falsebb:
-; IS__CGSCC____-NEXT:    br label [[END]]
-; IS__CGSCC____:       end:
-; IS__CGSCC____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to i32*), [[FALSEBB]] ]
-; IS__CGSCC____-NEXT:    store i32 0, i32* [[PTR]], align 32
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test13-2
+; IS__CGSCC_OPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR10]] {
+; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_OPM:       truebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_OPM:       falsebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END]]
+; IS__CGSCC_OPM:       end:
+; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to i32*), [[FALSEBB]] ]
+; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[PTR]], align 32
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test13-2
+; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9]] {
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_NPM:       truebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_NPM:       falsebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END]]
+; IS__CGSCC_NPM:       end:
+; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to i32*), [[FALSEBB]] ]
+; IS__CGSCC_NPM-NEXT:    store i32 0, i32* [[PTR]], align 32
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   br i1 %c, label %truebb, label %falsebb
 truebb:
   br label %end
 falsebb:
   br label %end
 end:
   %ptr = phi i32* [ %dst, %truebb ], [ inttoptr (i64 160 to i32*), %falsebb ]
   store i32 0, i32* %ptr
   ret void
 }
 
 define void @test13-3(i1 %c, i32* align 32 %dst) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test13-3
-; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR8]] {
+; IS__TUNIT____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8]] {
 ; IS__TUNIT____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
 ; IS__TUNIT____:       truebb:
 ; IS__TUNIT____-NEXT:    br label [[END:%.*]]
 ; IS__TUNIT____:       falsebb:
 ; IS__TUNIT____-NEXT:    br label [[END]]
 ; IS__TUNIT____:       end:
 ; IS__TUNIT____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to i32*), [[FALSEBB]] ]
 ; IS__TUNIT____-NEXT:    store i32 0, i32* [[PTR]], align 32
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@test13-3
-; IS__CGSCC____-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) [[ATTR8]] {
-; IS__CGSCC____-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
-; IS__CGSCC____:       truebb:
-; IS__CGSCC____-NEXT:    br label [[END:%.*]]
-; IS__CGSCC____:       falsebb:
-; IS__CGSCC____-NEXT:    br label [[END]]
-; IS__CGSCC____:       end:
-; IS__CGSCC____-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to i32*), [[FALSEBB]] ]
-; IS__CGSCC____-NEXT:    store i32 0, i32* [[PTR]], align 32
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test13-3
+; IS__CGSCC_OPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR10]] {
+; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_OPM:       truebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_OPM:       falsebb:
+; IS__CGSCC_OPM-NEXT:    br label [[END]]
+; IS__CGSCC_OPM:       end:
+; IS__CGSCC_OPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to i32*), [[FALSEBB]] ]
+; IS__CGSCC_OPM-NEXT:    store i32 0, i32* [[PTR]], align 32
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test13-3
+; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]], i32* nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9]] {
+; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
+; IS__CGSCC_NPM:       truebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END:%.*]]
+; IS__CGSCC_NPM:       falsebb:
+; IS__CGSCC_NPM-NEXT:    br label [[END]]
+; IS__CGSCC_NPM:       end:
+; IS__CGSCC_NPM-NEXT:    [[PTR:%.*]] = phi i32* [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to i32*), [[FALSEBB]] ]
+; IS__CGSCC_NPM-NEXT:    store i32 0, i32* [[PTR]], align 32
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   br i1 %c, label %truebb, label %falsebb
 truebb:
   br label %end
 falsebb:
   br label %end
 end:
   %ptr = phi i32* [ %dst, %truebb ], [ inttoptr (i64 128 to i32*), %falsebb ]
   store i32 0, i32* %ptr
   ret void
 }
 
 ; Don't crash on ptr2int/int2ptr uses.
 define i64 @ptr2int(i32* %p) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ptr2int
-; IS__TUNIT____-SAME: (i32* nofree readnone [[P:%.*]]) [[ATTR9]] {
+; IS__TUNIT____-SAME: (i32* nofree readnone [[P:%.*]]) #[[ATTR9]] {
 ; IS__TUNIT____-NEXT:    [[P2I:%.*]] = ptrtoint i32* [[P]] to i64
 ; IS__TUNIT____-NEXT:    ret i64 [[P2I]]
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@ptr2int
-; IS__CGSCC____-SAME: (i32* nofree readnone [[P:%.*]]) [[ATTR9:#.*]] {
-; IS__CGSCC____-NEXT:    [[P2I:%.*]] = ptrtoint i32* [[P]] to i64
-; IS__CGSCC____-NEXT:    ret i64 [[P2I]]
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@ptr2int
+; IS__CGSCC_OPM-SAME: (i32* nofree readnone [[P:%.*]]) #[[ATTR11:[0-9]+]] {
+; IS__CGSCC_OPM-NEXT:    [[P2I:%.*]] = ptrtoint i32* [[P]] to i64
+; IS__CGSCC_OPM-NEXT:    ret i64 [[P2I]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@ptr2int
+; IS__CGSCC_NPM-SAME: (i32* nofree readnone [[P:%.*]]) #[[ATTR10:[0-9]+]] {
+; IS__CGSCC_NPM-NEXT:    [[P2I:%.*]] = ptrtoint i32* [[P]] to i64
+; IS__CGSCC_NPM-NEXT:    ret i64 [[P2I]]
 ;
   %p2i = ptrtoint i32* %p to i64
   ret i64 %p2i
 }
 define i64* @int2ptr(i64 %i) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@int2ptr
-; IS__TUNIT____-SAME: (i64 [[I:%.*]]) [[ATTR9]] {
+; IS__TUNIT____-SAME: (i64 [[I:%.*]]) #[[ATTR9]] {
 ; IS__TUNIT____-NEXT:    [[I2P:%.*]] = inttoptr i64 [[I]] to i64*
 ; IS__TUNIT____-NEXT:    ret i64* [[I2P]]
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@int2ptr
-; IS__CGSCC____-SAME: (i64 [[I:%.*]]) [[ATTR9]] {
-; IS__CGSCC____-NEXT:    [[I2P:%.*]] = inttoptr i64 [[I]] to i64*
-; IS__CGSCC____-NEXT:    ret i64* [[I2P]]
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@int2ptr
+; IS__CGSCC_OPM-SAME: (i64 [[I:%.*]]) #[[ATTR11]] {
+; IS__CGSCC_OPM-NEXT:    [[I2P:%.*]] = inttoptr i64 [[I]] to i64*
+; IS__CGSCC_OPM-NEXT:    ret i64* [[I2P]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@int2ptr
+; IS__CGSCC_NPM-SAME: (i64 [[I:%.*]]) #[[ATTR10]] {
+; IS__CGSCC_NPM-NEXT:    [[I2P:%.*]] = inttoptr i64 [[I]] to i64*
+; IS__CGSCC_NPM-NEXT:    ret i64* [[I2P]]
 ;
   %i2p = inttoptr i64 %i to i64*
   ret i64* %i2p
 }
 
 ; Use the store alignment only for the pointer operand.
 define void @aligned_store(i8* %Value, i8** %Ptr) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@aligned_store
-; IS__TUNIT____-SAME: (i8* nofree writeonly [[VALUE:%.*]], i8** nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) [[ATTR5]] {
+; IS__TUNIT____-SAME: (i8* nofree writeonly [[VALUE:%.*]], i8** nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR5]] {
 ; IS__TUNIT____-NEXT:    store i8* [[VALUE]], i8** [[PTR]], align 32
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@aligned_store
-; IS__CGSCC____-SAME: (i8* nofree writeonly [[VALUE:%.*]], i8** nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) [[ATTR5]] {
-; IS__CGSCC____-NEXT:    store i8* [[VALUE]], i8** [[PTR]], align 32
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@aligned_store
+; IS__CGSCC_OPM-SAME: (i8* nofree writeonly [[VALUE:%.*]], i8** nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR7]] {
+; IS__CGSCC_OPM-NEXT:    store i8* [[VALUE]], i8** [[PTR]], align 32
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@aligned_store
+; IS__CGSCC_NPM-SAME: (i8* nofree writeonly [[VALUE:%.*]], i8** nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR6]] {
+; IS__CGSCC_NPM-NEXT:    store i8* [[VALUE]], i8** [[PTR]], align 32
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   store i8* %Value, i8** %Ptr, align 32
   ret void
 }
 
 declare i8* @some_func(i8*)
 define void @align_call_op_not_store(i8* align 2048 %arg) {
 ; CHECK-LABEL: define {{[^@]+}}@align_call_op_not_store
 ; CHECK-SAME: (i8* align 2048 [[ARG:%.*]]) {
 ; CHECK-NEXT:    [[UNKNOWN:%.*]] = call i8* @some_func(i8* align 2048 [[ARG]])
 ; CHECK-NEXT:    store i8 0, i8* [[UNKNOWN]], align 1
 ; CHECK-NEXT:    ret void
 ;
   %unknown = call i8* @some_func(i8* %arg)
   store i8 0, i8* %unknown
   ret void
 }
 define void @align_store_after_bc(i32* align 2048 %arg) {
 ;
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@align_store_after_bc
-; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) [[ATTR5]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR5]] {
 ; IS__TUNIT____-NEXT:    [[BC:%.*]] = bitcast i32* [[ARG]] to i8*
 ; IS__TUNIT____-NEXT:    store i8 0, i8* [[BC]], align 2048
 ; IS__TUNIT____-NEXT:    ret void
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
-; IS__CGSCC____-LABEL: define {{[^@]+}}@align_store_after_bc
-; IS__CGSCC____-SAME: (i32* nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) [[ATTR5]] {
-; IS__CGSCC____-NEXT:    [[BC:%.*]] = bitcast i32* [[ARG]] to i8*
-; IS__CGSCC____-NEXT:    store i8 0, i8* [[BC]], align 2048
-; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@align_store_after_bc
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR7]] {
+; IS__CGSCC_OPM-NEXT:    [[BC:%.*]] = bitcast i32* [[ARG]] to i8*
+; IS__CGSCC_OPM-NEXT:    store i8 0, i8* [[BC]], align 2048
+; IS__CGSCC_OPM-NEXT:    ret void
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@align_store_after_bc
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR6]] {
+; IS__CGSCC_NPM-NEXT:    [[BC:%.*]] = bitcast i32* [[ARG]] to i8*
+; IS__CGSCC_NPM-NEXT:    store i8 0, i8* [[BC]], align 2048
+; IS__CGSCC_NPM-NEXT:    ret void
 ;
   %bc = bitcast i32* %arg to i8*
   store i8 0, i8* %bc
   ret void
 }
 
 ; Make sure we do not annotate the callee of a must-tail call with an alignment
 ; we cannot also put on the caller.
 @cnd = external global i1
 define i32 @musttail_callee_1(i32* %p) {
 ; IS__TUNIT____: Function Attrs: argmemonly nofree nosync nounwind readonly willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@musttail_callee_1
-; IS__TUNIT____-SAME: (i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) [[ATTR4]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR4]] {
 ; IS__TUNIT____-NEXT:    [[V:%.*]] = load i32, i32* [[P]], align 32
 ; IS__TUNIT____-NEXT:    ret i32 [[V]]
 ;
-; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@musttail_callee_1
-; IS__CGSCC____-SAME: (i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) [[ATTR4]] {
-; IS__CGSCC____-NEXT:    [[V:%.*]] = load i32, i32* [[P]], align 32
-; IS__CGSCC____-NEXT:    ret i32 [[V]]
+; IS__CGSCC_OPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@musttail_callee_1
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR6]] {
+; IS__CGSCC_OPM-NEXT:    [[V:%.*]] = load i32, i32* [[P]], align 32
+; IS__CGSCC_OPM-NEXT:    ret i32 [[V]]
+;
+; IS__CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nosync nounwind readonly willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@musttail_callee_1
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR5]] {
+; IS__CGSCC_NPM-NEXT:    [[V:%.*]] = load i32, i32* [[P]], align 32
+; IS__CGSCC_NPM-NEXT:    ret i32 [[V]]
 ;
   %v = load i32, i32* %p, align 32
   ret i32 %v
 }
 define i32 @musttail_caller_1(i32* %p) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readonly willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@musttail_caller_1
-; IS__TUNIT____-SAME: (i32* nocapture nofree readonly [[P:%.*]]) [[ATTR10:#.*]] {
+; IS__TUNIT____-SAME: (i32* nocapture nofree readonly [[P:%.*]]) #[[ATTR10:[0-9]+]] {
 ; IS__TUNIT____-NEXT:    [[C:%.*]] = load i1, i1* @cnd, align 1
 ; IS__TUNIT____-NEXT:    br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]]
 ; IS__TUNIT____:       mt:
-; IS__TUNIT____-NEXT:    [[V:%.*]] = musttail call i32 @musttail_callee_1(i32* nocapture nofree readonly [[P]]) [[ATTR10]]
+; IS__TUNIT____-NEXT:    [[V:%.*]] = musttail call i32 @musttail_callee_1(i32* nocapture nofree readonly [[P]]) #[[ATTR10]]
 ; IS__TUNIT____-NEXT:    ret i32 [[V]]
 ; IS__TUNIT____:       exit:
 ; IS__TUNIT____-NEXT:    ret i32 0
 ;
 ; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readonly willreturn
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@musttail_caller_1
-; IS__CGSCC_OPM-SAME: (i32* nocapture nofree readonly [[P:%.*]]) [[ATTR11:#.*]] {
+; IS__CGSCC_OPM-SAME: (i32* nocapture nofree readonly [[P:%.*]]) #[[ATTR12:[0-9]+]] {
 ; IS__CGSCC_OPM-NEXT:    [[C:%.*]] = load i1, i1* @cnd, align 1
 ; IS__CGSCC_OPM-NEXT:    br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]]
 ; IS__CGSCC_OPM:       mt:
-; IS__CGSCC_OPM-NEXT:    [[V:%.*]] = musttail call i32 @musttail_callee_1(i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P]]) [[ATTR13:#.*]]
+; IS__CGSCC_OPM-NEXT:    [[V:%.*]] = musttail call i32 @musttail_callee_1(i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P]]) #[[ATTR14:[0-9]+]]
 ; IS__CGSCC_OPM-NEXT:    ret i32 [[V]]
 ; IS__CGSCC_OPM:       exit:
 ; IS__CGSCC_OPM-NEXT:    ret i32 0
 ;
 ; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readonly willreturn
 ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@musttail_caller_1
-; IS__CGSCC_NPM-SAME: (i32* nocapture nofree readonly [[P:%.*]]) [[ATTR10:#.*]] {
+; IS__CGSCC_NPM-SAME: (i32* nocapture nofree readonly [[P:%.*]]) #[[ATTR11:[0-9]+]] {
 ; IS__CGSCC_NPM-NEXT:    [[C:%.*]] = load i1, i1* @cnd, align 1
 ; IS__CGSCC_NPM-NEXT:    br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]]
 ; IS__CGSCC_NPM:       mt:
-; IS__CGSCC_NPM-NEXT:    [[V:%.*]] = musttail call i32 @musttail_callee_1(i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P]]) [[ATTR12:#.*]]
+; IS__CGSCC_NPM-NEXT:    [[V:%.*]] = musttail call i32 @musttail_callee_1(i32* nocapture nofree noundef nonnull readonly dereferenceable(4) [[P]]) #[[ATTR13:[0-9]+]]
 ; IS__CGSCC_NPM-NEXT:    ret i32 [[V]]
 ; IS__CGSCC_NPM:       exit:
 ; IS__CGSCC_NPM-NEXT:    ret i32 0
 ;
   %c = load i1, i1* @cnd
   br i1 %c, label %mt, label %exit
 mt:
   %v = musttail call i32 @musttail_callee_1(i32* %p)
   ret i32 %v
 exit:
   ret i32 0
 }
 
 define i32* @checkAndAdvance(i32* align(16) %p) {
-; NOT_CGSCC_OPM: Function Attrs: nounwind
-; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@checkAndAdvance
-; NOT_CGSCC_OPM-SAME: (i32* noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) [[ATTR2]] {
-; NOT_CGSCC_OPM-NEXT:  entry:
-; NOT_CGSCC_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* [[P]], align 16
-; NOT_CGSCC_OPM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
-; NOT_CGSCC_OPM-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
-; NOT_CGSCC_OPM:       if.then:
-; NOT_CGSCC_OPM-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[P]], i64 4
-; NOT_CGSCC_OPM-NEXT:    [[CALL:%.*]] = call nonnull align 16 i32* @checkAndAdvance(i32* nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    br label [[RETURN]]
-; NOT_CGSCC_OPM:       return:
-; NOT_CGSCC_OPM-NEXT:    [[RETVAL_0:%.*]] = phi i32* [ [[CALL]], [[IF_THEN]] ], [ [[P]], [[ENTRY:%.*]] ]
-; NOT_CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) [[ATTR2]]
-; NOT_CGSCC_OPM-NEXT:    ret i32* [[RETVAL_0]]
+; IS__TUNIT____: Function Attrs: nounwind
+; IS__TUNIT____-LABEL: define {{[^@]+}}@checkAndAdvance
+; IS__TUNIT____-SAME: (i32* noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR2]] {
+; IS__TUNIT____-NEXT:  entry:
+; IS__TUNIT____-NEXT:    [[TMP0:%.*]] = load i32, i32* [[P]], align 16
+; IS__TUNIT____-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+; IS__TUNIT____-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
+; IS__TUNIT____:       if.then:
+; IS__TUNIT____-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[P]], i64 4
+; IS__TUNIT____-NEXT:    [[CALL:%.*]] = call nonnull align 16 i32* @checkAndAdvance(i32* nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    br label [[RETURN]]
+; IS__TUNIT____:       return:
+; IS__TUNIT____-NEXT:    [[RETVAL_0:%.*]] = phi i32* [ [[CALL]], [[IF_THEN]] ], [ [[P]], [[ENTRY:%.*]] ]
+; IS__TUNIT____-NEXT:    call void @user_i32_ptr(i32* noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR2]]
+; IS__TUNIT____-NEXT:    ret i32* [[RETVAL_0]]
 ;
 ; IS__CGSCC_OPM: Function Attrs: nounwind
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@checkAndAdvance
-; IS__CGSCC_OPM-SAME: (i32* noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) [[ATTR3]] {
+; IS__CGSCC_OPM-SAME: (i32* noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR4]] {
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    [[TMP0:%.*]] = load i32, i32* [[P]], align 16
 ; IS__CGSCC_OPM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
 ; IS__CGSCC_OPM-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
 ; IS__CGSCC_OPM:       if.then:
 ; IS__CGSCC_OPM-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[P]], i64 4
-; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call nonnull align 16 i32* @checkAndAdvance(i32* nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) [[ATTR3]]
+; IS__CGSCC_OPM-NEXT:    [[CALL:%.*]] = call nonnull align 16 i32* @checkAndAdvance(i32* nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR4]]
 ; IS__CGSCC_OPM-NEXT:    br label [[RETURN]]
 ; IS__CGSCC_OPM:       return:
 ; IS__CGSCC_OPM-NEXT:    [[RETVAL_0:%.*]] = phi i32* [ [[CALL]], [[IF_THEN]] ], [ [[P]], [[ENTRY:%.*]] ]
-; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) [[ATTR3]]
+; IS__CGSCC_OPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR4]]
 ; IS__CGSCC_OPM-NEXT:    ret i32* [[RETVAL_0]]
 ;
+; IS__CGSCC_NPM: Function Attrs: nounwind
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@checkAndAdvance
+; IS__CGSCC_NPM-SAME: (i32* noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR3]] {
+; IS__CGSCC_NPM-NEXT:  entry:
+; IS__CGSCC_NPM-NEXT:    [[TMP0:%.*]] = load i32, i32* [[P]], align 16
+; IS__CGSCC_NPM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+; IS__CGSCC_NPM-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
+; IS__CGSCC_NPM:       if.then:
+; IS__CGSCC_NPM-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i32, i32* [[P]], i64 4
+; IS__CGSCC_NPM-NEXT:    [[CALL:%.*]] = call nonnull align 16 i32* @checkAndAdvance(i32* nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    br label [[RETURN]]
+; IS__CGSCC_NPM:       return:
+; IS__CGSCC_NPM-NEXT:    [[RETVAL_0:%.*]] = phi i32* [ [[CALL]], [[IF_THEN]] ], [ [[P]], [[ENTRY:%.*]] ]
+; IS__CGSCC_NPM-NEXT:    call void @user_i32_ptr(i32* noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR3]]
+; IS__CGSCC_NPM-NEXT:    ret i32* [[RETVAL_0]]
+;
 entry:
   %0 = load i32, i32* %p, align 4
   %cmp = icmp eq i32 %0, 0
   br i1 %cmp, label %if.then, label %return
 
 if.then:                                          ; preds = %entry
   %add.ptr = getelementptr inbounds i32, i32* %p, i64 4
   %call = call i32* @checkAndAdvance(i32* nonnull %add.ptr)

 }
 
 declare void @align4_callee(i8* align(4) %p)
 
 
 attributes #0 = { nounwind uwtable noinline }
 attributes #1 = { uwtable noinline }
 attributes #2 = { null_pointer_is_valid }
+; IS__TUNIT____: attributes #[[ATTR0]] = { nofree noinline nosync nounwind readnone uwtable willreturn }
+; IS__TUNIT____: attributes #[[ATTR1]] = { nofree noinline noreturn nosync nounwind readnone uwtable }
+; IS__TUNIT____: attributes #[[ATTR2]] = { nounwind }
+; IS__TUNIT____: attributes #[[ATTR3]] = { nofree nosync nounwind }
+; IS__TUNIT____: attributes #[[ATTR4]] = { argmemonly nofree nosync nounwind readonly willreturn }
+; IS__TUNIT____: attributes #[[ATTR5]] = { argmemonly nofree nosync nounwind willreturn writeonly }
+; IS__TUNIT____: attributes #[[ATTR6]] = { nounwind willreturn }
+; IS__TUNIT____: attributes #[[ATTR7]] = { argmemonly nofree noinline nosync nounwind uwtable willreturn writeonly }
+; IS__TUNIT____: attributes #[[ATTR8]] = { nofree nosync nounwind willreturn writeonly }
+; IS__TUNIT____: attributes #[[ATTR9]] = { nofree nosync nounwind readnone willreturn }
+; IS__TUNIT____: attributes #[[ATTR10]] = { nofree nosync nounwind readonly willreturn }
+; IS__TUNIT____: attributes #[[ATTR11]] = { nofree noreturn nosync nounwind readnone }
+;.
+; IS__CGSCC_OPM: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind readnone uwtable willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR1]] = { nofree noinline noreturn nosync nounwind readnone uwtable }
+; IS__CGSCC_OPM: attributes #[[ATTR2]] = { nofree noinline nosync nounwind readnone uwtable willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR3]] = { noinline nounwind uwtable }
+; IS__CGSCC_OPM: attributes #[[ATTR4]] = { nounwind }
+; IS__CGSCC_OPM: attributes #[[ATTR5]] = { nofree nosync nounwind }
+; IS__CGSCC_OPM: attributes #[[ATTR6]] = { argmemonly nofree norecurse nosync nounwind readonly willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR7]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR8]] = { nounwind willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR9]] = { argmemonly nofree noinline norecurse nosync nounwind uwtable willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR10]] = { nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC_OPM: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind readnone willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR12]] = { nofree norecurse nosync nounwind readonly willreturn }
+; IS__CGSCC_OPM: attributes #[[ATTR13]] = { nofree noreturn nosync nounwind readnone }
+; IS__CGSCC_OPM: attributes #[[ATTR14]] = { readonly willreturn }
+;.
+; IS__CGSCC_NPM: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind readnone uwtable willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR1]] = { nofree noinline noreturn nosync nounwind readnone uwtable }
+; IS__CGSCC_NPM: attributes #[[ATTR2]] = { noinline nounwind uwtable }
+; IS__CGSCC_NPM: attributes #[[ATTR3]] = { nounwind }
+; IS__CGSCC_NPM: attributes #[[ATTR4]] = { nofree nosync nounwind }
+; IS__CGSCC_NPM: attributes #[[ATTR5]] = { argmemonly nofree norecurse nosync nounwind readonly willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR6]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR7]] = { nounwind willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR8]] = { argmemonly nofree noinline norecurse nosync nounwind uwtable willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC_NPM: attributes #[[ATTR10]] = { nofree norecurse nosync nounwind readnone willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind readonly willreturn }
+; IS__CGSCC_NPM: attributes #[[ATTR12]] = { nofree noreturn nosync nounwind readnone }
+; IS__CGSCC_NPM: attributes #[[ATTR13]] = { readonly willreturn }

llvm/test/Transforms/Attributor/liveness.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=39 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=39 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; TODO: The old pass manager cgscc run is disabled as it causes a crash on windows which is under investigation: http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/23151
 ; 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
 ; 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
 
-; NOT_CGSCC_OPM: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
-; IS__CGSCC_OPM: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
+; NOT_CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
+; IS__CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
 @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 nosync
 
 declare void @normal_call() readnone
 
 declare i32 @foo()
 
 declare i32 @foo_nounwind() nounwind
 
 declare i32 @foo_noreturn_nounwind() noreturn nounwind
 
 declare i32 @foo_noreturn() noreturn
 
 declare i32 @bar() nosync readnone
 
 ; This internal function has no live call sites, so all its BBs are considered dead,
 ; and nothing should be deduced for it.
 
 define internal i32 @dead_internal_func(i32 %0) {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@dead_internal_func
-; IS__CGSCC____-SAME: () [[ATTR6:#.*]] {
+; IS__CGSCC____-SAME: () #[[ATTR6:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    br label [[TMP2:%.*]]
 ; IS__CGSCC____:       1:
 ; IS__CGSCC____-NEXT:    ret i32 undef
 ; IS__CGSCC____:       2:
 ; IS__CGSCC____-NEXT:    [[TMP3:%.*]] = phi i32 [ [[TMP6:%.*]], [[TMP2]] ], [ 1, [[TMP0:%.*]] ]
 ; IS__CGSCC____-NEXT:    [[TMP4:%.*]] = phi i32 [ [[TMP5:%.*]], [[TMP2]] ], [ 1, [[TMP0]] ]
 ; IS__CGSCC____-NEXT:    [[TMP5]] = mul nsw i32 [[TMP3]], [[TMP4]]
 ; IS__CGSCC____-NEXT:    [[TMP6]] = add nuw nsw i32 [[TMP3]], 1
; <label>:5:                                      ; preds = %1, %5
   %7 = phi i32 [ %8, %5 ], [ 1, %1 ]
   %8 = mul nsw i32 %6, %7
   %9 = add nuw nsw i32 %6, 1
   %10 = icmp eq i32 %6, %0
   br i1 %10, label %3, label %5
 }
 
 define i32 @volatile_load(i32*) norecurse nounwind uwtable {
-; CHECK: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
-; CHECK-LABEL: define {{[^@]+}}@volatile_load
-; CHECK-SAME: (i32* nofree align 4 [[TMP0:%.*]]) [[ATTR7:#.*]] {
-; CHECK-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
-; CHECK-NEXT:    ret i32 [[TMP2]]
+; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@volatile_load
+; NOT_CGSCC_NPM-SAME: (i32* nofree align 4 [[TMP0:%.*]]) #[[ATTR6:[0-9]+]] {
+; NOT_CGSCC_NPM-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
+; NOT_CGSCC_NPM-NEXT:    ret i32 [[TMP2]]
+;
+; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nounwind uwtable willreturn
+; IS__CGSCC____-LABEL: define {{[^@]+}}@volatile_load
+; IS__CGSCC____-SAME: (i32* nofree align 4 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
+; IS__CGSCC____-NEXT:    [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
+; IS__CGSCC____-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = load volatile i32, i32* %0, align 4
   ret i32 %2
 }
 
 define internal i32 @internal_load(i32*) norecurse nounwind uwtable {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@internal_load
-; IS__CGSCC____-SAME: () [[ATTR8:#.*]] {
+; IS__CGSCC____-SAME: () #[[ATTR8:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    ret i32 undef
 ;
   %2 = load i32, i32* %0, align 4
   ret i32 %2
 }
 ; TEST 1: Only first block is live.
 
 define i32 @first_block_no_return(i32 %a, i32* nonnull %ptr1, i32* %ptr2) #0 {
 ; CHECK: Function Attrs: nofree noreturn nosync nounwind
 ; CHECK-LABEL: define {{[^@]+}}@first_block_no_return
-; CHECK-SAME: (i32 [[A:%.*]], i32* nocapture nofree nonnull readnone [[PTR1:%.*]], i32* nocapture nofree readnone [[PTR2:%.*]]) [[ATTR0:#.*]] {
+; CHECK-SAME: (i32 [[A:%.*]], i32* nocapture nofree nonnull readnone [[PTR1:%.*]], i32* nocapture nofree readnone [[PTR2:%.*]]) #[[ATTR0:[0-9]+]] {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @no_return_call() [[ATTR3:#.*]]
+; CHECK-NEXT:    call void @no_return_call() #[[ATTR3:[0-9]+]]
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    unreachable
 ;

 }
 
 ; TEST 2: cond.true is dead, but cond.end is not, since cond.false is live
 
 ; This is just an example. For example we can put a sync call in a
 ; dead block and check if it is deduced.
 
 define i32 @dead_block_present(i32 %a, i32* %ptr1) #0 {
-; CHECK: Function Attrs: nosync
-; CHECK-LABEL: define {{[^@]+}}@dead_block_present
-; CHECK-SAME: (i32 [[A:%.*]], i32* nocapture nofree readnone [[PTR1:%.*]]) [[ATTR9:#.*]] {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
-; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
-; CHECK:       cond.true:
-; CHECK-NEXT:    call void @no_return_call() [[ATTR3]]
-; CHECK-NEXT:    unreachable
-; CHECK:       cond.false:
-; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
-; CHECK-NEXT:    br label [[COND_END:%.*]]
-; CHECK:       cond.end:
-; CHECK-NEXT:    ret i32 [[CALL1]]
+; NOT_CGSCC_NPM: Function Attrs: nosync
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@dead_block_present
+; NOT_CGSCC_NPM-SAME: (i32 [[A:%.*]], i32* nocapture nofree readnone [[PTR1:%.*]]) #[[ATTR7:[0-9]+]] {
+; NOT_CGSCC_NPM-NEXT:  entry:
+; NOT_CGSCC_NPM-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
+; NOT_CGSCC_NPM-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; NOT_CGSCC_NPM:       cond.true:
+; NOT_CGSCC_NPM-NEXT:    call void @no_return_call() #[[ATTR3]]
+; NOT_CGSCC_NPM-NEXT:    unreachable
+; NOT_CGSCC_NPM:       cond.false:
+; NOT_CGSCC_NPM-NEXT:    call void @normal_call()
+; NOT_CGSCC_NPM-NEXT:    [[CALL1:%.*]] = call i32 @bar()
+; NOT_CGSCC_NPM-NEXT:    br label [[COND_END:%.*]]
+; NOT_CGSCC_NPM:       cond.end:
+; NOT_CGSCC_NPM-NEXT:    ret i32 [[CALL1]]
+;
+; IS__CGSCC____: Function Attrs: nosync
+; IS__CGSCC____-LABEL: define {{[^@]+}}@dead_block_present
+; IS__CGSCC____-SAME: (i32 [[A:%.*]], i32* nocapture nofree readnone [[PTR1:%.*]]) #[[ATTR9:[0-9]+]] {
+; IS__CGSCC____-NEXT:  entry:
+; IS__CGSCC____-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
+; IS__CGSCC____-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; IS__CGSCC____:       cond.true:
+; IS__CGSCC____-NEXT:    call void @no_return_call() #[[ATTR3]]
+; IS__CGSCC____-NEXT:    unreachable
+; IS__CGSCC____:       cond.false:
+; IS__CGSCC____-NEXT:    call void @normal_call()
+; IS__CGSCC____-NEXT:    [[CALL1:%.*]] = call i32 @bar()
+; IS__CGSCC____-NEXT:    br label [[COND_END:%.*]]
+; IS__CGSCC____:       cond.end:
+; IS__CGSCC____-NEXT:    ret i32 [[CALL1]]
 ;
 entry:
   %cmp = icmp eq i32 %a, 0
   br i1 %cmp, label %cond.true, label %cond.false
 
 cond.true:                                        ; preds = %entry
   call void @no_return_call()
   %call = call i32 @volatile_load(i32* %ptr1)
cond.end:                                         ; preds = %cond.false, %cond.true
   ret i32 %cond
 }
 
 ; TEST 3: both cond.true and cond.false are dead, therfore cond.end is dead as well.
 
 define i32 @all_dead(i32 %a) #0 {
 ; CHECK: Function Attrs: nofree noreturn nosync nounwind
 ; CHECK-LABEL: define {{[^@]+}}@all_dead
-; CHECK-SAME: (i32 [[A:%.*]]) [[ATTR0]] {
+; CHECK-SAME: (i32 [[A:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
-; CHECK-NEXT:    call void @no_return_call() [[ATTR3]]
+; CHECK-NEXT:    call void @no_return_call() #[[ATTR3]]
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.false:
-; CHECK-NEXT:    call void @no_return_call() [[ATTR3]]
+; CHECK-NEXT:    call void @no_return_call() #[[ATTR3]]
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    unreachable
 ;
 entry:
   %cmp = icmp eq i32 %a, 0
   br i1 %cmp, label %cond.true, label %cond.false
 

 define i32 @all_live(i32 %a) #0 {
 ; CHECK-LABEL: define {{[^@]+}}@all_live
 ; CHECK-SAME: (i32 [[A:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_noreturn() [[ATTR4:#.*]]
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_noreturn() #[[ATTR4:[0-9]+]]
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    call void @normal_call()
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
 ; CHECK-NEXT:    br label [[COND_END:%.*]]
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    ret i32 [[CALL1]]
 ;

 define i32 @invoke_noreturn(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: define {{[^@]+}}@invoke_noreturn
 ; CHECK-SAME: (i32 [[A:%.*]]) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL:%.*]] = invoke i32 @foo_noreturn() [[ATTR4]]
+; CHECK-NEXT:    [[CALL:%.*]] = invoke i32 @foo_noreturn() #[[ATTR4]]
 ; CHECK-NEXT:    to label [[CONTINUE:%.*]] unwind label [[CLEANUP:%.*]]
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    call void @normal_call()
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
 ; CHECK-NEXT:    br label [[COND_END:%.*]]
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    ret i32 [[CALL1]]
 ; CHECK:       continue:

 define i32 @invoke_noreturn_nounwind(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: define {{[^@]+}}@invoke_noreturn_nounwind
 ; CHECK-SAME: (i32 [[A:%.*]]) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_noreturn_nounwind() [[ATTR3]]
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_noreturn_nounwind() #[[ATTR3]]
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    call void @normal_call()
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
 ; CHECK-NEXT:    br label [[COND_END:%.*]]
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    ret i32 [[CALL1]]
 ; CHECK:       continue:

 define i32 @invoke_nounwind(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: define {{[^@]+}}@invoke_nounwind
 ; CHECK-SAME: (i32 [[A:%.*]]) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_nounwind() [[ATTR2:#.*]]
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_nounwind() #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    br label [[CONTINUE:%.*]]
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    call void @normal_call()
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
 ; CHECK-NEXT:    br label [[COND_END:%.*]]
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    [[COND:%.*]] = phi i32 [ [[CALL]], [[CONTINUE]] ], [ [[CALL1]], [[COND_FALSE]] ]
 ; CHECK-NEXT:    ret i32 [[COND]]

 define i32 @invoke_nounwind_phi(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: define {{[^@]+}}@invoke_nounwind_phi
 ; CHECK-SAME: (i32 [[A:%.*]]) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_nounwind() [[ATTR2]]
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_nounwind() #[[ATTR2]]
 ; CHECK-NEXT:    br label [[CONTINUE:%.*]]
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    call void @normal_call()
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
 ; CHECK-NEXT:    br label [[CONTINUE]]
 ; CHECK:       continue:
 ; CHECK-NEXT:    [[P:%.*]] = phi i32 [ 0, [[COND_TRUE]] ], [ 1, [[COND_FALSE]] ]
 ; CHECK-NEXT:    ret i32 [[P]]

 define i32 @invoke_nounwind_phi_dom(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: define {{[^@]+}}@invoke_nounwind_phi_dom
 ; CHECK-SAME: (i32 [[A:%.*]]) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    call void @normal_call()
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_nounwind() [[ATTR2]]
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_nounwind() #[[ATTR2]]
 ; CHECK-NEXT:    br label [[CONTINUE:%.*]]
 ; CHECK:       cond.false:
 ; CHECK-NEXT:    call void @normal_call()
 ; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @bar()
 ; CHECK-NEXT:    br label [[CONTINUE]]
 ; CHECK:       continue:
 ; CHECK-NEXT:    [[P:%.*]] = phi i32 [ [[CALL]], [[COND_TRUE]] ], [ [[CALL1]], [[COND_FALSE]] ]
 ; CHECK-NEXT:    ret i32 [[P]]

 }
 
 ; TEST 6: Undefined behvior, taken from LangRef.
 ; FIXME: Should be able to detect undefined behavior.
 
 define void @ub(i32* %0) {
 ; NOT_CGSCC_NPM: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@ub
-; NOT_CGSCC_NPM-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) [[ATTR8:#.*]] {
+; NOT_CGSCC_NPM-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR8:[0-9]+]] {
 ; NOT_CGSCC_NPM-NEXT:    [[POISON:%.*]] = sub nuw i32 0, 1
 ; NOT_CGSCC_NPM-NEXT:    [[STILL_POISON:%.*]] = and i32 [[POISON]], 0
 ; NOT_CGSCC_NPM-NEXT:    [[POISON_YET_AGAIN:%.*]] = getelementptr i32, i32* [[TMP0]], i32 [[STILL_POISON]]
 ; NOT_CGSCC_NPM-NEXT:    store i32 0, i32* [[POISON_YET_AGAIN]], align 4
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: argmemonly nofree norecurse nosync nounwind willreturn writeonly
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ub
-; IS__CGSCC____-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) [[ATTR10:#.*]] {
+; IS__CGSCC____-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR10:[0-9]+]] {
 ; IS__CGSCC____-NEXT:    [[POISON:%.*]] = sub nuw i32 0, 1
 ; IS__CGSCC____-NEXT:    [[STILL_POISON:%.*]] = and i32 [[POISON]], 0
 ; IS__CGSCC____-NEXT:    [[POISON_YET_AGAIN:%.*]] = getelementptr i32, i32* [[TMP0]], i32 [[STILL_POISON]]
 ; IS__CGSCC____-NEXT:    store i32 0, i32* [[POISON_YET_AGAIN]], align 4
 ; IS__CGSCC____-NEXT:    ret void
 ;
   %poison = sub nuw i32 0, 1           ; Results in a poison value.
   %still_poison = and i32 %poison, 0   ; 0, but also poison.
   %poison_yet_again = getelementptr i32, i32* %0, i32 %still_poison
   store i32 0, i32* %poison_yet_again  ; Undefined behavior due to store to poison.
   ret void
 }
 
 define void @inf_loop() #0 {
 ; NOT_CGSCC_NPM: Function Attrs: nofree noreturn nosync nounwind readnone
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@inf_loop
-; NOT_CGSCC_NPM-SAME: () [[ATTR9:#.*]] {
+; NOT_CGSCC_NPM-SAME: () #[[ATTR9:[0-9]+]] {
 ; NOT_CGSCC_NPM-NEXT:  entry:
 ; NOT_CGSCC_NPM-NEXT:    br label [[WHILE_BODY:%.*]]
 ; NOT_CGSCC_NPM:       while.body:
 ; NOT_CGSCC_NPM-NEXT:    br label [[WHILE_BODY]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse noreturn nosync nounwind readnone
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@inf_loop
-; IS__CGSCC____-SAME: () [[ATTR11:#.*]] {
+; IS__CGSCC____-SAME: () #[[ATTR11:[0-9]+]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    br label [[WHILE_BODY:%.*]]
 ; IS__CGSCC____:       while.body:
 ; IS__CGSCC____-NEXT:    br label [[WHILE_BODY]]
 ;
 entry:
   br label %while.body
 
 while.body:                                       ; preds = %entry, %while.body
   br label %while.body
 }
 
 ; TEST 7: Infinite loop.
 ; FIXME: Detect infloops, and mark affected blocks dead.
 
 define i32 @test5(i32, i32) #0 {
 ; CHECK: Function Attrs: nosync readnone
 ; CHECK-LABEL: define {{[^@]+}}@test5
-; CHECK-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) [[ATTR5:#.*]] {
+; CHECK-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR5:[0-9]+]] {
 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP0]], [[TMP1]]
 ; CHECK-NEXT:    br i1 [[TMP3]], label [[COND_IF:%.*]], label [[COND_ELSEIF:%.*]]
 ; CHECK:       cond.if:
 ; CHECK-NEXT:    [[TMP4:%.*]] = tail call i32 @bar()
 ; CHECK-NEXT:    br label [[COND_END:%.*]]
 ; CHECK:       cond.elseif:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.else:

 cond.end:                                               ; preds = %cond.if, %cond.else, %cond.elseif
   %7 = phi i32 [ %1, %cond.elseif ], [ 0, %cond.else ], [ 0, %cond.if ]
   ret i32 %7
 }
 
 define void @rec() #0 {
 ; NOT_CGSCC_NPM: Function Attrs: nofree noreturn nosync nounwind readnone willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@rec
-; NOT_CGSCC_NPM-SAME: () [[ATTR10:#.*]] {
+; NOT_CGSCC_NPM-SAME: () #[[ATTR10:[0-9]+]] {
 ; NOT_CGSCC_NPM-NEXT:  entry:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse noreturn nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@rec
-; IS__CGSCC____-SAME: () [[ATTR12:#.*]] {
+; IS__CGSCC____-SAME: () #[[ATTR12:[0-9]+]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    unreachable
 ;
 entry:
   call void @rec()
   ret void
 }
 
 ; TEST 8: Recursion
 ; FIXME: everything after first block should be marked dead
 ; and unreachable should be put after call to @rec().
 
 define i32 @test6(i32, i32) #0 {
 ; NOT_CGSCC_NPM: Function Attrs: nofree noreturn nosync nounwind readnone willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test6
-; NOT_CGSCC_NPM-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) [[ATTR10]] {
+; NOT_CGSCC_NPM-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR10]] {
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       cond.if:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       cond.elseif:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       cond.else:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       cond.end:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse noreturn nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test6
-; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) [[ATTR12]] {
+; IS__CGSCC____-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR12]] {
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       cond.if:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       cond.elseif:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       cond.else:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       cond.end:
; <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() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree noreturn nosync nounwind
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test_unreachable
-; NOT_CGSCC_NPM-SAME: () [[ATTR0:#.*]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14:#.*]]
-; NOT_CGSCC_NPM-NEXT:    call void @test_unreachable() [[ATTR0]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR0]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14:[0-9]+]]
+; NOT_CGSCC_NPM-NEXT:    call void @test_unreachable() #[[ATTR0]]
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ;
 ; IS__CGSCC____: Function Attrs: nofree noreturn nosync nounwind
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test_unreachable
-; IS__CGSCC____-SAME: () [[ATTR0:#.*]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16:#.*]]
-; IS__CGSCC____-NEXT:    call void @test_unreachable() [[ATTR0]]
+; IS__CGSCC____-SAME: () #[[ATTR0]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17:[0-9]+]]
+; IS__CGSCC____-NEXT:    call void @test_unreachable() #[[ATTR0]]
 ; IS__CGSCC____-NEXT:    unreachable
 ;
   call void @sink()
   call void @test_unreachable()
   unreachable
 }
 
 define linkonce_odr void @non_exact1() {
 ; CHECK-LABEL: define {{[^@]+}}@non_exact1() {
-; CHECK-NEXT:    call void @non_dead_a0() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a1() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a2() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a3() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a4() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a5() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a6() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a7() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a8() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a9() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a10() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a11() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a12() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a13() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a14() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_a15() [[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a0() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a1() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a2() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a3() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a4() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a5() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a6() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a7() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a8() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a9() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a10() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a11() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a12() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a13() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a14() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_a15() #[[ATTR2]]
 ; CHECK-NEXT:    call void @middle()
 ; CHECK-NEXT:    ret void
 ;
   call void @non_dead_a0()
   call void @non_dead_a1()
   call void @non_dead_a2()
   call void @non_dead_a3()
   call void @non_dead_a4()
;
   call void @non_dead_a14()
   call void @non_dead_a15()
   call void @middle()
   ret void
 }
 define internal void @middle() {
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@middle() {
 ; NOT_CGSCC_NPM-NEXT:  bb0:
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b0() [[ATTR11:#.*]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b1() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b2() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b3() [[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b0() #[[ATTR11:[0-9]+]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b1() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b2() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b3() #[[ATTR11]]
 ; NOT_CGSCC_NPM-NEXT:    br label [[BB1:%.*]]
 ; NOT_CGSCC_NPM:       bb1:
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b4() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b5() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b6() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b7() [[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b4() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b5() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b6() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b7() #[[ATTR11]]
 ; NOT_CGSCC_NPM-NEXT:    br label [[BB2:%.*]]
 ; NOT_CGSCC_NPM:       bb2:
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b8() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b9() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b10() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b11() [[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b8() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b9() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b10() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b11() #[[ATTR11]]
 ; NOT_CGSCC_NPM-NEXT:    br label [[BB3:%.*]]
 ; NOT_CGSCC_NPM:       bb3:
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b12() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b13() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b14() [[ATTR11]]
-; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b15() [[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b12() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b13() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b14() #[[ATTR11]]
+; NOT_CGSCC_NPM-NEXT:    call void @non_dead_b15() #[[ATTR11]]
 ; NOT_CGSCC_NPM-NEXT:    br label [[BB4:%.*]]
 ; NOT_CGSCC_NPM:       bb4:
 ; NOT_CGSCC_NPM-NEXT:    call void @non_exact2()
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@middle() {
 ; IS__CGSCC____-NEXT:  bb0:
-; IS__CGSCC____-NEXT:    call void @non_dead_b0() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b1() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b2() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b3() [[ATTR16]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b0() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b1() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b2() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b3() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    br label [[BB1:%.*]]
 ; IS__CGSCC____:       bb1:
-; IS__CGSCC____-NEXT:    call void @non_dead_b4() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b5() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b6() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b7() [[ATTR16]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b4() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b5() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b6() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b7() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    br label [[BB2:%.*]]
 ; IS__CGSCC____:       bb2:
-; IS__CGSCC____-NEXT:    call void @non_dead_b8() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b9() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b10() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b11() [[ATTR16]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b8() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b9() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b10() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b11() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    br label [[BB3:%.*]]
 ; IS__CGSCC____:       bb3:
-; IS__CGSCC____-NEXT:    call void @non_dead_b12() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b13() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b14() [[ATTR16]]
-; IS__CGSCC____-NEXT:    call void @non_dead_b15() [[ATTR16]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b12() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b13() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b14() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @non_dead_b15() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    br label [[BB4:%.*]]
 ; IS__CGSCC____:       bb4:
 ; IS__CGSCC____-NEXT:    call void @non_exact2()
 ; IS__CGSCC____-NEXT:    ret void
 ;
 bb0:
   call void @non_dead_b0()
   call void @non_dead_b1()
bb3:
   call void @non_dead_b15()
 br label %bb4
 bb4:
   call void @non_exact2()
   ret void
 }
 define linkonce_odr void @non_exact2() {
 ; CHECK-LABEL: define {{[^@]+}}@non_exact2() {
-; CHECK-NEXT:    call void @non_dead_c0() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c1() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c2() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c3() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c4() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c5() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c6() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c7() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c8() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c9() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c10() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c11() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c12() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c13() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c14() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_c15() [[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c0() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c1() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c2() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c3() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c4() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c5() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c6() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c7() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c8() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c9() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c10() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c11() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c12() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c13() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c14() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_c15() #[[ATTR2]]
 ; CHECK-NEXT:    call void @non_exact3()
 ; CHECK-NEXT:    ret void
 ;
   call void @non_dead_c0()
   call void @non_dead_c1()
   call void @non_dead_c2()
   call void @non_dead_c3()
   call void @non_dead_c4()
   call void @non_dead_c5()
   call void @non_dead_c6()
   call void @non_dead_c7()
   call void @non_dead_c8()
   call void @non_dead_c9()
   call void @non_dead_c10()
   call void @non_dead_c11()
   call void @non_dead_c12()
   call void @non_dead_c13()
   call void @non_dead_c14()
   call void @non_dead_c15()
   call void @non_exact3()
   ret void
 }
 define linkonce_odr void @non_exact3() {
 ; CHECK-LABEL: define {{[^@]+}}@non_exact3() {
-; CHECK-NEXT:    call void @non_dead_d0() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d1() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d2() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d3() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d4() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d5() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d6() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d7() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d8() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d9() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d10() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d11() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d12() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d13() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d14() [[ATTR2]]
-; CHECK-NEXT:    call void @non_dead_d15() [[ATTR2]]
-; CHECK-NEXT:    [[NR:%.*]] = call i32 @foo_noreturn() [[ATTR4]]
+; CHECK-NEXT:    call void @non_dead_d0() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d1() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d2() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d3() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d4() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d5() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d6() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d7() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d8() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d9() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d10() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d11() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d12() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d13() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d14() #[[ATTR2]]
+; CHECK-NEXT:    call void @non_dead_d15() #[[ATTR2]]
+; CHECK-NEXT:    [[NR:%.*]] = call i32 @foo_noreturn() #[[ATTR4]]
 ; CHECK-NEXT:    unreachable
 ;
   call void @non_dead_d0()
   call void @non_dead_d1()
   call void @non_dead_d2()
   call void @non_dead_d3()
   call void @non_dead_d4()
   call void @non_dead_d5()
;
   %nr = call i32 @foo_noreturn()
   call void @dead_e1()
   ret void
 }
 
 define internal void @non_dead_a0() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a0
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a0
-; IS__CGSCC____-SAME: () [[ATTR13:#.*]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13:[0-9]+]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a1() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a1
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a1
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a2() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a2
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a2
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a3() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a3
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a3
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a4() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a4
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a4
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a5() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a5
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a5
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a6() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a6
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a6
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a7() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a7
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a7
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a8() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a8
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a8
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a9() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a9
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a9
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a10() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a10
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a10
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a11() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a11
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a11
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a12() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a12
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a12
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a13() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a13
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a13
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a14() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a14
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a14
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_a15() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_a15
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_a15
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b0() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b0
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b0
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b1() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b1
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b1
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b2() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b2
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b2
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b3() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b3
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b3
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b4() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b4
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b4
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b5() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b5
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b5
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b6() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b6
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b6
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b7() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b7
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b7
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b8() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b8
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b8
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b9() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b9
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b9
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b10() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b10
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b10
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b11() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b11
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b11
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b12() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b12
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b12
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b13() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b13
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b13
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b14() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b14
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b14
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_b15() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_b15
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_b15
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c0() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c0
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c0
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c1() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c1
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c1
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c2() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c2
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c2
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c3() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c3
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c3
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c4() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c4
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c4
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c5() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c5
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c5
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c6() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c6
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c6
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c7() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c7
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c7
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c8() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c8
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c8
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c9() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c9
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c9
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c10() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c10
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c10
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c11() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c11
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c11
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c12() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c12
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c12
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c13() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c13
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c13
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c14() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c14
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c14
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_c15() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_c15
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_c15
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d0() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d0
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d0
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d1() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d1
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d1
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d2() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d2
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d2
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d3() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d3
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d3
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d4() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d4
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d4
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d5() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d5
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d5
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d6() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d6
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d6
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d7() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d7
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d7
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d8() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d8
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d8
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d9() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d9
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d9
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d10() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d10
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d10
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d11() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d11
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d11
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d12() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d12
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d12
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d13() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d13
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d13
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d14() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d14
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d14
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @non_dead_d15() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@non_dead_d15
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@non_dead_d15
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 define internal void @dead_e0() { call void @dead_e1() ret void }
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@dead_e0() {
 ; IS__CGSCC____-NEXT:    call void @dead_e1()
lpad:
   br label %live_with_dead_entry
 live_with_dead_entry:
   ret void
 }
 
 define void @live_with_dead_entry_lp() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK: Function Attrs: nounwind
 ; CHECK-LABEL: define {{[^@]+}}@live_with_dead_entry_lp
-; CHECK-SAME: () [[ATTR2]] personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-SAME: () #[[ATTR2]] personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    invoke void @blowup() [[ATTR4]]
+; CHECK-NEXT:    invoke void @blowup() #[[ATTR4]]
 ; CHECK-NEXT:    to label [[LIVE_WITH_DEAD_ENTRY_DEAD:%.*]] unwind label [[LP1:%.*]]
 ; CHECK:       lp1:
 ; CHECK-NEXT:    [[LP:%.*]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:    catch i8* null
-; CHECK-NEXT:    invoke void @blowup() [[ATTR4]]
+; CHECK-NEXT:    invoke void @blowup() #[[ATTR4]]
 ; CHECK-NEXT:    to label [[LIVE_WITH_DEAD_ENTRY_DEAD1:%.*]] unwind label [[LP2:%.*]]
 ; CHECK:       lp2:
 ; CHECK-NEXT:    [[TMP0:%.*]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:    catch i8* null
 ; CHECK-NEXT:    br label [[LIVE_WITH_DEAD_ENTRY:%.*]]
 ; CHECK:       live_with_dead_entry.dead:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       live_with_dead_entry.dead1:
lp2:
   br label %live_with_dead_entry
 live_with_dead_entry:
   ret void
 }
 
 define internal void @useless_arg_sink(i32* %a) {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@useless_arg_sink
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@useless_arg_sink
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @sink()
   ret void
 }
 
 define internal void @useless_arg_almost_sink(i32* %a) {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@useless_arg_almost_sink
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    call void @useless_arg_sink() [[ATTR11]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    call void @useless_arg_sink() #[[ATTR11]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@useless_arg_almost_sink
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    call void @useless_arg_sink() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @useless_arg_sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void @useless_arg_sink(i32* %a)
   ret void
 }
 
 ; Check we do not annotate the function interface of this weak function.
 define weak_odr void @useless_arg_ext(i32* %a) {
 ; CHECK-LABEL: define {{[^@]+}}@useless_arg_ext
 ; CHECK-SAME: (i32* [[A:%.*]]) {
-; CHECK-NEXT:    call void @useless_arg_almost_sink() [[ATTR2]]
+; CHECK-NEXT:    call void @useless_arg_almost_sink() #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ;
   call void @useless_arg_almost_sink(i32* %a)
   ret void
 }
 
 define internal void @useless_arg_ext_int(i32* %a) {
 ; CHECK-LABEL: define {{[^@]+}}@useless_arg_ext_int
;
   ret void
 }
 
 ; FIXME: We should fold terminators.
 
 define internal i32 @switch_default(i64 %i) nounwind {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@switch_default
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
 ; NOT_CGSCC_NPM-NEXT:  entry:
 ; NOT_CGSCC_NPM-NEXT:    switch i64 0, label [[SW_DEFAULT:%.*]] [
 ; NOT_CGSCC_NPM-NEXT:    i64 3, label [[RETURN:%.*]]
 ; NOT_CGSCC_NPM-NEXT:    i64 10, label [[RETURN]]
 ; NOT_CGSCC_NPM-NEXT:    ]
 ; NOT_CGSCC_NPM:       sw.default:
-; NOT_CGSCC_NPM-NEXT:    call void @sink() [[ATTR14]]
+; NOT_CGSCC_NPM-NEXT:    call void @sink() #[[ATTR14]]
 ; NOT_CGSCC_NPM-NEXT:    ret i32 undef
 ; NOT_CGSCC_NPM:       return:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@switch_default
-; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    switch i64 0, label [[SW_DEFAULT:%.*]] [
 ; IS__CGSCC____-NEXT:    i64 3, label [[RETURN:%.*]]
 ; IS__CGSCC____-NEXT:    i64 10, label [[RETURN]]
 ; IS__CGSCC____-NEXT:    ]
 ; IS__CGSCC____:       sw.default:
-; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
+; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret i32 undef
 ; IS__CGSCC____:       return:
 ; IS__CGSCC____-NEXT:    unreachable
 ;
 entry:
   switch i64 %i, label %sw.default [
   i64 3, label %return
   i64 10, label %return
   ]
 
 sw.default:
   call void @sink()
   ret i32 123
 
 return:
   ret i32 0
 }
 
 define i32 @switch_default_caller() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@switch_default_caller
-; NOT_CGSCC_NPM-SAME: () [[ATTR11]] {
-; NOT_CGSCC_NPM-NEXT:    [[CALL2:%.*]] = tail call i32 @switch_default() [[ATTR11]]
+; NOT_CGSCC_NPM-SAME: () #[[ATTR11]] {
+; NOT_CGSCC_NPM-NEXT:    [[CALL2:%.*]] = tail call i32 @switch_default() #[[ATTR11]]
 ; NOT_CGSCC_NPM-NEXT:    ret i32 123
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@switch_default_caller
-; IS__CGSCC____-SAME: () [[ATTR13]] {
-; IS__CGSCC____-NEXT:    [[CALL2:%.*]] = tail call i32 @switch_default() [[ATTR16]]
+; IS__CGSCC____-SAME: () #[[ATTR13]] {
+; IS__CGSCC____-NEXT:    [[CALL2:%.*]] = tail call i32 @switch_default() #[[ATTR17]]
 ; IS__CGSCC____-NEXT:    ret i32 123
 ;
   %call2 = tail call i32 @switch_default(i64 0)
   ret i32 %call2
 }
 
 define internal i32 @switch_default_dead(i64 %i) nounwind {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@switch_default_dead
-; IS__CGSCC____-SAME: () [[ATTR6]] {
+; IS__CGSCC____-SAME: () #[[ATTR6]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    switch i64 0, label [[SW_DEFAULT:%.*]] [
 ; IS__CGSCC____-NEXT:    i64 3, label [[RETURN:%.*]]
 ; IS__CGSCC____-NEXT:    i64 10, label [[RETURN]]
 ; IS__CGSCC____-NEXT:    ]
 ; IS__CGSCC____:       sw.default:
 ; IS__CGSCC____-NEXT:    ret i32 undef
 ; IS__CGSCC____:       return:

 
 return:
   ret i32 0
 }
 
 define i32 @switch_default_dead_caller() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind readnone willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@switch_default_dead_caller
-; NOT_CGSCC_NPM-SAME: () [[ATTR12:#.*]] {
+; NOT_CGSCC_NPM-SAME: () #[[ATTR12:[0-9]+]] {
 ; NOT_CGSCC_NPM-NEXT:    ret i32 123
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@switch_default_dead_caller
-; IS__CGSCC____-SAME: () [[ATTR6]] {
+; IS__CGSCC____-SAME: () #[[ATTR6]] {
 ; IS__CGSCC____-NEXT:    ret i32 123
 ;
   %call2 = tail call i32 @switch_default_dead(i64 0)
   ret i32 %call2
 }
 
 define void @call_via_pointer_with_dead_args(i32* %a, i32* %b, void (i32*, i32*, i32*, i64, i32**)* %fp) {
 ; CHECK-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args

 entry:
   tail call void @use_i32p(i32* %a)
   tail call void @use_i32p(i32* %a)
   ret void
 }
 declare void @use_i32p(i32*)
 
 ; Allow blockaddress users
-; NOT_CGSCC_OPM-NOT: @dead_with_blockaddress_users
 define internal void @dead_with_blockaddress_users(i32* nocapture %pc) nounwind readonly {
 ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@dead_with_blockaddress_users
-; IS__CGSCC_OPM-SAME: (i32* nocapture [[PC:%.*]])
+; IS__CGSCC_OPM-SAME: (i32* noalias nocapture nofree nonnull readonly align 536870912 dereferenceable(4294967295) [[PC:%.*]])
 ; IS__CGSCC_OPM-NEXT:  entry:
 ; IS__CGSCC_OPM-NEXT:    br label [[INDIRECTGOTO:%.*]]
 ; IS__CGSCC_OPM:       lab0:
 ; IS__CGSCC_OPM-NEXT:    [[INDVAR_NEXT:%.*]] = add i32 [[INDVAR:%.*]], 1
 ; IS__CGSCC_OPM-NEXT:    br label [[INDIRECTGOTO]]
 ; IS__CGSCC_OPM:       end:
 ; IS__CGSCC_OPM-NEXT:    ret void
 ; IS__CGSCC_OPM:       indirectgoto:
 ; IS__CGSCC_OPM-NEXT:    [[INDVAR]] = phi i32 [ [[INDVAR_NEXT]], [[LAB0:%.*]] ], [ 0, [[ENTRY:%.*]] ]
 ; IS__CGSCC_OPM-NEXT:    [[PC_ADDR_0:%.*]] = getelementptr i32, i32* [[PC]], i32 [[INDVAR]]
 ; IS__CGSCC_OPM-NEXT:    [[TMP1_PN:%.*]] = load i32, i32* [[PC_ADDR_0]]
 ; IS__CGSCC_OPM-NEXT:    [[INDIRECT_GOTO_DEST_IN:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* @dead_with_blockaddress_users.l, i32 0, i32 [[TMP1_PN]]
 ; IS__CGSCC_OPM-NEXT:    [[INDIRECT_GOTO_DEST:%.*]] = load i8*, i8** [[INDIRECT_GOTO_DEST_IN]]
 ; IS__CGSCC_OPM-NEXT:    indirectbr i8* [[INDIRECT_GOTO_DEST]], [label [[LAB0]], label %end]
 ;
+; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone
+; IS__CGSCC____-LABEL: define {{[^@]+}}@dead_with_blockaddress_users
+; IS__CGSCC____-SAME: (i32* noalias nocapture nofree nonnull readonly align 536870912 dereferenceable(4294967295) [[PC:%.*]]) #[[ATTR14:[0-9]+]] {
+; IS__CGSCC____-NEXT:  entry:
+; IS__CGSCC____-NEXT:    br label [[INDIRECTGOTO:%.*]]
+; IS__CGSCC____:       lab0:
+; IS__CGSCC____-NEXT:    [[INDVAR_NEXT:%.*]] = add i32 [[INDVAR:%.*]], 1
+; IS__CGSCC____-NEXT:    br label [[INDIRECTGOTO]]
+; IS__CGSCC____:       end:
+; IS__CGSCC____-NEXT:    ret void
+; IS__CGSCC____:       indirectgoto:
+; IS__CGSCC____-NEXT:    [[INDVAR]] = phi i32 [ [[INDVAR_NEXT]], [[LAB0:%.*]] ], [ 0, [[ENTRY:%.*]] ]
+; IS__CGSCC____-NEXT:    [[PC_ADDR_0:%.*]] = getelementptr i32, i32* undef, i32 [[INDVAR]]
+; IS__CGSCC____-NEXT:    [[TMP1_PN:%.*]] = load i32, i32* [[PC_ADDR_0]], align 4
+; IS__CGSCC____-NEXT:    [[INDIRECT_GOTO_DEST_IN:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* @dead_with_blockaddress_users.l, i32 0, i32 [[TMP1_PN]]
+; IS__CGSCC____-NEXT:    [[INDIRECT_GOTO_DEST:%.*]] = load i8*, i8** [[INDIRECT_GOTO_DEST_IN]], align 8
+; IS__CGSCC____-NEXT:    indirectbr i8* [[INDIRECT_GOTO_DEST]], [label [[LAB0]], label %end]
+;
 entry:
   br label %indirectgoto
 
 lab0:                                             ; preds = %indirectgoto
   %indvar.next = add i32 %indvar, 1               ; <i32> [#uses=1]
   br label %indirectgoto
 
 end:                                              ; preds = %indirectgoto
for.end.1:
   ret i32 0
 }
 
 declare noalias i8* @malloc(i64)
 
 define i32 @h(i32 %i) {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind readnone willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@h
-; NOT_CGSCC_NPM-SAME: (i32 [[I:%.*]]) [[ATTR12]] {
+; NOT_CGSCC_NPM-SAME: (i32 [[I:%.*]]) #[[ATTR12]] {
 ; NOT_CGSCC_NPM-NEXT:    ret i32 0
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@h
-; IS__CGSCC____-SAME: (i32 [[I:%.*]]) [[ATTR6]] {
+; IS__CGSCC____-SAME: (i32 [[I:%.*]]) #[[ATTR6]] {
 ; IS__CGSCC____-NEXT:    ret i32 0
 ;
   ret i32 0
 }
 
 
 ; Verify we do not choke on the GEP in the unreachable block.
 
 @p = global i8 0
 
 define void @bad_gep() {
 ; NOT_CGSCC_NPM: Function Attrs: nofree nosync nounwind readnone willreturn
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@bad_gep
-; NOT_CGSCC_NPM-SAME: () [[ATTR12]] {
+; NOT_CGSCC_NPM-SAME: () #[[ATTR12]] {
 ; NOT_CGSCC_NPM-NEXT:  entry:
 ; NOT_CGSCC_NPM-NEXT:    [[N:%.*]] = alloca i8, align 1
 ; NOT_CGSCC_NPM-NEXT:    [[M:%.*]] = alloca i8, align 1
-; NOT_CGSCC_NPM-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) [[ATTR15:#.*]]
+; NOT_CGSCC_NPM-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR15:[0-9]+]]
 ; NOT_CGSCC_NPM-NEXT:    br label [[EXIT:%.*]]
 ; NOT_CGSCC_NPM:       while.body:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       if.then:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       if.end:
 ; NOT_CGSCC_NPM-NEXT:    unreachable
 ; NOT_CGSCC_NPM:       exit:
-; NOT_CGSCC_NPM-NEXT:    call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) [[ATTR15]]
+; NOT_CGSCC_NPM-NEXT:    call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR15]]
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@bad_gep
-; IS__CGSCC____-SAME: () [[ATTR14:#.*]] {
+; IS__CGSCC____-SAME: () #[[ATTR15:[0-9]+]] {
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[N:%.*]] = alloca i8, align 1
 ; IS__CGSCC____-NEXT:    [[M:%.*]] = alloca i8, align 1
-; IS__CGSCC____-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) [[ATTR17:#.*]]
+; IS__CGSCC____-NEXT:    call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR18:[0-9]+]]
 ; IS__CGSCC____-NEXT:    br label [[EXIT:%.*]]
 ; IS__CGSCC____:       while.body:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       if.then:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       if.end:
 ; IS__CGSCC____-NEXT:    unreachable
 ; IS__CGSCC____:       exit:
-; IS__CGSCC____-NEXT:    call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) [[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR18]]
 ; IS__CGSCC____-NEXT:    ret void
 ;
 entry:
   %n = alloca i8
   %m = alloca i8
   call void @llvm.lifetime.start.p0i8(i64 1, i8* %n)
   br label %exit
 
exit:
   ret void
 }
 
 declare i1 @bad_gep_helper1(i8*, i8*, i8*)
 declare void @bad_gep_helper2(i8)
 
 declare void @llvm.lifetime.start.p0i8(i64 %0, i8* %1)
 declare void @llvm.lifetime.end.p0i8(i64 %0, i8* %1)
+; NOT_CGSCC_NPM: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind }
+; NOT_CGSCC_NPM: attributes #[[ATTR1:[0-9]+]] = { readnone }
+; NOT_CGSCC_NPM: attributes #[[ATTR2]] = { nounwind }
+; NOT_CGSCC_NPM: attributes #[[ATTR3]] = { noreturn nounwind }
+; NOT_CGSCC_NPM: attributes #[[ATTR4]] = { noreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR5]] = { nosync readnone }
+; NOT_CGSCC_NPM: attributes #[[ATTR6]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR7]] = { nosync }
+; NOT_CGSCC_NPM: attributes #[[ATTR8]] = { argmemonly nofree nosync nounwind willreturn writeonly }
+; NOT_CGSCC_NPM: attributes #[[ATTR9]] = { nofree noreturn nosync nounwind readnone }
+; NOT_CGSCC_NPM: attributes #[[ATTR10]] = { nofree noreturn nosync nounwind readnone willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR11]] = { nofree nosync nounwind willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR12]] = { nofree nosync nounwind readnone willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR13:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR14]] = { nounwind willreturn }
+; NOT_CGSCC_NPM: attributes #[[ATTR15]] = { willreturn }
+;.
+; IS__CGSCC____: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind }
+; IS__CGSCC____: attributes #[[ATTR1:[0-9]+]] = { readnone }
+; IS__CGSCC____: attributes #[[ATTR2]] = { nounwind }
+; IS__CGSCC____: attributes #[[ATTR3]] = { noreturn nounwind }
+; IS__CGSCC____: attributes #[[ATTR4]] = { noreturn }
+; IS__CGSCC____: attributes #[[ATTR5]] = { nosync readnone }
+; IS__CGSCC____: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind readnone willreturn }
+; IS__CGSCC____: attributes #[[ATTR7]] = { argmemonly nofree norecurse nounwind uwtable willreturn }
+; IS__CGSCC____: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind readnone uwtable willreturn }
+; IS__CGSCC____: attributes #[[ATTR9]] = { nosync }
+; IS__CGSCC____: attributes #[[ATTR10]] = { argmemonly nofree norecurse nosync nounwind willreturn writeonly }
+; IS__CGSCC____: attributes #[[ATTR11]] = { nofree norecurse noreturn nosync nounwind readnone }
+; IS__CGSCC____: attributes #[[ATTR12]] = { nofree norecurse noreturn nosync nounwind readnone willreturn }
+; IS__CGSCC____: attributes #[[ATTR13]] = { nofree nosync nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR14]] = { nofree norecurse nosync nounwind readnone }
+; IS__CGSCC____: attributes #[[ATTR15]] = { nofree nosync nounwind readnone willreturn }
+; IS__CGSCC____: attributes #[[ATTR16:[0-9]+]] = { argmemonly nofree nosync nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR17]] = { nounwind willreturn }
+; IS__CGSCC____: attributes #[[ATTR18]] = { willreturn }

llvm/test/Transforms/Attributor/nodelete.ll

+; RUN: opt -attributor-cgscc -S < %s | FileCheck %s
+
+%"a" = type { i64 }
+%"b" = type { i8 }
+
+define hidden i64 @f1() align 2 {
+entry:
+  %ref.tmp = alloca %"a", align 8
+  %call2 = call i64 @f2(%"a"* %ref.tmp)
+  ret i64 %call2
+}
+
+define internal i64 @f2(%"a"* %this) align 2 {
+entry:
+  %this.addr = alloca %"a"*, align 8
+  store %"a"* %this, %"a"** %this.addr, align 8
+  %this1 = load %"a"*, %"a"** %this.addr, align 8
+  %0 = bitcast %"a"* %this1 to %"b"*
+  call void @f3(%"b"* %0)
+  ret i64 undef
+}
+
+define internal void @f3(%"b"* %this) align 2 {
+entry:
+  %this.addr = alloca %"b"*, align 8
+  store %"b"* %this, %"b"** %this.addr, align 8
+  %this1 = load %"b"*, %"b"** %this.addr, align 8
+  %call = call i1 @f4(%"b"* %this1)
+  ret void
+}
+
+define internal i1 @f4(%"b"* %this) align 2 {
+entry:
+  %this.addr = alloca %"b"*, align 8
+  store %"b"* %this, %"b"** %this.addr, align 8
+  %this1 = load %"b"*, %"b"** %this.addr, align 8
+  %call = call %"a"* @f5(%"b"* %this1)
+  ret i1 undef
+}
+
+define internal %"a"* @f5(%"b"* %this) align 2 {
+entry:
+  %this.addr = alloca %"b"*, align 8
+  store %"b"* %this, %"b"** %this.addr, align 8
+  %this1 = load %"b"*, %"b"** %this.addr, align 8
+  %0 = bitcast %"b"* %this1 to %"a"*
+  ret %"a"* %0
+}
+
+; CHECK: define hidden i64 @f1()
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   ret i64 undef
+; CHECK-NEXT: }
+
+; CHECK: define internal i64 @f2(%a* noalias nocapture nofree noundef nonnull readnone align 8 dereferenceable(8) %this)
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %this.addr = alloca %a*, align 8
+; CHECK-NEXT:   store %a* %this, %a** %this.addr, align 8
+; CHECK-NEXT:   ret i64 undef
+; CHECK-NEXT: }
+
+; CHECK: define internal void @f3(%b* noalias nocapture nofree readnone %this)
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %this.addr = alloca %b*, align 8
+; CHECK-NEXT:   store %b* %this, %b** %this.addr, align 8
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; CHECK: define internal i1 @f4(%b* noalias nocapture nofree readnone %this)
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %this.addr = alloca %b*, align 8
+; CHECK-NEXT:   store %b* %this, %b** %this.addr, align 8
+; CHECK-NEXT:   ret i1 undef
+; CHECK-NEXT: }
+
+; CHECK: define internal noalias nonnull %a* @f5(%b* noalias nocapture nofree readnone %this)
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %this.addr = alloca %b*, align 8
+; CHECK-NEXT:   store %b* %this, %b** %this.addr, align 8
+; CHECK-NEXT:   ret %a* undef
+; CHECK-NEXT: }
 No newline at end of file

llvm/test/Transforms/OpenMP/parallel_deletion_cg_update.ll

 ; RUN: opt < %s -instcombine -attributor-cgscc -print-callgraph -disable-output -verify 2>&1 -enable-new-pm=0 | FileCheck %s
 
 ; CHECK: Call graph node <<null function>><<{{.*}}>>  #uses=0
 ; CHECK:   CS<None> calls function 'dead_fork_call'
-; CHECK:   CS<None> calls function 'd'
+; CHECK:   CS<None> calls function '.omp_outlined..0'
 ; CHECK:   CS<None> calls function '__kmpc_fork_call'
 ; CHECK:   CS<None> calls function 'live_fork_call'
 ; CHECK:   CS<None> calls function '.omp_outlined..1'
-;
+; CHECK:   CS<None> calls function 'd'
+;
+; CHECK: Call graph node for function: '.omp_outlined..0'<<{{.*}}>>  #uses=1
+; 
 ; CHECK: Call graph node for function: '.omp_outlined..1'<<{{.*}}>>  #uses=3
 ; CHECK:   CS<{{.*}}> calls function 'd'
 ;
 ; CHECK: Call graph node for function: '__kmpc_fork_call'<<{{.*}}>>  #uses=3
 ; CHECK:   CS<None> calls external node
 ;
 ; CHECK: Call graph node for function: 'd'<<{{.*}}>>  #uses=2
 ; CHECK:   CS<None> calls external node