Fix testcases to not rely upon target-* attributes.

llvm-svn: 176135

19 files changed, 270 insertions, 289 deletions

diff --git a/clang/test/CodeGen/2008-04-08-NoExceptions.c b/clang/test/CodeGen/2008-04-08-NoExceptions.c
index 7d533b7a3a2..254d30ac3c2 100644
--- a/clang/test/CodeGen/2008-04-08-NoExceptions.c
+++ b/clang/test/CodeGen/2008-04-08-NoExceptions.c
@@ -9,5 +9,4 @@ void g(void) {
 
 // CHECK-NOT: declare void @f() #0
 
-// CHECK: attributes #0 = { nounwind {{.*}} }
-// CHECK: attributes #1 = { "target-features"={{.*}} }
+// CHECK: attributes #0 = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/address-space-field1.c b/clang/test/CodeGen/address-space-field1.c
index 9f23b24aca5..c6b31812a1d 100644
--- a/clang/test/CodeGen/address-space-field1.c
+++ b/clang/test/CodeGen/address-space-field1.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin10 < %s -o - | FileCheck %s
 // CHECK:%struct.S = type { i32, i32 }
-// CHECK:define void @test_addrspace(%struct.S addrspace(1)* %p1, %struct.S addrspace(2)* %p2) #0
+// CHECK:define void @test_addrspace(%struct.S addrspace(1)* %p1, %struct.S addrspace(2)* %p2) [[NUW:#[0-9]+]]
 // CHECK:  [[p1addr:%.*]] = alloca %struct.S addrspace(1)*
 // CHECK:  [[p2addr:%.*]] = alloca %struct.S addrspace(2)*
 // CHECK:  store %struct.S addrspace(1)* %p1, %struct.S addrspace(1)** [[p1addr]]
@@ -37,4 +37,4 @@ void test_addrspace(__addr1 S* p1, __addr2 S*p2) {
   p1->b = p2->a;
 }
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/alias.c b/clang/test/CodeGen/alias.c
index 113b26def2f..a8380a37c58 100644
--- a/clang/test/CodeGen/alias.c
+++ b/clang/test/CodeGen/alias.c
@@ -14,7 +14,7 @@ void f0(void) { }
 extern void f1(void);
 extern void f1(void) __attribute((alias("f0")));
 // CHECKBASIC: @f1 = alias void ()* @f0
-// CHECKBASIC: define void @f0() #0 {
+// CHECKBASIC: define void @f0() [[NUW:#[0-9]+]] {
 
 // Make sure that aliases cause referenced values to be emitted.
 // PR3200
@@ -34,19 +34,17 @@ static int inner_weak(int a) { return 0; }
 extern __typeof(inner) inner_a __attribute__((alias("inner")));
 static __typeof(inner_weak) inner_weak_a __attribute__((weakref, alias("inner_weak")));
 // CHECKCC: @inner_a = alias i32 (i32)* @inner
-// CHECKCC: define internal arm_aapcs_vfpcc i32 @inner(i32 %a) #0 {
+// CHECKCC: define internal arm_aapcs_vfpcc i32 @inner(i32 %a) [[NUW:#[0-9]+]] {
 
 int outer(int a) { return inner(a); }
-// CHECKCC: define arm_aapcs_vfpcc i32 @outer(i32 %a) #0 {
+// CHECKCC: define arm_aapcs_vfpcc i32 @outer(i32 %a) [[NUW]] {
 // CHECKCC: call arm_aapcs_vfpcc  i32 @inner(i32 %{{.*}})
 
 int outer_weak(int a) { return inner_weak_a(a); }
-// CHECKCC: define arm_aapcs_vfpcc i32 @outer_weak(i32 %a) #0 {
+// CHECKCC: define arm_aapcs_vfpcc i32 @outer_weak(i32 %a) [[NUW]] {
 // CHECKCC: call arm_aapcs_vfpcc  i32 @inner_weak(i32 %{{.*}})
-// CHECKCC: define internal arm_aapcs_vfpcc i32 @inner_weak(i32 %a) #0 {
+// CHECKCC: define internal arm_aapcs_vfpcc i32 @inner_weak(i32 %a) [[NUW]] {
 
-// CHECKBASIC: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECKBASIC: attributes #1 = { inlinehint nounwind "target-features"={{.*}} }
+// CHECKBASIC: attributes [[NUW]] = { nounwind{{.*}} }
 
-// CHECKCC: attributes #0 = { nounwind }
-// CHECKCC: attributes #1 = { inlinehint nounwind }
+// CHECKCC: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/attr-naked.c b/clang/test/CodeGen/attr-naked.c
index 8490d463a23..c07dd8d3732 100644
--- a/clang/test/CodeGen/attr-naked.c
+++ b/clang/test/CodeGen/attr-naked.c
@@ -4,15 +4,15 @@ void t1() __attribute__((naked));
 
 // Basic functionality check
 // (Note that naked needs to imply noinline to work properly.)
-// CHECK: define void @t1() #0 {
+// CHECK: define void @t1() [[NAKED:#[0-9]+]] {
 void t1()
 {
 }
 
 // Make sure this doesn't explode in the verifier.
 // (It doesn't really make sense, but it isn't invalid.)
-// CHECK: define void @t2() #0 {
+// CHECK: define void @t2() [[NAKED]] {
 __attribute((naked, always_inline)) void t2()  {
 }
 
-// CHECK: attributes #0 = { naked noinline nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} }
diff --git a/clang/test/CodeGen/attributes.c b/clang/test/CodeGen/attributes.c
index 49746ba5237..356a17996a8 100644
--- a/clang/test/CodeGen/attributes.c
+++ b/clang/test/CodeGen/attributes.c
@@ -36,39 +36,39 @@ int t17() {
   return t15() + t16;
 }
 
-// CHECK: define void @t1() #2 {
+// CHECK: define void @t1() [[NR:#[0-9]+]] {
 void t1() __attribute__((noreturn));
 void t1() { while (1) {} }
 
-// CHECK: define void @t2() #0 {
+// CHECK: define void @t2() [[NUW:#[0-9]+]] {
 void t2() __attribute__((nothrow));
 void t2() {}
 
-// CHECK: define weak void @t3() #0 {
+// CHECK: define weak void @t3() [[NUW]] {
 void t3() __attribute__((weak));
 void t3() {}
 
-// CHECK: define hidden void @t4() #0 {
+// CHECK: define hidden void @t4() [[NUW]] {
 void t4() __attribute__((visibility("hidden")));
 void t4() {}
 
-// CHECK: define void @t7() #2 {
+// CHECK: define void @t7() [[NR]] {
 void t7() __attribute__((noreturn, nothrow));
 void t7() { while (1) {} }
 
-// CHECK: define void @t10() #0 section "SECT" {
+// CHECK: define void @t10() [[NUW]] section "SECT" {
 void t10(void) __attribute__((section("SECT")));
 void t10(void) {}
-// CHECK: define void @t11() #0 section "SECT" {
+// CHECK: define void @t11() [[NUW]] section "SECT" {
 void __attribute__((section("SECT"))) t11(void) {}
 
-// CHECK: define i32 @t19() #0 {
+// CHECK: define i32 @t19() [[NUW]] {
 extern int t19(void) __attribute__((weak_import));
 int t19(void) {
   return 10;
 }
 
-// CHECK:define void @t20() #0 {
+// CHECK:define void @t20() [[NUW]] {
 // CHECK: call void @abort()
 // CHECK-NEXT: unreachable
 void t20(void) {
@@ -88,8 +88,7 @@ void t21(void) {
 void __attribute__((section(".foo"))) t22(void);
 void __attribute__((section(".bar"))) t22(void) {}
 
-// CHECK: define void @t22() #0 section ".bar"
+// CHECK: define void @t22() [[NUW]] section ".bar"
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECK: attributes #1 = { "target-features"={{.*}} }
-// CHECK: attributes #2 = { noreturn nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
+// CHECK: attributes [[NR]] = { noreturn nounwind{{.*}} }
diff --git a/clang/test/CodeGen/builtin-attributes.c b/clang/test/CodeGen/builtin-attributes.c
index 79026cb54b8..c5c35c38994 100644
--- a/clang/test/CodeGen/builtin-attributes.c
+++ b/clang/test/CodeGen/builtin-attributes.c
@@ -58,5 +58,4 @@ int f3(double x) {
   return e;
 }
 
-// CHECK: attributes [[NUW]] = { nounwind }
-// CHECK: attributes #1 = { noreturn }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/function-attributes.c b/clang/test/CodeGen/function-attributes.c
index 1398d344fb3..25ca9163a19 100644
--- a/clang/test/CodeGen/function-attributes.c
+++ b/clang/test/CodeGen/function-attributes.c
@@ -1,12 +1,12 @@
 // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -Os -o - %s | FileCheck %s
-// CHECK: define signext i8 @f0(i32 %x) #0
-// CHECK: define zeroext i8 @f1(i32 %x) #0
-// CHECK: define void @f2(i8 signext %x) #0
-// CHECK: define void @f3(i8 zeroext %x) #0
-// CHECK: define signext i16 @f4(i32 %x) #0
-// CHECK: define zeroext i16 @f5(i32 %x) #0
-// CHECK: define void @f6(i16 signext %x) #0
-// CHECK: define void @f7(i16 zeroext %x) #0
+// CHECK: define signext i8 @f0(i32 %x) [[NUW:#[0-9]+]]
+// CHECK: define zeroext i8 @f1(i32 %x) [[NUW]]
+// CHECK: define void @f2(i8 signext %x) [[NUW]]
+// CHECK: define void @f3(i8 zeroext %x) [[NUW]]
+// CHECK: define signext i16 @f4(i32 %x) [[NUW]]
+// CHECK: define zeroext i16 @f5(i32 %x) [[NUW]]
+// CHECK: define void @f6(i16 signext %x) [[NUW]]
+// CHECK: define void @f7(i16 zeroext %x) [[NUW]]
 
 signed char f0(int x) { return x; }
 
@@ -25,25 +25,25 @@ void f6(signed short x) { }
 void f7(unsigned short x) { }
 
 // CHECK: define void @f8()
-// CHECK: #1
+// CHECK: [[AI:#[0-9]+]]
 // CHECK: {
 void __attribute__((always_inline)) f8(void) { }
 
 // CHECK: call void @f9_t()
-// CHECK: [[F9:#[0-9]+]]
+// CHECK: [[NR:#[0-9]+]]
 // CHECK: }
 void __attribute__((noreturn)) f9_t(void);
 void f9(void) { f9_t(); }
 
 // CHECK: call void @f9a()
-// CHECK: [[F9]]
+// CHECK: [[NR]]
 // CHECK: }
 _Noreturn void f9a(void);
 void f9b(void) { f9a(); }
 
 // FIXME: We should be setting nounwind on calls.
 // CHECK: call i32 @f10_t()
-// CHECK: [[F10_T:#[0-9]+]]
+// CHECK: [[NUW_RN:#[0-9]+]]
 // CHECK: {
 int __attribute__((const)) f10_t(void);
 int f10(void) { return f10_t(); }
@@ -55,7 +55,7 @@ int f12(int arg) {
   return arg ? 0 : f10_t();
 }
 
-// CHECK: define void @f13() #0
+// CHECK: define void @f13() [[NUW]]
 void f13(void) __attribute__((pure)) __attribute__((const));
 void f13(void){}
 
@@ -82,24 +82,24 @@ void f14(int a) {
 
 // <rdar://problem/7102668> [irgen] clang isn't setting the optsize bit on functions
 // CHECK: define void @f15
-// CHECK: #0
+// CHECK: [[NUW]]
 // CHECK: {
 void f15(void) {
 }
 
 // PR5254
 // CHECK: define void @f16
-// CHECK: #6
+// CHECK: [[ALIGN:#[0-9]+]]
 // CHECK: {
 void __attribute__((force_align_arg_pointer)) f16(void) {
 }
 
 // PR11038
 // CHECK: define void @f18()
-// CHECK: #7
+// CHECK: [[RT:#[0-9]+]]
 // CHECK: {
 // CHECK: call void @f17()
-// CHECK: [[F17:#[0-9]+]]
+// CHECK: [[RT_CALL:#[0-9]+]]
 // CHECK: ret void
 __attribute__ ((returns_twice)) void f17(void);
 __attribute__ ((returns_twice)) void f18(void) {
@@ -109,7 +109,7 @@ __attribute__ ((returns_twice)) void f18(void) {
 // CHECK: define void @f19()
 // CHECK: {
 // CHECK: call i32 @setjmp(i32* null)
-// CHECK: [[F17]]
+// CHECK: [[RT_CALL]]
 // CHECK: ret void
 typedef int jmp_buf[((9 * 2) + 3 + 16)];
 int setjmp(jmp_buf);
@@ -117,15 +117,10 @@ void f19(void) {
   setjmp(0);
 }
 
-// CHECK: attributes #0 = { nounwind optsize readnone "target-features"={{.*}} }
-// CHECK: attributes #1 = { alwaysinline nounwind optsize readnone "target-features"={{.*}} }
-// CHECK: attributes #2 = { noreturn nounwind optsize "target-features"={{.*}} }
-// CHECK: attributes #3 = { noreturn optsize "target-features"={{.*}} }
-// CHECK: attributes #4 = { nounwind optsize "target-features"={{.*}} }
-// CHECK: attributes #5 = { optsize "target-features"={{.*}} }
-// CHECK: attributes #6 = { nounwind optsize readnone alignstack=16 "target-features"={{.*}} }
-// CHECK: attributes #7 = { nounwind optsize returns_twice "target-features"={{.*}} }
-// CHECK: attributes #8 = { optsize returns_twice "target-features"={{.*}}
-// CHECK: attributes [[F9]] = { noreturn nounwind optsize }
-// CHECK: attributes [[F10_T]] = { nounwind optsize readnone }
-// CHECK: attributes [[F17]] = { nounwind optsize returns_twice }
+// CHECK: attributes [[NUW]] = { nounwind optsize readnone{{.*}} }
+// CHECK: attributes [[AI]] = { alwaysinline nounwind optsize readnone{{.*}} }
+// CHECK: attributes [[ALIGN]] = { nounwind optsize readnone alignstack=16{{.*}} }
+// CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} }
+// CHECK: attributes [[NR]] = { noreturn nounwind optsize }
+// CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone }
+// CHECK: attributes [[RT_CALL]] = { nounwind optsize returns_twice }
diff --git a/clang/test/CodeGen/incomplete-function-type-2.c b/clang/test/CodeGen/incomplete-function-type-2.c
index b696f77765a..41dd5fec4b2 100644
--- a/clang/test/CodeGen/incomplete-function-type-2.c
+++ b/clang/test/CodeGen/incomplete-function-type-2.c
@@ -2,7 +2,7 @@
 
 // PR14355: don't crash
 // Keep this test in its own file because CodeGenTypes has global state.
-// CHECK: define void @test10_foo({}* %p1.coerce) #0 {
+// CHECK: define void @test10_foo({}* %p1.coerce) [[NUW:#[0-9]+]] {
 struct test10_B;
 typedef struct test10_B test10_F3(double);
 void test10_foo(test10_F3 p1);
@@ -16,4 +16,4 @@ void test10_foo(test10_F3 p1)
   p1(0.0);
 }
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/libcall-declarations.c b/clang/test/CodeGen/libcall-declarations.c
index c24839a7eec..d07590ff117 100644
--- a/clang/test/CodeGen/libcall-declarations.c
+++ b/clang/test/CodeGen/libcall-declarations.c
@@ -86,111 +86,110 @@ void *use[] = {
   sqrtf, tan, tanl, tanf, trunc, truncl, truncf
 };
 
-// CHECK-NOERRNO: declare double @acos(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @acosl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @acosf(float) #0
-// CHECK-NOERRNO: declare double @asin(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @asinl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @asinf(float) #0
-// CHECK-NOERRNO: declare double @atan(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @atanl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @atanf(float) #0
-// CHECK-NOERRNO: declare double @atan2(double, double) #0
-// CHECK-NOERRNO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) #0
-// CHECK-NOERRNO: declare float @atan2f(float, float) #0
-// CHECK-NOERRNO: declare double @ceil(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @ceill(x86_fp80) #0
-// CHECK-NOERRNO: declare float @ceilf(float) #0
-// CHECK-NOERRNO: declare double @copysign(double, double) #0
-// CHECK-NOERRNO: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) #0
-// CHECK-NOERRNO: declare float @copysignf(float, float) #0
-// CHECK-NOERRNO: declare double @cos(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @cosl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @cosf(float) #0
-// CHECK-NOERRNO: declare double @exp(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @expl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @expf(float) #0
-// CHECK-NOERRNO: declare double @exp2(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @exp2l(x86_fp80) #0
-// CHECK-NOERRNO: declare float @exp2f(float) #0
-// CHECK-NOERRNO: declare double @fabs(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @fabsl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @fabsf(float) #0
-// CHECK-NOERRNO: declare double @floor(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @floorl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @floorf(float) #0
-// CHECK-NOERRNO: declare double @fma(double, double, double) #0
-// CHECK-NOERRNO: declare x86_fp80 @fmal(x86_fp80, x86_fp80, x86_fp80) #0
-// CHECK-NOERRNO: declare float @fmaf(float, float, float) #0
-// CHECK-NOERRNO: declare double @fmax(double, double) #0
-// CHECK-NOERRNO: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) #0
-// CHECK-NOERRNO: declare float @fmaxf(float, float) #0
-// CHECK-NOERRNO: declare double @fmin(double, double) #0
-// CHECK-NOERRNO: declare x86_fp80 @fminl(x86_fp80, x86_fp80) #0
-// CHECK-NOERRNO: declare float @fminf(float, float) #0
-// CHECK-NOERRNO: declare double @log(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @logl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @logf(float) #0
-// CHECK-NOERRNO: declare double @log2(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @log2l(x86_fp80) #0
-// CHECK-NOERRNO: declare float @log2f(float) #0
-// CHECK-NOERRNO: declare double @nearbyint(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @nearbyintl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @nearbyintf(float) #0
-// CHECK-NOERRNO: declare double @pow(double, double) #0
-// CHECK-NOERRNO: declare x86_fp80 @powl(x86_fp80, x86_fp80) #0
-// CHECK-NOERRNO: declare float @powf(float, float) #0
-// CHECK-NOERRNO: declare double @rint(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @rintl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @rintf(float) #0
-// CHECK-NOERRNO: declare double @round(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @roundl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @roundf(float) #0
-// CHECK-NOERRNO: declare double @sin(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @sinl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @sinf(float) #0
-// CHECK-NOERRNO: declare double @sqrt(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @sqrtl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @sqrtf(float) #0
-// CHECK-NOERRNO: declare double @tan(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @tanl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @tanf(float) #0
-// CHECK-NOERRNO: declare double @trunc(double) #0
-// CHECK-NOERRNO: declare x86_fp80 @truncl(x86_fp80) #0
-// CHECK-NOERRNO: declare float @truncf(float) #0
+// CHECK-NOERRNO: declare double @acos(double) [[NUW:#[0-9]+]]
+// CHECK-NOERRNO: declare x86_fp80 @acosl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @acosf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @asin(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @asinl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @asinf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @atan(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @atanl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @atanf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @atan2(double, double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @atan2f(float, float) [[NUW]]
+// CHECK-NOERRNO: declare double @ceil(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @ceill(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @ceilf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @copysign(double, double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @copysignf(float, float) [[NUW]]
+// CHECK-NOERRNO: declare double @cos(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @cosl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @cosf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @exp(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @expl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @expf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @exp2(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @exp2l(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @exp2f(float) [[NUW]]
+// CHECK-NOERRNO: declare double @fabs(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @fabsl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @fabsf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @floor(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @floorl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @floorf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @fma(double, double, double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @fmal(x86_fp80, x86_fp80, x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @fmaf(float, float, float) [[NUW]]
+// CHECK-NOERRNO: declare double @fmax(double, double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @fmaxf(float, float) [[NUW]]
+// CHECK-NOERRNO: declare double @fmin(double, double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @fminl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @fminf(float, float) [[NUW]]
+// CHECK-NOERRNO: declare double @log(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @logl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @logf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @log2(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @log2l(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @log2f(float) [[NUW]]
+// CHECK-NOERRNO: declare double @nearbyint(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @nearbyintl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @nearbyintf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @pow(double, double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @powl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @powf(float, float) [[NUW]]
+// CHECK-NOERRNO: declare double @rint(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @rintl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @rintf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @round(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @roundl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @roundf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @sin(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @sinl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @sinf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @sqrt(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @sqrtl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @sqrtf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @tan(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @tanl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @tanf(float) [[NUW]]
+// CHECK-NOERRNO: declare double @trunc(double) [[NUW]]
+// CHECK-NOERRNO: declare x86_fp80 @truncl(x86_fp80) [[NUW]]
+// CHECK-NOERRNO: declare float @truncf(float) [[NUW]]
 
-// CHECK-ERRNO: declare double @ceil(double) #1
-// CHECK-ERRNO: declare x86_fp80 @ceill(x86_fp80) #1
-// CHECK-ERRNO: declare float @ceilf(float) #1
-// CHECK-ERRNO: declare double @copysign(double, double) #1
-// CHECK-ERRNO: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) #1
-// CHECK-ERRNO: declare float @copysignf(float, float) #1
-// CHECK-ERRNO: declare double @fabs(double) #1
-// CHECK-ERRNO: declare x86_fp80 @fabsl(x86_fp80) #1
-// CHECK-ERRNO: declare float @fabsf(float) #1
-// CHECK-ERRNO: declare double @floor(double) #1
-// CHECK-ERRNO: declare x86_fp80 @floorl(x86_fp80) #1
-// CHECK-ERRNO: declare float @floorf(float) #1
-// CHECK-ERRNO: declare double @fmax(double, double) #1
-// CHECK-ERRNO: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) #1
-// CHECK-ERRNO: declare float @fmaxf(float, float) #1
-// CHECK-ERRNO: declare double @fmin(double, double) #1
-// CHECK-ERRNO: declare x86_fp80 @fminl(x86_fp80, x86_fp80) #1
-// CHECK-ERRNO: declare float @fminf(float, float) #1
-// CHECK-ERRNO: declare double @nearbyint(double) #1
-// CHECK-ERRNO: declare x86_fp80 @nearbyintl(x86_fp80) #1
-// CHECK-ERRNO: declare float @nearbyintf(float) #1
-// CHECK-ERRNO: declare double @rint(double) #1
-// CHECK-ERRNO: declare x86_fp80 @rintl(x86_fp80) #1
-// CHECK-ERRNO: declare float @rintf(float) #1
-// CHECK-ERRNO: declare double @round(double) #1
-// CHECK-ERRNO: declare x86_fp80 @roundl(x86_fp80) #1
-// CHECK-ERRNO: declare float @roundf(float) #1
-// CHECK-ERRNO: declare double @trunc(double) #1
-// CHECK-ERRNO: declare x86_fp80 @truncl(x86_fp80) #1
-// CHECK-ERRNO: declare float @truncf(float) #1
+// CHECK-ERRNO: declare double @ceil(double) [[NUW:#[0-9]+]]
+// CHECK-ERRNO: declare x86_fp80 @ceill(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @ceilf(float) [[NUW]]
+// CHECK-ERRNO: declare double @copysign(double, double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @copysignf(float, float) [[NUW]]
+// CHECK-ERRNO: declare double @fabs(double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @fabsl(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @fabsf(float) [[NUW]]
+// CHECK-ERRNO: declare double @floor(double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @floorl(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @floorf(float) [[NUW]]
+// CHECK-ERRNO: declare double @fmax(double, double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @fmaxf(float, float) [[NUW]]
+// CHECK-ERRNO: declare double @fmin(double, double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @fminl(x86_fp80, x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @fminf(float, float) [[NUW]]
+// CHECK-ERRNO: declare double @nearbyint(double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @nearbyintl(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @nearbyintf(float) [[NUW]]
+// CHECK-ERRNO: declare double @rint(double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @rintl(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @rintf(float) [[NUW]]
+// CHECK-ERRNO: declare double @round(double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @roundl(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @roundf(float) [[NUW]]
+// CHECK-ERRNO: declare double @trunc(double) [[NUW]]
+// CHECK-ERRNO: declare x86_fp80 @truncl(x86_fp80) [[NUW]]
+// CHECK-ERRNO: declare float @truncf(float) [[NUW]]
 
-// CHECK-NOERRNO: attributes #0 = { nounwind readnone "target-features"={{.*}} }
+// CHECK-NOERRNO: attributes [[NUW]] = { nounwind readnone{{.*}} }
 
-// CHECK-ERRNO: attributes #0 = { "target-features"={{.*}} }
-// CHECK-ERRNO: attributes #1 = { nounwind readnone "target-features"={{.*}} }
+// CHECK-ERRNO: attributes [[NUW]] = { nounwind readnone{{.*}} }
diff --git a/clang/test/CodeGen/libcalls.c b/clang/test/CodeGen/libcalls.c
index eb233ba2954..d882b0ef971 100644
--- a/clang/test/CodeGen/libcalls.c
+++ b/clang/test/CodeGen/libcalls.c
@@ -24,9 +24,9 @@ void test_sqrt(float a0, double a1, long double a2) {
 // CHECK-YES: declare float @sqrtf(float)
 // CHECK-YES: declare double @sqrt(double)
 // CHECK-YES: declare x86_fp80 @sqrtl(x86_fp80)
-// CHECK-NO: declare float @sqrtf(float) #1
-// CHECK-NO: declare double @sqrt(double) #1
-// CHECK-NO: declare x86_fp80 @sqrtl(x86_fp80) #1
+// CHECK-NO: declare float @sqrtf(float) [[NUW_RN1:#[0-9]+]]
+// CHECK-NO: declare double @sqrt(double) [[NUW_RN1]]
+// CHECK-NO: declare x86_fp80 @sqrtl(x86_fp80) [[NUW_RN1]]
 
 // CHECK-YES: define void @test_pow
 // CHECK-NO: define void @test_pow
@@ -47,9 +47,9 @@ void test_pow(float a0, double a1, long double a2) {
 // CHECK-YES: declare float @powf(float, float)
 // CHECK-YES: declare double @pow(double, double)
 // CHECK-YES: declare x86_fp80 @powl(x86_fp80, x86_fp80)
-// CHECK-NO: declare float @llvm.pow.f32(float, float) #2
-// CHECK-NO: declare double @llvm.pow.f64(double, double) #2
-// CHECK-NO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) #2
+// CHECK-NO: declare float @llvm.pow.f32(float, float) [[NUW_RO:#[0-9]+]]
+// CHECK-NO: declare double @llvm.pow.f64(double, double) [[NUW_RO]]
+// CHECK-NO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[NUW_RO]]
 
 // CHECK-YES: define void @test_fma
 // CHECK-NO: define void @test_fma
@@ -67,12 +67,12 @@ void test_fma(float a0, double a1, long double a2) {
     long double l2 = fmal(a2, a2, a2);
 }
 
-// CHECK-YES: declare float @llvm.fma.f32(float, float, float) #2
-// CHECK-YES: declare double @llvm.fma.f64(double, double, double) #2
-// CHECK-YES: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) #2
-// CHECK-NO: declare float @llvm.fma.f32(float, float, float) #3
-// CHECK-NO: declare double @llvm.fma.f64(double, double, double) #3
-// CHECK-NO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) #3
+// CHECK-YES: declare float @llvm.fma.f32(float, float, float) [[NUW_RN:#[0-9]+]]
+// CHECK-YES: declare double @llvm.fma.f64(double, double, double) [[NUW_RN]]
+// CHECK-YES: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[NUW_RN]]
+// CHECK-NO: declare float @llvm.fma.f32(float, float, float) [[NUW_RN2:#[0-9]+]]
+// CHECK-NO: declare double @llvm.fma.f64(double, double, double) [[NUW_RN2]]
+// CHECK-NO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[NUW_RN2]]
 
 // Just checking to make sure these library functions are marked readnone
 void test_builtins(double d, float f, long double ld) {
@@ -81,49 +81,46 @@ void test_builtins(double d, float f, long double ld) {
   double atan_ = atan(d);
   long double atanl_ = atanl(ld);
   float atanf_ = atanf(f);
-// CHECK-NO: declare double @atan(double) #1
-// CHECK-NO: declare x86_fp80 @atanl(x86_fp80) #1
-// CHECK-NO: declare float @atanf(float) #1
-// CHECK-YES-NOT: declare double @atan(double) #2
-// CHECK-YES-NOT: declare x86_fp80 @atanl(x86_fp80) #2
-// CHECK-YES-NOT: declare float @atanf(float) #2
+// CHECK-NO: declare double @atan(double) [[NUW_RN1]]
+// CHECK-NO: declare x86_fp80 @atanl(x86_fp80) [[NUW_RN1]]
+// CHECK-NO: declare float @atanf(float) [[NUW_RN1]]
+// CHECK-YES-NOT: declare double @atan(double) [[NUW_RN]]
+// CHECK-YES-NOT: declare x86_fp80 @atanl(x86_fp80) [[NUW_RN]]
+// CHECK-YES-NOT: declare float @atanf(float) [[NUW_RN]]
 
   double atan2_ = atan2(d, 2);
   long double atan2l_ = atan2l(ld, ld);
   float atan2f_ = atan2f(f, f);
-// CHECK-NO: declare double @atan2(double, double) #1
-// CHECK-NO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) #1
-// CHECK-NO: declare float @atan2f(float, float) #1
-// CHECK-YES-NOT: declare double @atan2(double, double) #2
-// CHECK-YES-NOT: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) #2
-// CHECK-YES-NOT: declare float @atan2f(float, float) #2
+// CHECK-NO: declare double @atan2(double, double) [[NUW_RN1]]
+// CHECK-NO: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NUW_RN1]]
+// CHECK-NO: declare float @atan2f(float, float) [[NUW_RN1]]
+// CHECK-YES-NOT: declare double @atan2(double, double) [[NUW_RN]]
+// CHECK-YES-NOT: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[NUW_RN]]
+// CHECK-YES-NOT: declare float @atan2f(float, float) [[NUW_RN]]
 
   double exp_ = exp(d);
   long double expl_ = expl(ld);
   float expf_ = expf(f);
-// CHECK-NO: declare double @exp(double) #1
-// CHECK-NO: declare x86_fp80 @expl(x86_fp80) #1
-// CHECK-NO: declare float @expf(float) #1
-// CHECK-YES-NOT: declare double @exp(double) #2
-// CHECK-YES-NOT: declare x86_fp80 @expl(x86_fp80) #2
-// CHECK-YES-NOT: declare float @expf(float) #2
+// CHECK-NO: declare double @exp(double) [[NUW_RN1]]
+// CHECK-NO: declare x86_fp80 @expl(x86_fp80) [[NUW_RN1]]
+// CHECK-NO: declare float @expf(float) [[NUW_RN1]]
+// CHECK-YES-NOT: declare double @exp(double) [[NUW_RN]]
+// CHECK-YES-NOT: declare x86_fp80 @expl(x86_fp80) [[NUW_RN]]
+// CHECK-YES-NOT: declare float @expf(float) [[NUW_RN]]
 
   double log_ = log(d);
   long double logl_ = logl(ld);
   float logf_ = logf(f);
-// CHECK-NO: declare double @log(double) #1
-// CHECK-NO: declare x86_fp80 @logl(x86_fp80) #1
-// CHECK-NO: declare float @logf(float) #1
-// CHECK-YES-NOT: declare double @log(double) #2
-// CHECK-YES-NOT: declare x86_fp80 @logl(x86_fp80) #2
-// CHECK-YES-NOT: declare float @logf(float) #2
+// CHECK-NO: declare double @log(double) [[NUW_RN1]]
+// CHECK-NO: declare x86_fp80 @logl(x86_fp80) [[NUW_RN1]]
+// CHECK-NO: declare float @logf(float) [[NUW_RN1]]
+// CHECK-YES-NOT: declare double @log(double) [[NUW_RN]]
+// CHECK-YES-NOT: declare x86_fp80 @logl(x86_fp80) [[NUW_RN]]
+// CHECK-YES-NOT: declare float @logf(float) [[NUW_RN]]
 }
 
-// CHECK-YES: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECK-YES: attributes #1 = { "target-features"={{.*}} }
-// CHECK-YES: attributes #2 = { nounwind readnone }
+// CHECK-YES: attributes [[NUW_RN]] = { nounwind readnone }
 
-// CHECK-NO: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECK-NO: attributes #1 = { nounwind readnone "target-features"={{.*}} }
-// CHECK-NO: attributes #2 = { nounwind readonly }
-// CHECK-NO: attributes #3 = { nounwind readnone }
+// CHECK-NO: attributes [[NUW_RN1]] = { nounwind readnone{{.*}} }
+// CHECK-NO: attributes [[NUW_RO]] = { nounwind readonly }
+// CHECK-NO: attributes [[NUW_RN2]] = { nounwind readnone }
diff --git a/clang/test/CodeGen/mips-vector-arg.c b/clang/test/CodeGen/mips-vector-arg.c
index 9b2b35c8b70..3202ebd6309 100644
--- a/clang/test/CodeGen/mips-vector-arg.c
+++ b/clang/test/CodeGen/mips-vector-arg.c
@@ -8,26 +8,26 @@
 typedef float  v4sf __attribute__ ((__vector_size__ (16)));
 typedef int v4i32 __attribute__ ((__vector_size__ (16)));
 
-// O32: define void @test_v4sf(i32 %a1.coerce0, i32 %a1.coerce1, i32 %a1.coerce2, i32 %a1.coerce3, i32 %a2, i32, i32 %a3.coerce0, i32 %a3.coerce1, i32 %a3.coerce2, i32 %a3.coerce3) #0
+// O32: define void @test_v4sf(i32 %a1.coerce0, i32 %a1.coerce1, i32 %a1.coerce2, i32 %a1.coerce3, i32 %a2, i32, i32 %a3.coerce0, i32 %a3.coerce1, i32 %a3.coerce2, i32 %a3.coerce3) [[NUW1:#[0-9]+]]
 // O32: declare i32 @test_v4sf_2(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32)
-// N64: define void @test_v4sf(i64 %a1.coerce0, i64 %a1.coerce1, i32 %a2, i64, i64 %a3.coerce0, i64 %a3.coerce1) #0
+// N64: define void @test_v4sf(i64 %a1.coerce0, i64 %a1.coerce1, i32 %a2, i64, i64 %a3.coerce0, i64 %a3.coerce1) [[NUW1:#[0-9]+]]
 // N64: declare i32 @test_v4sf_2(i64, i64, i32, i64, i64, i64)
 extern test_v4sf_2(v4sf, int, v4sf);
 void test_v4sf(v4sf a1, int a2, v4sf a3) {
   test_v4sf_2(a3, a2, a1);
 }
 
-// O32: define void @test_v4i32(i32 %a1.coerce0, i32 %a1.coerce1, i32 %a1.coerce2, i32 %a1.coerce3, i32 %a2, i32, i32 %a3.coerce0, i32 %a3.coerce1, i32 %a3.coerce2, i32 %a3.coerce3) #0
+// O32: define void @test_v4i32(i32 %a1.coerce0, i32 %a1.coerce1, i32 %a1.coerce2, i32 %a1.coerce3, i32 %a2, i32, i32 %a3.coerce0, i32 %a3.coerce1, i32 %a3.coerce2, i32 %a3.coerce3) [[NUW2:#[0-9]+]]
 // O32: declare i32 @test_v4i32_2(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32)
-// N64: define void @test_v4i32(i64 %a1.coerce0, i64 %a1.coerce1, i32 %a2, i64, i64 %a3.coerce0, i64 %a3.coerce1) #0
+// N64: define void @test_v4i32(i64 %a1.coerce0, i64 %a1.coerce1, i32 %a2, i64, i64 %a3.coerce0, i64 %a3.coerce1) [[NUW2:#[0-9]+]]
 // N64: declare i32 @test_v4i32_2(i64, i64, i32, i64, i64, i64)
 extern test_v4i32_2(v4i32, int, v4i32);
 void test_v4i32(v4i32 a1, int a2, v4i32 a3) {
   test_v4i32_2(a3, a2, a1);
 }
 
-// O32: attributes #0 = { nounwind "target-cpu"={{.*}} "target-features"={{.*}} }
-// O32: attributes #1 = { "target-cpu"={{.*}} "target-features"={{.*}} }
+// O32: attributes [[NUW1]] = { nounwind{{.*}} }
+// O32: attributes [[NUW2]] = { nounwind{{.*}} }
 
-// N64: attributes #0 = { nounwind "target-cpu"={{.*}} "target-features"={{.*}} }
-// N64: attributes #1 = { "target-cpu"={{.*}} "target-features"={{.*}} }
+// N64: attributes [[NUW1]] = { nounwind{{.*}} }
+// N64: attributes [[NUW2]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/mrtd.c b/clang/test/CodeGen/mrtd.c
index 743a9d5944b..a40a59ac0fc 100644
--- a/clang/test/CodeGen/mrtd.c
+++ b/clang/test/CodeGen/mrtd.c
@@ -2,7 +2,7 @@
 
 void baz(int arg);
 
-// CHECK: define x86_stdcallcc void @foo(i32 %arg) #0
+// CHECK: define x86_stdcallcc void @foo(i32 %arg) [[NUW:#[0-9]+]]
 void foo(int arg) {
 // CHECK: call x86_stdcallcc i32 bitcast (i32 (...)* @bar to i32 (i32)*)(
   bar(arg);
@@ -14,5 +14,4 @@ void foo(int arg) {
 
 // CHECK: declare x86_stdcallcc void @baz(i32)
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECK: attributes #1 = { "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/ms-declspecs.c b/clang/test/CodeGen/ms-declspecs.c
index c116fbec7aa..26bdc58ebb7 100644
--- a/clang/test/CodeGen/ms-declspecs.c
+++ b/clang/test/CodeGen/ms-declspecs.c
@@ -8,21 +8,21 @@ union { struct S s; } u;
 // CHECK: @u = {{.*}}zeroinitializer, align 16
 
 
-// CHECK: define void @t3() #0 {
+// CHECK: define void @t3() [[NAKED:#[0-9]+]] {
 __declspec(naked) void t3() {}
 
-// CHECK: define void @t22() #1
+// CHECK: define void @t22() [[NUW:#[0-9]+]]
 void __declspec(nothrow) t22();
 void t22() {}
 
-// CHECK: define void @t2() #2 {
+// CHECK: define void @t2() [[NI:#[0-9]+]] {
 __declspec(noinline) void t2() {}
 
 // CHECK: call void @f20_t() [[NR:#[0-9]+]]
 __declspec(noreturn) void f20_t(void);
 void f20(void) { f20_t(); }
 
-// CHECK: attributes #0 = { naked noinline nounwind "target-features"={{.*}} }
-// CHECK: attributes #1 = { nounwind "target-features"={{.*}} }
-// CHECK: attributes #2 = { noinline nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NAKED]] = { naked noinline nounwind{{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
+// CHECK: attributes [[NI]] = { noinline nounwind{{.*}} }
 // CHECK: attributes [[NR]] = { noreturn }
diff --git a/clang/test/CodeGen/ppc64-complex-parms.c b/clang/test/CodeGen/ppc64-complex-parms.c
index 4c7b9800043..92a6fa59b5f 100644
--- a/clang/test/CodeGen/ppc64-complex-parms.c
+++ b/clang/test/CodeGen/ppc64-complex-parms.c
@@ -9,55 +9,55 @@ float foo_float(_Complex float x) {
   return crealf(x);
 }
 
-// CHECK: define float @foo_float(float {{[%A-Za-z0-9.]+}}, float {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define float @foo_float(float {{[%A-Za-z0-9.]+}}, float {{[%A-Za-z0-9.]+}}) [[NUW:#[0-9]+]] {
 
 double foo_double(_Complex double x) {
   return creal(x);
 }
 
-// CHECK: define double @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define double @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 long double foo_long_double(_Complex long double x) {
   return creall(x);
 }
 
-// CHECK: define ppc_fp128 @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define ppc_fp128 @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 int foo_int(_Complex int x) {
   return __real__ x;
 }
 
-// CHECK: define signext i32 @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define signext i32 @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 short foo_short(_Complex short x) {
   return __real__ x;
 }
 
-// CHECK: define signext i16 @foo_short(i16 {{[%A-Za-z0-9.]+}}, i16 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define signext i16 @foo_short(i16 {{[%A-Za-z0-9.]+}}, i16 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 signed char foo_char(_Complex signed char x) {
   return __real__ x;
 }
 
-// CHECK: define signext i8 @foo_char(i8 {{[%A-Za-z0-9.]+}}, i8 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define signext i8 @foo_char(i8 {{[%A-Za-z0-9.]+}}, i8 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 long foo_long(_Complex long x) {
   return __real__ x;
 }
 
-// CHECK: define i64 @foo_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define i64 @foo_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 long long foo_long_long(_Complex long long x) {
   return __real__ x;
 }
 
-// CHECK: define i64 @foo_long_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define i64 @foo_long_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 void bar_float(void) {
   foo_float(2.0f - 2.5fi);
 }
 
-// CHECK: define void @bar_float() #0 {
+// CHECK: define void @bar_float() [[NUW]] {
 // CHECK: %[[VAR1:[A-Za-z0-9.]+]] = alloca { float, float }, align 4
 // CHECK: %[[VAR2:[A-Za-z0-9.]+]] = getelementptr inbounds { float, float }* %[[VAR1]], i32 0, i32 0
 // CHECK: %[[VAR3:[A-Za-z0-9.]+]] = getelementptr inbounds { float, float }* %[[VAR1]], i32 0, i32 1
@@ -73,7 +73,7 @@ void bar_double(void) {
   foo_double(2.0 - 2.5i);
 }
 
-// CHECK: define void @bar_double() #0 {
+// CHECK: define void @bar_double() [[NUW]] {
 // CHECK: %[[VAR11:[A-Za-z0-9.]+]] = alloca { double, double }, align 8
 // CHECK: %[[VAR12:[A-Za-z0-9.]+]] = getelementptr inbounds { double, double }* %[[VAR11]], i32 0, i32 0
 // CHECK: %[[VAR13:[A-Za-z0-9.]+]] = getelementptr inbounds { double, double }* %[[VAR11]], i32 0, i32 1
@@ -89,7 +89,7 @@ void bar_long_double(void) {
   foo_long_double(2.0L - 2.5Li);
 }
 
-// CHECK: define void @bar_long_double() #0 {
+// CHECK: define void @bar_long_double() [[NUW]] {
 // CHECK: %[[VAR21:[A-Za-z0-9.]+]] = alloca { ppc_fp128, ppc_fp128 }, align 16
 // CHECK: %[[VAR22:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
 // CHECK: %[[VAR23:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
@@ -105,7 +105,7 @@ void bar_int(void) {
   foo_int(2 - 3i);
 }
 
-// CHECK: define void @bar_int() #0 {
+// CHECK: define void @bar_int() [[NUW]] {
 // CHECK: %[[VAR31:[A-Za-z0-9.]+]] = alloca { i32, i32 }, align 4
 // CHECK: %[[VAR32:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }* %[[VAR31]], i32 0, i32 0
 // CHECK: %[[VAR33:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }* %[[VAR31]], i32 0, i32 1
@@ -121,7 +121,7 @@ void bar_short(void) {
   foo_short(2 - 3i);
 }
 
-// CHECK: define void @bar_short() #0 {
+// CHECK: define void @bar_short() [[NUW]] {
 // CHECK: %[[VAR41:[A-Za-z0-9.]+]] = alloca { i16, i16 }, align 2
 // CHECK: %[[VAR42:[A-Za-z0-9.]+]] = getelementptr inbounds { i16, i16 }* %[[VAR41]], i32 0, i32 0
 // CHECK: %[[VAR43:[A-Za-z0-9.]+]] = getelementptr inbounds { i16, i16 }* %[[VAR41]], i32 0, i32 1
@@ -137,7 +137,7 @@ void bar_char(void) {
   foo_char(2 - 3i);
 }
 
-// CHECK: define void @bar_char() #0 {
+// CHECK: define void @bar_char() [[NUW]] {
 // CHECK: %[[VAR51:[A-Za-z0-9.]+]] = alloca { i8, i8 }, align 1
 // CHECK: %[[VAR52:[A-Za-z0-9.]+]] = getelementptr inbounds { i8, i8 }* %[[VAR51]], i32 0, i32 0
 // CHECK: %[[VAR53:[A-Za-z0-9.]+]] = getelementptr inbounds { i8, i8 }* %[[VAR51]], i32 0, i32 1
@@ -153,7 +153,7 @@ void bar_long(void) {
   foo_long(2L - 3Li);
 }
 
-// CHECK: define void @bar_long() #0 {
+// CHECK: define void @bar_long() [[NUW]] {
 // CHECK: %[[VAR61:[A-Za-z0-9.]+]] = alloca { i64, i64 }, align 8
 // CHECK: %[[VAR62:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }* %[[VAR61]], i32 0, i32 0
 // CHECK: %[[VAR63:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }* %[[VAR61]], i32 0, i32 1
@@ -169,7 +169,7 @@ void bar_long_long(void) {
   foo_long_long(2LL - 3LLi);
 }
 
-// CHECK: define void @bar_long_long() #0 {
+// CHECK: define void @bar_long_long() [[NUW]] {
 // CHECK: %[[VAR71:[A-Za-z0-9.]+]] = alloca { i64, i64 }, align 8
 // CHECK: %[[VAR72:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }* %[[VAR71]], i32 0, i32 0
 // CHECK: %[[VAR73:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }* %[[VAR71]], i32 0, i32 1
@@ -181,4 +181,4 @@ void bar_long_long(void) {
 // CHECK: %[[VAR77:[A-Za-z0-9.]+]] = load i64* %[[VAR76]], align 1
 // CHECK: %{{[A-Za-z0-9.]+}} = call i64 @foo_long_long(i64 %[[VAR75]], i64 %[[VAR77]])
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/ppc64-complex-return.c b/clang/test/CodeGen/ppc64-complex-return.c
index d530d50d885..b3fd5497701 100644
--- a/clang/test/CodeGen/ppc64-complex-return.c
+++ b/clang/test/CodeGen/ppc64-complex-return.c
@@ -9,55 +9,55 @@ _Complex float foo_float(_Complex float x) {
   return x;
 }
 
-// CHECK: define { float, float } @foo_float(float {{[%A-Za-z0-9.]+}}, float {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { float, float } @foo_float(float {{[%A-Za-z0-9.]+}}, float {{[%A-Za-z0-9.]+}}) [[NUW:#[0-9]+]] {
 
 _Complex double foo_double(_Complex double x) {
   return x;
 }
 
-// CHECK: define { double, double } @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { double, double } @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex long double foo_long_double(_Complex long double x) {
   return x;
 }
 
-// CHECK: define { ppc_fp128, ppc_fp128 } @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { ppc_fp128, ppc_fp128 } @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex int foo_int(_Complex int x) {
   return x;
 }
 
-// CHECK: define { i32, i32 } @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { i32, i32 } @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex short foo_short(_Complex short x) {
   return x;
 }
 
-// CHECK: define { i16, i16 } @foo_short(i16 {{[%A-Za-z0-9.]+}}, i16 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { i16, i16 } @foo_short(i16 {{[%A-Za-z0-9.]+}}, i16 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex signed char foo_char(_Complex signed char x) {
   return x;
 }
 
