Bitcast wrapped in a call obscures function attributes, pessimizing MemorySSA

[antoniofrighetto]

Summary

A logic incompleteness may lead MemorySSA to be too conservative in its results. Specifically,
when dealing with a call of kind call i32 bitcast (i1 (i1)* @test to i32 (i32)*)(i32 %1),
where function call test is declared with readonly attribute, the bitcast is not wrapped,
obscuring function attributes. Hence, some methods of CallBase (e.g., doesNotReadMemory)
could provide incomplete results. This issue was addressed with improved checks.

[nikic]

llvm/lib/IR/Instructions.cpp

352–359

You should be able to drop the getCalledFunction() part, as it is subsumed by the newly added code.

[jdoerfert]

I'm slightly worried about the inconsistency but I am convincing myself slowly this is fine to do. I also imagine a single bitcast is the most important case to catch. The tests for MSSA is a bit obscure but I guess there is sufficient test coverage across the 4 tests.

The Attributor tests need to be updated properly though. I left comments.

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

1

Don't change the options.

135

Run the update script so these things don't go away.

[jdoerfert]

llvm/lib/IR/Instructions.cpp

355–356

Style suggestion, OK to ignore. I find it easier to read (less casts).

[jdoerfert]

LGTM, anyone else?

[lebedev.ri]

In D109888#3004336, @jdoerfert wrote:

LGTM, anyone else?

LG

llvm/lib/IR/Instructions.cpp

353–354

There's BitCastOperator, but it would also catch instructions

357–358

Could also use dyn_cast, don't know if that would be better/worse.

[antoniofrighetto]

llvm/lib/IR/Instructions.cpp

341

I suspect methods CallBase::getIntrinsicID and CallBase::paramHasAttr might be changed as well in the future.

352–359

Right, forgot to drop it.

357–358

Since I've changed to use dyn_cast before, it seems reasonable to use it here too.

[nikic]

I'm okay with this for the case of function attributes in particular, because those don't really depend on ABI considerations. I will say though that you're brushing really close to UB here, and I may push back against extending other places in this direction. Like, say you have a void(i128) and call it as void(i64, i64) knowing that under the particular ABI used those two i64s will assemble into an i128 -- is that a legal call? In what manner would a function param attribute correlate with call arguments there?

[jdoerfert]

In D109888#3004544, @nikic wrote:

I'm okay with this for the case of function attributes in particular, because those don't really depend on ABI considerations. I will say though that you're brushing really close to UB here, and I may push back against extending other places in this direction. Like, say you have a void(i128) and call it as void(i64, i64) knowing that under the particular ABI used those two i64s will assemble into an i128 -- is that a legal call? In what manner would a function param attribute correlate with call arguments there?

I second this.

Recently I (had to) start to fix all the places in the Attributor that are not aware that call site and callee might mismatch wrt. parameters (due to casts). It's a mess even w/o attributes.
For functions we should be OK because there is no ambiguity what the "function" is.

[antoniofrighetto]

In D109888#3004544, @nikic wrote:

I'm okay with this for the case of function attributes in particular, because those don't really depend on ABI considerations. I will say though that you're brushing really close to UB here, and I may push back against extending other places in this direction. Like, say you have a void(i128) and call it as void(i64, i64) knowing that under the particular ABI used those two i64s will assemble into an i128 -- is that a legal call? In what manner would a function param attribute correlate with call arguments there?

Haven't really thought about it, yet, like @jdoerfert noted, there should exist no ambiguity as far as the function is concerned.

[antoniofrighetto]

This comment was removed by antoniofrighetto.

[antoniofrighetto]

I don't have commit access, may anybody close this, please?

llvm/lib/IR/Instructions.cpp