-// CHECK: define { i8, i8 } @foo_char(i8 {{[%A-Za-z0-9.]+}}, i8 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { i8, i8 } @foo_char(i8 {{[%A-Za-z0-9.]+}}, i8 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex long foo_long(_Complex long x) {
   return x;
 }
 
-// CHECK: define { i64, i64 } @foo_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { i64, i64 } @foo_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex long long foo_long_long(_Complex long long x) {
   return x;
 }
 
-// CHECK: define { i64, i64 } @foo_long_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) #0 {
+// CHECK: define { i64, i64 } @foo_long_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 float bar_float(void) {
   return crealf(foo_float(2.0f - 2.5fi));
 }
 
-// CHECK: define float @bar_float() #0 {
+// CHECK: define float @bar_float() [[NUW]] {
 // CHECK: [[VAR1:[%A-Za-z0-9.]+]] = call { float, float } @foo_float
 // CHECK: extractvalue { float, float } [[VAR1]], 0
 // CHECK: extractvalue { float, float } [[VAR1]], 1
@@ -66,7 +66,7 @@ double bar_double(void) {
   return creal(foo_double(2.0 - 2.5i));
 }
 
-// CHECK: define double @bar_double() #0 {
+// CHECK: define double @bar_double() [[NUW]] {
 // CHECK: [[VAR2:[%A-Za-z0-9.]+]] = call { double, double } @foo_double
 // CHECK: extractvalue { double, double } [[VAR2]], 0
 // CHECK: extractvalue { double, double } [[VAR2]], 1
@@ -75,7 +75,7 @@ long double bar_long_double(void) {
   return creall(foo_long_double(2.0L - 2.5Li));
 }
 
-// CHECK: define ppc_fp128 @bar_long_double() #0 {
+// CHECK: define ppc_fp128 @bar_long_double() [[NUW]] {
 // CHECK: [[VAR3:[%A-Za-z0-9.]+]] = call { ppc_fp128, ppc_fp128 } @foo_long_double
 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 0
 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 1
@@ -84,7 +84,7 @@ int bar_int(void) {
   return __real__(foo_int(2 - 3i));
 }
 
-// CHECK: define signext i32 @bar_int() #0 {
+// CHECK: define signext i32 @bar_int() [[NUW]] {
 // CHECK: [[VAR4:[%A-Za-z0-9.]+]] = call { i32, i32 } @foo_int
 // CHECK: extractvalue { i32, i32 } [[VAR4]], 0
 // CHECK: extractvalue { i32, i32 } [[VAR4]], 1
@@ -93,7 +93,7 @@ short bar_short(void) {
   return __real__(foo_short(2 - 3i));
 }
 
-// CHECK: define signext i16 @bar_short() #0 {
+// CHECK: define signext i16 @bar_short() [[NUW]] {
 // CHECK: [[VAR5:[%A-Za-z0-9.]+]] = call { i16, i16 } @foo_short
 // CHECK: extractvalue { i16, i16 } [[VAR5]], 0
 // CHECK: extractvalue { i16, i16 } [[VAR5]], 1