Value *CallBase::getReturnedArgOperand() const {
   if (const Function *F = getCalledFunction())
     if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index))
       return getArgOperand(Index - AttributeList::FirstArgIndex);
 
   return nullptr;
 }
 
 /// Determine whether the argument or parameter has the given attribute.
 bool CallBase::paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
   assert(ArgNo < getNumArgOperands() && "Param index out of bounds!");
 
   if (Attrs.hasParamAttr(ArgNo, Kind))
     return true;
   if (const Function *F = getCalledFunction())
     return F->getAttributes().hasParamAttr(ArgNo, Kind);
   return false;
 }
 
 bool CallBase::hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const {
-  if (const Function *F = getCalledFunction())
-    return F->getAttributes().hasFnAttr(Kind);
+  Value *V = getCalledOperand();
+  if (auto *CE = dyn_cast<ConstantExpr>(V))
+    if (CE->getOpcode() == BitCast)
+      V = CE->getOperand(0);
+
+  if (isa<Function>(V))
+    return cast<Function>(V)->getAttributes().hasFnAttr(Kind);
+
   return false;
 }
 
 bool CallBase::hasFnAttrOnCalledFunction(StringRef Kind) const {
-  if (const Function *F = getCalledFunction())
-    return F->getAttributes().hasFnAttr(Kind);
+  Value *V = getCalledOperand();
+  if (auto *CE = dyn_cast<ConstantExpr>(V))
+    if (CE->getOpcode() == BitCast)
+      V = CE->getOperand(0);
+
+  if (isa<Function>(V))
+    return cast<Function>(V)->getAttributes().hasFnAttr(Kind);
+
   return false;
 }
 
 void CallBase::getOperandBundlesAsDefs(
     SmallVectorImpl<OperandBundleDef> &Defs) const {
   for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
     Defs.emplace_back(getOperandBundleAt(i));
 }

llvm/test/Analysis/MemorySSA/call-bitcast.ll

+; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
+;
+; Ensures that MemorySSA leverages the ground truth of the function being called when wrapped in a bitcast.
+
+declare i1 @opaque_true(i1) nounwind readonly
+
+define i1 @foo(i32* %ptr, i1 %cond) {
+  %cond_wide = zext i1 %cond to i32
+; CHECK: MemoryUse(liveOnEntry) MayAlias
+; CHECK-NEXT: call i32 bitcast
+  %cond_hidden_wide = call i32 bitcast (i1 (i1)* @opaque_true to i32 (i32)*)(i32 %cond_wide)
+  %cond_hidden = trunc i32 %cond_hidden_wide to i1
+  ret i1 %cond_hidden
+}

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

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; 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
 
 ; The original C source looked like this:
 ;
 ;   long long a101, b101, e101;

 ; Note that -lint will report this as UB, but it passes -verify.
 
 ; This test is just to verify that we do not crash/assert due to mismatch in
 ; argument count between the caller and callee.
 
 ; FIXME we should recognize this as UB and make it an unreachable.
 
 define dso_local i16 @foo(i16 %a) {
-; CHECK-LABEL: define {{[^@]+}}@foo
-; CHECK-SAME: (i16 [[A:%.*]]) {
-; CHECK-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
-; CHECK-NEXT:    ret i16 [[CALL]]
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@foo
+; NOT_CGSCC_NPM-SAME: (i16 [[A:%.*]]) {
+; NOT_CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 @bar()
+; NOT_CGSCC_NPM-NEXT:    ret i16 [[CALL]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@foo
+; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_NPM-NEXT:    ret i16 0
 ;
   %call = call i16 bitcast (i16 (i16, i16) * @bar to i16 (i16) *)(i16 %a)
   ret i16 %call
 }
 
 define internal i16 @bar(i16 %p1, i16 %p2) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@bar
-; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR0:[0-9]+]] {
+; IS__TUNIT____-SAME: () [[ATTR0:#.*]] {
 ; IS__TUNIT____-NEXT:    ret i16 0
 ;
-; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
-; IS__CGSCC____-LABEL: define {{[^@]+}}@bar
-; IS__CGSCC____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR0:[0-9]+]] {
-; IS__CGSCC____-NEXT:    ret i16 0
+; IS__CGSCC_OPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@bar
+; IS__CGSCC_OPM-SAME: () [[ATTR0:#.*]] {
+; IS__CGSCC_OPM-NEXT:    ret i16 0
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@bar
+; IS__CGSCC_NPM-SAME: () [[ATTR0]] {
+; IS__CGSCC_NPM-NEXT:    ret i16 undef
 ;
   ret i16 0
 }
 
 define dso_local i16 @foo2(i16 %a) {
-; CHECK-LABEL: define {{[^@]+}}@foo2
-; CHECK-SAME: (i16 [[A:%.*]]) {
-; CHECK-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar2 to i16 (i16)*)(i16 [[A]])
-; CHECK-NEXT:    ret i16 [[CALL]]
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@foo2
+; NOT_CGSCC_NPM-SAME: (i16 [[A:%.*]]) {
+; NOT_CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar2 to i16 (i16)*)(i16 [[A]])
+; NOT_CGSCC_NPM-NEXT:    ret i16 [[CALL]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@foo2
+; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) [[ATTR1:#.*]] {
+; IS__CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar2 to i16 (i16)*)(i16 [[A]])
+; IS__CGSCC_NPM-NEXT:    ret i16 [[CALL]]
 ;
   %call = call i16 bitcast (i16 (i16, i16) * @bar2 to i16 (i16) *)(i16 %a)
   ret i16 %call
 }
 
 define internal i16 @bar2(i16 %p1, i16 %p2) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@bar2
-; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) [[ATTR0]] {
 ; IS__TUNIT____-NEXT:    [[A:%.*]] = add i16 [[P1]], [[P2]]
 ; IS__TUNIT____-NEXT:    ret i16 [[A]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@bar2
-; IS__CGSCC____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) [[ATTR0:#.*]] {
 ; IS__CGSCC____-NEXT:    [[A:%.*]] = add i16 [[P1]], [[P2]]
 ; IS__CGSCC____-NEXT:    ret i16 [[A]]
 ;
   %a = add i16 %p1, %p2
   ret i16 %a
 }
 
 
 ;-------------------------------------------------------------------------------
 ; Additional tests to verify that we still optimize when having a mismatch
 ; in argument count due to varargs (as long as all non-variadic arguments have
 ; been provided),
 
 define dso_local i16 @vararg_tests(i16 %a) {
-; CHECK-LABEL: define {{[^@]+}}@vararg_tests
-; CHECK-SAME: (i16 [[A:%.*]]) {
-; CHECK-NEXT:    [[CALL2:%.*]] = call i16 bitcast (i16 (i16, i16, ...)* @vararg_no_prop to i16 (i16)*)(i16 noundef 7)
-; CHECK-NEXT:    [[ADD:%.*]] = add i16 7, [[CALL2]]
-; CHECK-NEXT:    ret i16 [[ADD]]
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@vararg_tests
+; NOT_CGSCC_NPM-SAME: (i16 [[A:%.*]]) {
+; NOT_CGSCC_NPM-NEXT:    [[CALL2:%.*]] = call i16 bitcast (i16 (i16, i16, ...)* @vararg_no_prop to i16 (i16)*)(i16 noundef 7)
+; NOT_CGSCC_NPM-NEXT:    [[ADD:%.*]] = add i16 7, [[CALL2]]
+; NOT_CGSCC_NPM-NEXT:    ret i16 [[ADD]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@vararg_tests
+; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) [[ATTR1]] {
+; IS__CGSCC_NPM-NEXT:    [[CALL2:%.*]] = call i16 bitcast (i16 (i16, i16, ...)* @vararg_no_prop to i16 (i16)*)(i16 noundef 7)
+; IS__CGSCC_NPM-NEXT:    [[ADD:%.*]] = add i16 7, [[CALL2]]
+; IS__CGSCC_NPM-NEXT:    ret i16 [[ADD]]
 ;
   %call1 = call i16 (i16, ...) @vararg_prop(i16 7, i16 8, i16 %a)
   %call2 = call i16 bitcast (i16 (i16, i16, ...) * @vararg_no_prop to i16 (i16) *) (i16 7)
   %add = add i16 %call1, %call2
   ret i16 %add
 }
 
 define internal i16 @vararg_prop(i16 %p1, ...) {
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@vararg_prop
-; IS__CGSCC____-SAME: (i16 [[P1:%.*]], ...) #[[ATTR0]] {
-; IS__CGSCC____-NEXT:    ret i16 undef
+; IS__CGSCC____-SAME: (i16 returned [[P1:%.*]], ...) [[ATTR0]] {
+; IS__CGSCC____-NEXT:    ret i16 7
 ;
   ret i16 %p1
 }
 
 define internal i16 @vararg_no_prop(i16 %p1, i16 %p2, ...) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@vararg_no_prop
-; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR0]] {
+; IS__TUNIT____-SAME: (i16 returned [[P1:%.*]], i16 [[P2:%.*]], ...) [[ATTR0]] {
 ; IS__TUNIT____-NEXT:    ret i16 7
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@vararg_no_prop
-; IS__CGSCC____-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR0]] {
+; IS__CGSCC____-SAME: (i16 returned [[P1:%.*]], i16 [[P2:%.*]], ...) [[ATTR0]] {
 ; IS__CGSCC____-NEXT:    ret i16 7
 ;
   ret i16 %p1
 }
 
-;.
-; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind readnone willreturn }
-;.
-; IS__CGSCC____: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind readnone willreturn }
-;.

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

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; 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
 
 ; This test is just to verify that we do not crash/assert due to mismatch in
 ; argument type between the caller and callee.
 
 define dso_local i16 @foo(i16 %a) {
-; CHECK-LABEL: define {{[^@]+}}@foo
-; CHECK-SAME: (i16 [[A:%.*]]) {
-; CHECK-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16, i32)*)(i16 [[A]], i32 7)
-; CHECK-NEXT:    ret i16 [[CALL]]
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@foo
+; NOT_CGSCC_NPM-SAME: (i16 [[A:%.*]]) {
+; NOT_CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16, i32)*)(i16 [[A]], i32 7)
+; NOT_CGSCC_NPM-NEXT:    ret i16 [[CALL]]
+;
+; IS__CGSCC_NPM: Function Attrs: nofree norecurse nosync nounwind readnone
+; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@foo
+; IS__CGSCC_NPM-SAME: (i16 [[A:%.*]]) [[ATTR0:#.*]] {
+; IS__CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16, i32)*)(i16 [[A]], i32 7)
+; IS__CGSCC_NPM-NEXT:    ret i16 [[CALL]]
 ;
   %call = call i16 bitcast (i16 (i16, i16) * @bar to i16 (i16, i32) *)(i16 %a, i32 7)
   ret i16 %call
 }
 
 define internal i16 @bar(i16 %p1, i16 %p2) {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind readnone willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@bar
-; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 returned [[P2:%.*]]) #[[ATTR0:[0-9]+]] {
+; IS__TUNIT____-SAME: (i16 [[P1:%.*]], i16 returned [[P2:%.*]]) [[ATTR0:#.*]] {
 ; IS__TUNIT____-NEXT:    ret i16 [[P2]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind readnone willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@bar
-; IS__CGSCC____-SAME: (i16 [[P1:%.*]], i16 returned [[P2:%.*]]) #[[ATTR0:[0-9]+]] {
+; IS__CGSCC____-SAME: (i16 [[P1:%.*]], i16 returned [[P2:%.*]]) [[ATTR1:#.*]] {
 ; IS__CGSCC____-NEXT:    ret i16 [[P2]]
 ;
   ret i16 %p2
 }
 
 
-;.
-; IS__TUNIT____: attributes #[[ATTR0]] = { nofree nosync nounwind readnone willreturn }
-;.
-; IS__CGSCC____: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind readnone willreturn }
-;.

llvm/test/Transforms/Attributor/liveness.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
-; RUN: opt -attributor -enable-new-pm=0 -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=34 -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=34 -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
+; 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___: @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)]
+; 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)]
 @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.
 
-;.
-; NOT_CGSCC_NPM: @[[DEAD_WITH_BLOCKADDRESS_USERS_L:[a-zA-Z0-9_$"\\.-]+]] = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
-; NOT_CGSCC_NPM: @[[A1:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 8
-; NOT_CGSCC_NPM: @[[A2:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 16
-; NOT_CGSCC_NPM: @[[E:[a-zA-Z0-9_$"\\.-]+]] = global %struct.a* null
-; NOT_CGSCC_NPM: @[[P:[a-zA-Z0-9_$"\\.-]+]] = global i8 0
-;.
-; IS__CGSCC____: @[[DEAD_WITH_BLOCKADDRESS_USERS_L:[a-zA-Z0-9_$"\\.-]+]] = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, [[LAB0:%.*]]), i8* blockaddress(@dead_with_blockaddress_users, [[END:%.*]])]
-; IS__CGSCC____: @[[A1:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 8
-; IS__CGSCC____: @[[A2:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 16
-; IS__CGSCC____: @[[E:[a-zA-Z0-9_$"\\.-]+]] = global %struct.a* null
-; IS__CGSCC____: @[[P:[a-zA-Z0-9_$"\\.-]+]] = global i8 0
-;.
 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:[0-9]+]] {
+; IS__CGSCC____-SAME: () [[ATTR6:#.*]] {
 ; 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 {
-; 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]]
+; 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]]
 ;
   %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:[0-9]+]] {
+; IS__CGSCC____-SAME: () [[ATTR8:#.*]] {
 ; 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:[0-9]+]] {
+; CHECK-SAME: (i32 [[A:%.*]], i32* nocapture nofree nonnull readnone [[PTR1:%.*]], i32* nocapture nofree readnone [[PTR2:%.*]]) [[ATTR0:#.*]] {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @no_return_call() #[[ATTR3:[0-9]+]]
+; CHECK-NEXT:    call void @no_return_call() [[ATTR3:#.*]]
 ; 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 {
-; 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]]
+; 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]]
 ;
 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:[0-9]+]]
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo_noreturn() [[ATTR4:#.*]]
 ; 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:[0-9]+]]
+; 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 [[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]]
cleanup:
   %res = landingpad { i8*, i32 } catch i8* null
   ret i32 0
 }
 
 ; TEST 6: Undefined behvior, taken from LangRef.
 ; FIXME: Should be able to detect undefined behavior.
 
 define void @ub(i32* %0) {
-; IS________OPM: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
-; IS________OPM-LABEL: define {{[^@]+}}@ub
-; IS________OPM-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR8:[0-9]+]] {
-; IS________OPM-NEXT:    store i32 0, i32* [[TMP0]], align 4
-; IS________OPM-NEXT:    ret void
-;
-; IS__TUNIT_NPM: Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
-; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@ub
-; IS__TUNIT_NPM-SAME: (i32* nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR8:[0-9]+]] {
-; IS__TUNIT_NPM-NEXT:    store i32 0, i32* undef, align 1073741824
-; IS__TUNIT_NPM-NEXT:    ret void
+; 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-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 readnone [[TMP0:%.*]]) #[[ATTR10:[0-9]+]] {
-; IS__CGSCC____-NEXT:    store i32 0, i32* undef, align 1073741824
+; IS__CGSCC____-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) [[ATTR10:#.*]] {
+; 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:[0-9]+]] {
+; NOT_CGSCC_NPM-SAME: () [[ATTR9:#.*]] {
 ; 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:[0-9]+]] {
+; IS__CGSCC____-SAME: () [[ATTR11:#.*]] {
 ; 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:[0-9]+]] {
+; CHECK-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) [[ATTR5:#.*]] {
 ; 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:[0-9]+]] {
+; NOT_CGSCC_NPM-SAME: () [[ATTR10:#.*]] {
 ; 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:[0-9]+]] {
+; IS__CGSCC____-SAME: () [[ATTR12:#.*]] {
 ; 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:[0-9]+]]
-; NOT_CGSCC_NPM-NEXT:    call void @test_unreachable() #[[ATTR0]]
+; 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-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() #[[ATTR17:[0-9]+]]
-; IS__CGSCC____-NEXT:    call void @test_unreachable() #[[ATTR0]]
+; IS__CGSCC____-SAME: () [[ATTR0:#.*]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16:#.*]]
+; 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:[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:    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:    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() #[[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:    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:    br label [[BB1:%.*]]
 ; IS__CGSCC____:       bb1:
-; 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:    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:    br label [[BB2:%.*]]
 ; IS__CGSCC____:       bb2:
-; 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:    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:    br label [[BB3:%.*]]
 ; IS__CGSCC____:       bb3:
-; 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:    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:    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:[0-9]+]] {
-; IS__CGSCC____-NEXT:    call void @sink() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13:#.*]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    call void @useless_arg_sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-NEXT:    call void @sink() [[ATTR16]]
 ; 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() #[[ATTR17]]
+; IS__CGSCC____-SAME: () [[ATTR13]] {
+; IS__CGSCC____-NEXT:    [[CALL2:%.*]] = tail call i32 @switch_default() [[ATTR16]]
 ; 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:[0-9]+]] {
+; NOT_CGSCC_NPM-SAME: () [[ATTR12:#.*]] {
 ; 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
-; CHECK-SAME: (i32* [[A:%.*]], i32* [[B:%.*]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef nonnull [[FP:%.*]]) {
+; CHECK-SAME: (i32* [[A:%.*]], i32* [[B:%.*]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree nonnull [[FP:%.*]]) {
 ; CHECK-NEXT:    call void [[FP]](i32* [[A]], i32* [[B]], i32* [[A]], i64 -1, i32** null)
 ; CHECK-NEXT:    ret void
 ;
   call void %fp(i32* %a, i32* %b, i32* %a, i64 -1, i32** null)
   ret void
 }
 ; FIXME: We have to prevent the propagation of %fp in the new pm CGSCC pass until the CallGraphUpdater can handle the new call edge.
 define internal void @call_via_pointer_with_dead_args_internal_a(i32* %a, i32* %b, void (i32*, i32*, i32*, i64, i32**)* %fp) {
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args_internal_a
-; NOT_CGSCC_NPM-SAME: (i32* [[A:%.*]], i32* noundef nonnull align 128 dereferenceable(4) [[B:%.*]]) {
+; NOT_CGSCC_NPM-SAME: (i32* [[A:%.*]], i32* noundef nonnull align 128 dereferenceable(4) [[B:%.*]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef nonnull [[FP:%.*]]) {
 ; NOT_CGSCC_NPM-NEXT:    call void @called_via_pointer(i32* [[A]], i32* nonnull align 128 dereferenceable(4) [[B]], i32* [[A]], i64 -1, i32** null)
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args_internal_a
 ; IS__CGSCC____-SAME: (i32* [[A:%.*]], i32* noundef nonnull align 128 dereferenceable(4) [[B:%.*]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef nonnull [[FP:%.*]]) {
 ; IS__CGSCC____-NEXT:    call void [[FP]](i32* [[A]], i32* nonnull align 128 dereferenceable(4) [[B]], i32* [[A]], i64 -1, i32** null)
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void %fp(i32* %a, i32* %b, i32* %a, i64 -1, i32** null)
   ret void
 }
 define internal void @call_via_pointer_with_dead_args_internal_b(i32* %a, i32* %b, void (i32*, i32*, i32*, i64, i32**)* %fp) {
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args_internal_b
-; NOT_CGSCC_NPM-SAME: (i32* [[A:%.*]], i32* noundef nonnull align 128 dereferenceable(4) [[B:%.*]]) {
+; NOT_CGSCC_NPM-SAME: (i32* [[A:%.*]], i32* noundef nonnull align 128 dereferenceable(4) [[B:%.*]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef nonnull [[FP:%.*]]) {
 ; NOT_CGSCC_NPM-NEXT:    call void @called_via_pointer_internal_2(i32* [[A]], i32* nonnull align 128 dereferenceable(4) [[B]], i32* [[A]], i64 -1, i32** null)
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args_internal_b
 ; IS__CGSCC____-SAME: (i32* [[A:%.*]], i32* noundef nonnull align 128 dereferenceable(4) [[B:%.*]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef nonnull [[FP:%.*]]) {
 ; IS__CGSCC____-NEXT:    call void [[FP]](i32* [[A]], i32* nonnull align 128 dereferenceable(4) [[B]], i32* [[A]], i64 -1, i32** null)
 ; IS__CGSCC____-NEXT:    ret void
 ;
   call void %fp(i32* %a, i32* %b, i32* %a, i64 -1, i32** null)
   ret void
 }
 define void @call_via_pointer_with_dead_args_caller(i32* %a, i32* %b) {
 ; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args_caller
 ; NOT_CGSCC_NPM-SAME: (i32* [[A:%.*]], i32* [[B:%.*]]) {
 ; NOT_CGSCC_NPM-NEXT:    [[PTR1:%.*]] = alloca i32, align 128
 ; NOT_CGSCC_NPM-NEXT:    [[PTR2:%.*]] = alloca i32, align 128
 ; NOT_CGSCC_NPM-NEXT:    [[PTR3:%.*]] = alloca i32, align 128
 ; NOT_CGSCC_NPM-NEXT:    [[PTR4:%.*]] = alloca i32, align 128
 ; NOT_CGSCC_NPM-NEXT:    call void @call_via_pointer_with_dead_args(i32* [[A]], i32* noundef nonnull align 128 dereferenceable(4) [[PTR1]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef @called_via_pointer)
 ; NOT_CGSCC_NPM-NEXT:    call void @call_via_pointer_with_dead_args(i32* [[A]], i32* noundef nonnull align 128 dereferenceable(4) [[PTR2]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef @called_via_pointer_internal_1)
-; NOT_CGSCC_NPM-NEXT:    call void @call_via_pointer_with_dead_args_internal_a(i32* [[B]], i32* noundef nonnull align 128 dereferenceable(4) [[PTR3]])
-; NOT_CGSCC_NPM-NEXT:    call void @call_via_pointer_with_dead_args_internal_b(i32* [[B]], i32* noundef nonnull align 128 dereferenceable(4) [[PTR4]])
+; NOT_CGSCC_NPM-NEXT:    call void @call_via_pointer_with_dead_args_internal_a(i32* [[B]], i32* noundef nonnull align 128 dereferenceable(4) [[PTR3]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef @called_via_pointer)
+; NOT_CGSCC_NPM-NEXT:    call void @call_via_pointer_with_dead_args_internal_b(i32* [[B]], i32* noundef nonnull align 128 dereferenceable(4) [[PTR4]], void (i32*, i32*, i32*, i64, i32**)* nocapture nofree noundef @called_via_pointer_internal_2)
 ; NOT_CGSCC_NPM-NEXT:    ret void
 ;
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args_caller
 ; IS__CGSCC____-SAME: (i32* [[A:%.*]], i32* [[B:%.*]]) {
 ; IS__CGSCC____-NEXT:    [[PTR1:%.*]] = alloca i32, align 128
 ; IS__CGSCC____-NEXT:    [[PTR2:%.*]] = alloca i32, align 128
 ; IS__CGSCC____-NEXT:    [[PTR3:%.*]] = alloca i32, align 128
 ; IS__CGSCC____-NEXT:    [[PTR4:%.*]] = alloca i32, align 128

 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* noalias nocapture nofree nonnull readonly align 536870912 dereferenceable(4294967295) [[PC:%.*]])
+; IS__CGSCC_OPM-SAME: (i32* nocapture [[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: () #[[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:    indirectbr i8* undef, [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

 
 ; The code below exposed a bug that caused %call to be replaced with `undef`.
 
 %struct.a = type { %struct.a* }
 
 @e = global %struct.a* null
 
 define i32 @main() {
-; CHECK-LABEL: define {{[^@]+}}@main() {
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[F:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    br label [[FOR_COND_0:%.*]]
-; CHECK:       for.cond.0:
-; CHECK-NEXT:    [[G_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY_0:%.*]] ]
-; CHECK-NEXT:    [[CMP_0:%.*]] = icmp ult i32 [[G_0]], 100
-; CHECK-NEXT:    br i1 [[CMP_0]], label [[FOR_BODY_0]], label [[FOR_END_0:%.*]]
-; CHECK:       for.body.0:
-; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[G_0]], 1
-; CHECK-NEXT:    br label [[FOR_COND_0]]
-; CHECK:       for.end.0:
-; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i64 noundef 8)
-; CHECK-NEXT:    store i8* [[CALL]], i8** bitcast (%struct.a** @e to i8**), align 8
-; CHECK-NEXT:    [[B:%.*]] = bitcast i8* [[CALL]] to %struct.a**
-; CHECK-NEXT:    store %struct.a* null, %struct.a** [[B]], align 8
-; CHECK-NEXT:    br label [[FOR_COND_1:%.*]]
-; CHECK:       for.cond.1:
-; CHECK-NEXT:    [[G_1:%.*]] = phi i32 [ 0, [[FOR_END_0]] ], [ [[INC6:%.*]], [[FOR_BODY_1:%.*]] ]
-; CHECK-NEXT:    [[CMP_1:%.*]] = icmp ult i32 [[G_1]], 100
-; CHECK-NEXT:    br i1 [[CMP_1]], label [[FOR_BODY_1]], label [[FOR_END_1:%.*]]
-; CHECK:       for.body.1:
-; CHECK-NEXT:    [[CALL4:%.*]] = call i32 (i32*, ...) bitcast (i32 (i32)* @h to i32 (i32*, ...)*)(i32* nonnull [[F]])
-; CHECK-NEXT:    [[INC6]] = add nuw nsw i32 [[G_1]], 1
-; CHECK-NEXT:    br label [[FOR_COND_1]]
-; CHECK:       for.end.1:
-; CHECK-NEXT:    ret i32 0
+; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@main() {
+; NOT_CGSCC_NPM-NEXT:  entry:
+; NOT_CGSCC_NPM-NEXT:    [[F:%.*]] = alloca i32, align 4
+; NOT_CGSCC_NPM-NEXT:    br label [[FOR_COND_0:%.*]]
+; NOT_CGSCC_NPM:       for.cond.0:
+; NOT_CGSCC_NPM-NEXT:    [[G_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY_0:%.*]] ]
+; NOT_CGSCC_NPM-NEXT:    [[CMP_0:%.*]] = icmp ult i32 [[G_0]], 100
+; NOT_CGSCC_NPM-NEXT:    br i1 [[CMP_0]], label [[FOR_BODY_0]], label [[FOR_END_0:%.*]]
+; NOT_CGSCC_NPM:       for.body.0:
+; NOT_CGSCC_NPM-NEXT:    [[INC]] = add nuw nsw i32 [[G_0]], 1
+; NOT_CGSCC_NPM-NEXT:    br label [[FOR_COND_0]]
+; NOT_CGSCC_NPM:       for.end.0:
+; NOT_CGSCC_NPM-NEXT:    [[CALL:%.*]] = call i8* @malloc(i64 noundef 8)
+; NOT_CGSCC_NPM-NEXT:    store i8* [[CALL]], i8** bitcast (%struct.a** @e to i8**), align 8
+; NOT_CGSCC_NPM-NEXT:    [[B:%.*]] = bitcast i8* [[CALL]] to %struct.a**
+; NOT_CGSCC_NPM-NEXT:    store %struct.a* null, %struct.a** [[B]], align 8
+; NOT_CGSCC_NPM-NEXT:    br label [[FOR_COND_1:%.*]]
+; NOT_CGSCC_NPM:       for.cond.1:
+; NOT_CGSCC_NPM-NEXT:    [[G_1:%.*]] = phi i32 [ 0, [[FOR_END_0]] ], [ [[INC6:%.*]], [[FOR_BODY_1:%.*]] ]
+; NOT_CGSCC_NPM-NEXT:    [[CMP_1:%.*]] = icmp ult i32 [[G_1]], 100
+; NOT_CGSCC_NPM-NEXT:    br i1 [[CMP_1]], label [[FOR_BODY_1]], label [[FOR_END_1:%.*]]
+; NOT_CGSCC_NPM:       for.body.1:
+; NOT_CGSCC_NPM-NEXT:    [[CALL4:%.*]] = call i32 (i32*, ...) bitcast (i32 (i32)* @h to i32 (i32*, ...)*)(i32* nonnull [[F]])
+; NOT_CGSCC_NPM-NEXT:    [[INC6]] = add nuw nsw i32 [[G_1]], 1
+; NOT_CGSCC_NPM-NEXT:    br label [[FOR_COND_1]]
+; NOT_CGSCC_NPM:       for.end.1:
+; NOT_CGSCC_NPM-NEXT:    ret i32 0
+;
+; IS__CGSCC____-LABEL: define {{[^@]+}}@main() {
+; IS__CGSCC____-NEXT:  entry:
+; IS__CGSCC____-NEXT:    br label [[FOR_COND_0:%.*]]
+; IS__CGSCC____:       for.cond.0:
+; IS__CGSCC____-NEXT:    [[G_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY_0:%.*]] ]
+; IS__CGSCC____-NEXT:    [[CMP_0:%.*]] = icmp ult i32 [[G_0]], 100
+; IS__CGSCC____-NEXT:    br i1 [[CMP_0]], label [[FOR_BODY_0]], label [[FOR_END_0:%.*]]
+; IS__CGSCC____:       for.body.0:
+; IS__CGSCC____-NEXT:    [[INC]] = add nuw nsw i32 [[G_0]], 1
+; IS__CGSCC____-NEXT:    br label [[FOR_COND_0]]
+; IS__CGSCC____:       for.end.0:
+; IS__CGSCC____-NEXT:    [[CALL:%.*]] = call i8* @malloc(i64 noundef 8)
+; IS__CGSCC____-NEXT:    store i8* [[CALL]], i8** bitcast (%struct.a** @e to i8**), align 8
+; IS__CGSCC____-NEXT:    [[B:%.*]] = bitcast i8* [[CALL]] to %struct.a**
+; IS__CGSCC____-NEXT:    store %struct.a* null, %struct.a** [[B]], align 8
+; IS__CGSCC____-NEXT:    br label [[FOR_COND_1:%.*]]
+; IS__CGSCC____:       for.cond.1:
+; IS__CGSCC____-NEXT:    [[G_1:%.*]] = phi i32 [ 0, [[FOR_END_0]] ], [ [[INC6:%.*]], [[FOR_BODY_1:%.*]] ]
+; IS__CGSCC____-NEXT:    [[CMP_1:%.*]] = icmp ult i32 [[G_1]], 100
+; IS__CGSCC____-NEXT:    br i1 [[CMP_1]], label [[FOR_BODY_1]], label [[FOR_END_1:%.*]]
+; IS__CGSCC____:       for.body.1:
+; IS__CGSCC____-NEXT:    [[INC6]] = add nuw nsw i32 [[G_1]], 1
+; IS__CGSCC____-NEXT:    br label [[FOR_COND_1]]
+; IS__CGSCC____:       for.end.1:
+; IS__CGSCC____-NEXT:    ret i32 0
 ;
 entry:
   %f = alloca i32
   br label %for.cond.0
 
 for.cond.0:
   %g.0 = phi i32 [ 0, %entry ], [ %inc, %for.body.0 ]
   %cmp.0 = icmp ult i32 %g.0, 100
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:[0-9]+]]
+; 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:    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: () #[[ATTR15:[0-9]+]] {
+; IS__CGSCC____-SAME: () [[ATTR14:#.*]] {
 ; 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]]) #[[ATTR18:[0-9]+]]
+; 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:    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]]) #[[ATTR18]]
+; 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:    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:[0-9]+]] = { 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 }
-;.