@@ -102,7 +102,7 @@ signed char bar_char(void) {
   return __real__(foo_char(2 - 3i));
 }
 
-// CHECK: define signext i8 @bar_char() #0 {
+// CHECK: define signext i8 @bar_char() [[NUW]] {
 // CHECK: [[VAR6:[%A-Za-z0-9.]+]] = call { i8, i8 } @foo_char
 // CHECK: extractvalue { i8, i8 } [[VAR6]], 0
 // CHECK: extractvalue { i8, i8 } [[VAR6]], 1
@@ -111,7 +111,7 @@ long bar_long(void) {
   return __real__(foo_long(2L - 3Li));
 }
 
-// CHECK: define i64 @bar_long() #0 {
+// CHECK: define i64 @bar_long() [[NUW]] {
 // CHECK: [[VAR7:[%A-Za-z0-9.]+]] = call { i64, i64 } @foo_long
 // CHECK: extractvalue { i64, i64 } [[VAR7]], 0
 // CHECK: extractvalue { i64, i64 } [[VAR7]], 1
@@ -120,10 +120,10 @@ long long bar_long_long(void) {
   return __real__(foo_long_long(2LL - 3LLi));
 }
 
-// CHECK: define i64 @bar_long_long() #0 {
+// CHECK: define i64 @bar_long_long() [[NUW]] {
 // CHECK: [[VAR8:[%A-Za-z0-9.]+]] = call { i64, i64 } @foo_long_long
 // CHECK: extractvalue { i64, i64 } [[VAR8]], 0
 // CHECK: extractvalue { i64, i64 } [[VAR8]], 1
 
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/ppc64-extend.c b/clang/test/CodeGen/ppc64-extend.c
index 17a8aeec0bf..68d28c79b52 100644
--- a/clang/test/CodeGen/ppc64-extend.c
+++ b/clang/test/CodeGen/ppc64-extend.c
@@ -2,15 +2,15 @@
 // RUN: %clang_cc1 -O0 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
 void f1(int x) { return; }
-// CHECK: define void @f1(i32 signext %x) #0
+// CHECK: define void @f1(i32 signext %x) [[NUW:#[0-9]+]]
 
 void f2(unsigned int x) { return; }
-// CHECK: define void @f2(i32 zeroext %x) #0
+// CHECK: define void @f2(i32 zeroext %x) [[NUW]]
 
 int f3(void) { return 0; }
-// CHECK: define signext i32 @f3() #0
+// CHECK: define signext i32 @f3() [[NUW]]
 
 unsigned int f4(void) { return 0; }
-// CHECK: define zeroext i32 @f4() #0
+// CHECK: define zeroext i32 @f4() [[NUW]]
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
diff --git a/clang/test/CodeGen/pragma-weak.c b/clang/test/CodeGen/pragma-weak.c
index 4319bf2c624..d4b1b9f93f6 100644
--- a/clang/test/CodeGen/pragma-weak.c
+++ b/clang/test/CodeGen/pragma-weak.c
@@ -136,7 +136,7 @@ void __both3(void) {}
 void __a1(void) __attribute((noinline));
 #pragma weak a1 = __a1
 void __a1(void) {}
-// CHECK: define void @__a1() #1
+// CHECK: define void @__a1() [[NI:#[0-9]+]]
 
 // attributes introduced BEFORE a combination of #pragma weak and alias()
 // hold...
@@ -144,11 +144,11 @@ void __a3(void) __attribute((noinline));
 #pragma weak a3 = __a3
 void a3(void) __attribute((alias("__a3")));
 void __a3(void) {}
-// CHECK: define void @__a3() #1
+// CHECK: define void @__a3() [[NI]]
 
 #pragma weak xxx = __xxx
 __attribute((pure,noinline,const,fastcall)) void __xxx(void) { }
-// CHECK: void @__xxx() #2
+// CHECK: void @__xxx() [[RN:#[0-9]+]]
 
 ///////////// PR10878: Make sure we can call a weak alias
 void SHA512Pad(void *context) {}
@@ -180,7 +180,5 @@ void zzz(void){}
 
 int correct_linkage;
 
-// CHECK: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECK: attributes #1 = { noinline nounwind "target-features"={{.*}} }
-// CHECK: attributes #2 = { noinline nounwind readnone "target-features"={{.*}} }
-// CHECK: attributes #3 = { "target-features"={{.*}} }
+// CHECK: attributes [[NI]] = { noinline nounwind{{.*}} }
+// CHECK: attributes [[RN]] = { noinline nounwind readnone{{.*}} }
diff --git a/clang/test/CodeGen/struct-passing.c b/clang/test/CodeGen/struct-passing.c
index 487f0610e73..d28fee213eb 100644
--- a/clang/test/CodeGen/struct-passing.c
+++ b/clang/test/CodeGen/struct-passing.c
@@ -16,13 +16,12 @@ void __attribute__((pure)) f5(T1 a);
 
 void *ps[] = { f0, f1, f2, f3, f4, f5 };
 
-// CHECK: declare i32 @f0() #0
-// CHECK: declare i32 @f1() #1
+// CHECK: declare i32 @f0() [[RN:#[0-9]+]]
+// CHECK: declare i32 @f1() [[RO:#[0-9]+]]
 // CHECK: declare void @f2({{.*}} sret)
 // CHECK: declare void @f3({{.*}} sret)
 // CHECK: declare void @f4({{.*}} byval align 4)
 // CHECK: declare void @f5({{.*}} byval align 4)
 
-// CHECK: attributes #0 = { nounwind readnone "target-features"={{.*}} }
-// CHECK: attributes #1 = { nounwind readonly "target-features"={{.*}} }
-// CHECK: attributes #2 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[RN]] = { nounwind readnone{{.*}} }
+// CHECK: attributes [[RO]] = { nounwind readonly{{.*}} }
diff --git a/clang/test/CodeGen/unwind-attr.c b/clang/test/CodeGen/unwind-attr.c
index 3a11ce620b5..2ffb5a8eeb8 100644
--- a/clang/test/CodeGen/unwind-attr.c
+++ b/clang/test/CodeGen/unwind-attr.c
@@ -3,28 +3,27 @@
 
 int opaque();
 
-// CHECK:       define [[INT:i.*]] @test0() #0 {
-// CHECK-NOEXC: define [[INT:i.*]] @test0() #0 {
+// CHECK:       define [[INT:i.*]] @test0() [[NONE:#[0-9]+]] {
+// CHECK-NOEXC: define [[INT:i.*]] @test0() [[NUW:#[0-9]+]] {
 int test0(void) {
   return opaque();
 }
 
 // <rdar://problem/8087431>: locally infer nounwind at -O0
-// CHECK:       define [[INT:i.*]] @test1() #1 {
-// CHECK-NOEXC: define [[INT:i.*]] @test1() #0 {
+// CHECK:       define [[INT:i.*]] @test1() [[NUW:#[0-9]+]] {
+// CHECK-NOEXC: define [[INT:i.*]] @test1() [[NUW]] {
 int test1(void) {
   return 0;
 }
 
 // <rdar://problem/8283071>: not for weak functions
-// CHECK:       define weak [[INT:i.*]] @test2() #0 {
-// CHECK-NOEXC: define weak [[INT:i.*]] @test2() #0 {
+// CHECK:       define weak [[INT:i.*]] @test2() [[NONE]] {
+// CHECK-NOEXC: define weak [[INT:i.*]] @test2() [[NUW]] {
 __attribute__((weak)) int test2(void) {
   return 0;
 }
 
-// CHECK: attributes #0 = { "target-features"={{.*}} }
-// CHECK: attributes #1 = { nounwind "target-features"={{.*}} }
+// CHECK: attributes [[NONE]] = { {{.*}} }
+// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
 
-// CHECK-NOEXC: attributes #0 = { nounwind "target-features"={{.*}} }
-// CHECK-NOEXC: attributes #1 = { "target-features"={{.*}} }
+// CHECK-NOEXC: attributes [[NUW]] = { nounwind{{.*}} }