[clang][RISCV] Added target attributes to runtime functions

[eklepilkina]

Summary

RISCVTargetMachine::getSubtargetImpl creates subtargets based on target attributes of IR functions. As result now runtime functions are placed in another subtarget and have another ABI. That causes warning messages like Hard-float 'd' ABI can't be used for a target that doesn't support the D instruction set extension (ignoring target-abi) during linking with lld with -flto

[eklepilkina]

Gently ping

[eklepilkina]

Gently ping

[jrtc27]

How does this affect LTO? LTO for RISC-V is broken for various reasons, but LTO isn't Clang's responsibility beyond passing on driver arguments. Is this not just one of many symptoms of RISC-V not having the right module-level subtarget under LTO, which is a real problem that needs fixing?

[erichkeane]

The code changes/test changes seem innocuous enough, so from an 'attribute code owner perspective' I think this is alright. I think @rjmccall or @eli.friedman need to take a peak from CodeGen owner's perspective, and it seems useful if the commit message better described (at least in a way that the three of us could understand) the motivation/reasoning here.

[eklepilkina]

How does this affect LTO?

This problem appeared only under lto as far as it's processed as one module.

Is this not just one of many symptoms of RISC-V not having the right module-level subtarget under LTO, which is a real problem that needs fixing?

Not exactly, to build right subtarget we need attributes. As far as mentioned in comments in code the main approach to provide subtarget information is adding information in functions attributes. Why not to provide this information for runtime functions? If we don't have right attributes what shall we use to find out proper target features?

[eklepilkina]

How does this affect LTO?

More detailed answer. We work with bitcode files only when use lto. If we don't use lto clang produces .o file that are already contains target information. We don't work with function attributes to get subtarget without lto.

[eklepilkina]

I've created one more patch connected with lto https://reviews.llvm.org/D142191 and it also uses attributes of functions as the way to get right TargetMachine in linker.

[eklepilkina]

Gently ping

[eklepilkina]

Gently ping

clang/lib/CodeGen/CGCall.cpp

for (StringRef Attr : CodeGenOpts.DefaultFunctionAttrs) {
     FuncAttrs.addAttribute(Var, Value);
   }
 }
 
 void CodeGenModule::addDefaultFunctionDefinitionAttributes(llvm::Function &F) {
   llvm::AttrBuilder FuncAttrs(F.getContext());
   getDefaultFunctionAttributes(F.getName(), F.hasOptNone(),
                                /* AttrOnCallSite = */ false, FuncAttrs);
-  // TODO: call GetCPUAndFeaturesAttributes?
+  GetCPUAndFeaturesAttributes(GlobalDecl(), FuncAttrs);
   F.addFnAttrs(FuncAttrs);
 }
 
 void CodeGenModule::addDefaultFunctionDefinitionAttributes(
                                                    llvm::AttrBuilder &attrs) {
   getDefaultFunctionAttributes(/*function name*/ "", /*optnone*/ false,
                                /*for call*/ false, attrs);
   GetCPUAndFeaturesAttributes(GlobalDecl(), attrs);

clang/lib/CodeGen/CodeGenModule.cpp

if (Entry) {
     llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
         F, Entry->getValueType()->getPointerTo());
     addGlobalValReplacement(Entry, BC);
   }
 
   assert(F->getName() == MangledName && "name was uniqued!");
   if (D)
     SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
+  else
+    addDefaultFunctionDefinitionAttributes(*F);
   if (ExtraAttrs.hasFnAttrs()) {
     llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
     F->addFnAttrs(B);
   }
 
   if (!DontDefer) {
     // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
     // each other bottoming out with the base dtor.  Therefore we emit non-base

clang/test/CodeGen/PowerPC/ignore-exceptions.cpp

 // RUN: %clang_cc1 %s -triple powerpc64-linux -fexceptions -fcxx-exceptions -fignore-exceptions -emit-llvm -o - | FileCheck %s
 
 struct A {
   ~A(){}
 };
 
 void f(void) {
 // CHECK-NOT: personality ptr @__gcc_personality_v0
   A a;
   try {
     throw 1;
   } catch(...) {
   }
 // CHECK:  %a = alloca %struct.A, align 1
-// CHECK:  %exception = call ptr @__cxa_allocate_exception(i64 4) #1
+// CHECK:  %exception = call ptr @__cxa_allocate_exception(i64 4) #{{[0-9]+}}
 // CHECK:  store i32 1, ptr %exception, align 16
-// CHECK:  call void @__cxa_throw(ptr %exception, ptr @_ZTIi, ptr null) #2
+// CHECK:  call void @__cxa_throw(ptr %exception, ptr @_ZTIi, ptr null) #{{[0-9]+}}
 // CHECK:  unreachable
 
 // CHECK-NOT: invoke
 // CHECK-NOT: landingpad
 // CHECK-NOT: __cxa_begin_catch
 // CHECK-NOT: __cxa_end_catch
 }

clang/test/CodeGen/atomic_ops.c

 // NATIVE: cmpxchg ptr {{%.*}}, i32 {{%.*}}, i32 [[NEW:%.*]] seq_cst seq_cst, align 4
 // NATIVE: ret i32 [[NEW]]
 // LIBCALL-LABEL: @compound_mul
 // LIBCALL: i1 @__atomic_compare_exchange(i32 noundef 4,
 
   return (in *= 5);
 }
 
-// LIBCALL: [[LC_ATTRS]] = { nounwind willreturn }
+// LIBCALL: [[LC_ATTRS]] = { nounwind willreturn {{.*}} }

clang/test/CodeGen/attr-cpuspecific.c

 ATTR(cpu_dispatch(ivybridge))
 void SingleVersion(void);
 // LINUX: define weak_odr ptr @SingleVersion.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @SingleVersion.S
 // LINUX: call void @llvm.trap
 // LINUX: unreachable
 
-// WINDOWS: define weak_odr dso_local void @SingleVersion() comdat
+// WINDOWS: define weak_odr dso_local void @SingleVersion() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call void @SingleVersion.S()
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @llvm.trap
 // WINDOWS: unreachable
 
 ATTR(cpu_specific(ivybridge))
 void NotCalled(void){}
 // LINUX: define{{.*}} void @NotCalled.S() #[[S]]
 // WINDOWS: define dso_local void @NotCalled.S() #[[S:[0-9]+]]
 
 // Done before any of the implementations.  Also has an undecorated forward
 // declaration.
 void TwoVersions(void);
 
 ATTR(cpu_dispatch(ivybridge, knl))
 void TwoVersions(void);
 // LINUX: define weak_odr ptr @TwoVersions.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @TwoVersions.Z
 // LINUX: ret ptr @TwoVersions.S
 // LINUX: call void @llvm.trap
 // LINUX: unreachable
 
-// WINDOWS: define weak_odr dso_local void @TwoVersions() comdat
+// WINDOWS: define weak_odr dso_local void @TwoVersions() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call void @TwoVersions.Z()
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @TwoVersions.S()
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @llvm.trap
 // WINDOWS: unreachable
 

 ATTR(cpu_dispatch(knl))
 void OrderDispatchUsageSpecific(void);
 // LINUX: define weak_odr ptr @OrderDispatchUsageSpecific.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @OrderDispatchUsageSpecific.Z
 // LINUX: call void @llvm.trap
 // LINUX: unreachable
 
-// WINDOWS: define weak_odr dso_local void @OrderDispatchUsageSpecific() comdat
+// WINDOWS: define weak_odr dso_local void @OrderDispatchUsageSpecific() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call void @OrderDispatchUsageSpecific.Z()
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @llvm.trap
 // WINDOWS: unreachable
 
 // CHECK: define {{.*}}void @OrderDispatchUsageSpecific.Z()
 

 void TwoVersionsSameAttr(void);
 // LINUX: define weak_odr ptr @TwoVersionsSameAttr.resolver()
 // LINUX: ret ptr @TwoVersionsSameAttr.Z
 // LINUX: ret ptr @TwoVersionsSameAttr.S
 // LINUX: ret ptr @TwoVersionsSameAttr.O
 // LINUX: call void @llvm.trap
 // LINUX: unreachable
 
-// WINDOWS: define weak_odr dso_local void @TwoVersionsSameAttr() comdat
+// WINDOWS: define weak_odr dso_local void @TwoVersionsSameAttr() #{{[0-9]+}} comdat
 // WINDOWS: call void @TwoVersionsSameAttr.Z
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @TwoVersionsSameAttr.S
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @TwoVersionsSameAttr.O
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @llvm.trap
 // WINDOWS: unreachable
 
 ATTR(cpu_dispatch(atom, ivybridge, knl))
 void ThreeVersionsSameAttr(void){}
 // LINUX: define weak_odr ptr @ThreeVersionsSameAttr.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @ThreeVersionsSameAttr.Z
 // LINUX: ret ptr @ThreeVersionsSameAttr.S
 // LINUX: ret ptr @ThreeVersionsSameAttr.O
 // LINUX: call void @llvm.trap
 // LINUX: unreachable
 
-// WINDOWS: define weak_odr dso_local void @ThreeVersionsSameAttr() comdat
+// WINDOWS: define weak_odr dso_local void @ThreeVersionsSameAttr() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: call void @ThreeVersionsSameAttr.Z
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @ThreeVersionsSameAttr.S
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @ThreeVersionsSameAttr.O
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @llvm.trap
 // WINDOWS: unreachable
 
 ATTR(cpu_dispatch(knl))
 void OrderSpecificUsageDispatch(void);
 // LINUX: define weak_odr ptr @OrderSpecificUsageDispatch.resolver()
 // LINUX: ret ptr @OrderSpecificUsageDispatch.Z
 
-// WINDOWS: define weak_odr dso_local void @OrderSpecificUsageDispatch() comdat
+// WINDOWS: define weak_odr dso_local void @OrderSpecificUsageDispatch() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: call void @OrderSpecificUsageDispatch.Z
 // WINDOWS-NEXT: ret void
 
 // No Cpu Specific options.
 ATTR(cpu_dispatch(atom, ivybridge, knl))
 void NoSpecifics(void);
 // LINUX: define weak_odr ptr @NoSpecifics.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @NoSpecifics.Z
 // LINUX: ret ptr @NoSpecifics.S
 // LINUX: ret ptr @NoSpecifics.O
 // LINUX: call void @llvm.trap
 // LINUX: unreachable
 
-// WINDOWS: define weak_odr dso_local void @NoSpecifics() comdat
+// WINDOWS: define weak_odr dso_local void @NoSpecifics() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: call void @NoSpecifics.Z
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @NoSpecifics.S
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @NoSpecifics.O
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @llvm.trap
 // WINDOWS: unreachable
 
 ATTR(cpu_dispatch(atom, generic, ivybridge, knl))
 void HasGeneric(void);
 // LINUX: define weak_odr ptr @HasGeneric.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @HasGeneric.Z
 // LINUX: ret ptr @HasGeneric.S
 // LINUX: ret ptr @HasGeneric.O
 // LINUX: ret ptr @HasGeneric.A
 // LINUX-NOT: call void @llvm.trap
 
-// WINDOWS: define weak_odr dso_local void @HasGeneric() comdat
+// WINDOWS: define weak_odr dso_local void @HasGeneric() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: call void @HasGeneric.Z
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @HasGeneric.S
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @HasGeneric.O
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @HasGeneric.A
 // WINDOWS-NEXT: ret void
 // WINDOWS-NOT: call void @llvm.trap
 
 ATTR(cpu_dispatch(atom, generic, ivybridge, knl))
 void HasParams(int i, double d);
 // LINUX: define weak_odr ptr @HasParams.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @HasParams.Z
 // LINUX: ret ptr @HasParams.S
 // LINUX: ret ptr @HasParams.O
 // LINUX: ret ptr @HasParams.A
 // LINUX-NOT: call void @llvm.trap
 
-// WINDOWS: define weak_odr dso_local void @HasParams(i32 %0, double %1) comdat
+// WINDOWS: define weak_odr dso_local void @HasParams(i32 %0, double %1) #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: call void @HasParams.Z(i32 %0, double %1)
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @HasParams.S(i32 %0, double %1)
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @HasParams.O(i32 %0, double %1)
 // WINDOWS-NEXT: ret void
 // WINDOWS: call void @HasParams.A(i32 %0, double %1)
 // WINDOWS-NEXT: ret void
 // WINDOWS-NOT: call void @llvm.trap
 
 ATTR(cpu_dispatch(atom, generic, ivybridge, knl))
 int HasParamsAndReturn(int i, double d);
 // LINUX: define weak_odr ptr @HasParamsAndReturn.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @HasParamsAndReturn.Z
 // LINUX: ret ptr @HasParamsAndReturn.S
 // LINUX: ret ptr @HasParamsAndReturn.O
 // LINUX: ret ptr @HasParamsAndReturn.A
 // LINUX-NOT: call void @llvm.trap
 
-// WINDOWS: define weak_odr dso_local i32 @HasParamsAndReturn(i32 %0, double %1) comdat
+// WINDOWS: define weak_odr dso_local i32 @HasParamsAndReturn(i32 %0, double %1) #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.Z(i32 %0, double %1)
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.S(i32 %0, double %1)
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.O(i32 %0, double %1)
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.A(i32 %0, double %1)
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS-NOT: call void @llvm.trap
 
 ATTR(cpu_dispatch(atom, generic, pentium))
 int GenericAndPentium(int i, double d);
 // LINUX: define weak_odr ptr @GenericAndPentium.resolver()
 // LINUX: call void @__cpu_indicator_init
 // LINUX: ret ptr @GenericAndPentium.O
 // LINUX: ret ptr @GenericAndPentium.B
 // LINUX-NOT: ret ptr @GenericAndPentium.A
 // LINUX-NOT: call void @llvm.trap
 
-// WINDOWS: define weak_odr dso_local i32 @GenericAndPentium(i32 %0, double %1) comdat
+// WINDOWS: define weak_odr dso_local i32 @GenericAndPentium(i32 %0, double %1) #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init
 // WINDOWS: %[[RET:.+]] = musttail call i32 @GenericAndPentium.O(i32 %0, double %1)
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS: %[[RET:.+]] = musttail call i32 @GenericAndPentium.B(i32 %0, double %1)
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS-NOT: call i32 @GenericAndPentium.A
 // WINDOWS-NOT: call void @llvm.trap
 
 ATTR(cpu_dispatch(atom, pentium))
 int DispatchFirst(void);
 // LINUX: define weak_odr ptr @DispatchFirst.resolver
 // LINUX: ret ptr @DispatchFirst.O
 // LINUX: ret ptr @DispatchFirst.B
 
-// WINDOWS: define weak_odr dso_local i32 @DispatchFirst() comdat
+// WINDOWS: define weak_odr dso_local i32 @DispatchFirst() #{{[0-9]+}} comdat
 // WINDOWS: %[[RET:.+]] = musttail call i32 @DispatchFirst.O()
 // WINDOWS-NEXT: ret i32 %[[RET]]
 // WINDOWS: %[[RET:.+]] = musttail call i32 @DispatchFirst.B()
 // WINDOWS-NEXT: ret i32 %[[RET]]
 
 ATTR(cpu_specific(atom))
 int DispatchFirst(void) {return 0;}
 // LINUX: define{{.*}} i32 @DispatchFirst.O

clang/test/CodeGen/attr-target-clones.c

 // LINUX: @unused.ifunc = weak_odr ifunc void (), ptr @unused.resolver
 // LINUX: @foo_inline.ifunc = weak_odr ifunc i32 (), ptr @foo_inline.resolver
 // LINUX: @foo_inline2.ifunc = weak_odr ifunc i32 (), ptr @foo_inline2.resolver
 // LINUX: @foo_used_no_defn.ifunc = weak_odr ifunc i32 (), ptr @foo_used_no_defn.resolver
 
 int __attribute__((target_clones("sse4.2, default"))) foo(void) { return 0; }
 // LINUX: define {{.*}}i32 @foo.sse4.2.0()
 // LINUX: define {{.*}}i32 @foo.default.1()
-// LINUX: define weak_odr ptr @foo.resolver() comdat
+// LINUX: define weak_odr ptr @foo.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @foo.sse4.2.0
 // LINUX: ret ptr @foo.default.1
 
 // WINDOWS: define dso_local i32 @foo.sse4.2.0()
 // WINDOWS: define dso_local i32 @foo.default.1()
-// WINDOWS: define weak_odr dso_local i32 @foo() comdat
+// WINDOWS: define weak_odr dso_local i32 @foo() #{{[0-9]+}} comdat
 // WINDOWS: musttail call i32 @foo.sse4.2.0
 // WINDOWS: musttail call i32 @foo.default.1
 
 __attribute__((target_clones("default,default ,sse4.2"))) void foo_dupes(void) {}
 // LINUX: define {{.*}}void @foo_dupes.default.1()
 // LINUX: define {{.*}}void @foo_dupes.sse4.2.0()
-// LINUX: define weak_odr ptr @foo_dupes.resolver() comdat
+// LINUX: define weak_odr ptr @foo_dupes.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @foo_dupes.sse4.2.0
 // LINUX: ret ptr @foo_dupes.default.1
 
 // WINDOWS: define dso_local void @foo_dupes.default.1()
 // WINDOWS: define dso_local void @foo_dupes.sse4.2.0()
-// WINDOWS: define weak_odr dso_local void @foo_dupes() comdat
+// WINDOWS: define weak_odr dso_local void @foo_dupes() #{{[0-9]+}} comdat
 // WINDOWS: musttail call void @foo_dupes.sse4.2.0
 // WINDOWS: musttail call void @foo_dupes.default.1
 
 void bar2(void) {
   // LINUX: define {{.*}}void @bar2()
   // WINDOWS: define dso_local void @bar2()
   foo_dupes();
   // LINUX: call void @foo_dupes.ifunc()
   // WINDOWS: call void @foo_dupes()
 }
 
 int bar(void) {
   // LINUX: define {{.*}}i32 @bar() #[[DEF:[0-9]+]]
   // WINDOWS: define dso_local i32 @bar() #[[DEF:[0-9]+]]
   return foo();
   // LINUX: call i32 @foo.ifunc()
   // WINDOWS: call i32 @foo()
 }
 
 void __attribute__((target_clones("default, arch=ivybridge"))) unused(void) {}
 // LINUX: define {{.*}}void @unused.default.1()
 // LINUX: define {{.*}}void @unused.arch_ivybridge.0()
-// LINUX: define weak_odr ptr @unused.resolver() comdat
+// LINUX: define weak_odr ptr @unused.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @unused.arch_ivybridge.0
 // LINUX: ret ptr @unused.default.1
 
 // WINDOWS: define dso_local void @unused.default.1()
 // WINDOWS: define dso_local void @unused.arch_ivybridge.0()
-// WINDOWS: define weak_odr dso_local void @unused() comdat
+// WINDOWS: define weak_odr dso_local void @unused() #{{[0-9]+}} comdat
 // WINDOWS: musttail call void @unused.arch_ivybridge.0
 // WINDOWS: musttail call void @unused.default.1
 
 
 inline int __attribute__((target_clones("arch=sandybridge,default,sse4.2")))
 foo_inline(void) { return 0; }
 inline int __attribute__((target_clones("arch=sandybridge,default,sse4.2")))
 foo_inline2(void);
 
 int bar3(void) {
   // LINUX: define {{.*}}i32 @bar3()
   // WINDOWS: define dso_local i32 @bar3()
   return foo_inline() + foo_inline2();
   // LINUX: call i32 @foo_inline.ifunc()
   // LINUX: call i32 @foo_inline2.ifunc()
   // WINDOWS: call i32 @foo_inline()
   // WINDOWS: call i32 @foo_inline2()
 }
 
-// LINUX: define weak_odr ptr @foo_inline.resolver() comdat
+// LINUX: define weak_odr ptr @foo_inline.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @foo_inline.arch_sandybridge.0
 // LINUX: ret ptr @foo_inline.sse4.2.1
 // LINUX: ret ptr @foo_inline.default.2
 
-// WINDOWS: define weak_odr dso_local i32 @foo_inline() comdat
+// WINDOWS: define weak_odr dso_local i32 @foo_inline() #{{[0-9]+}} comdat
 // WINDOWS: musttail call i32 @foo_inline.arch_sandybridge.0
 // WINDOWS: musttail call i32 @foo_inline.sse4.2.1
 // WINDOWS: musttail call i32 @foo_inline.default.2
 
 inline int __attribute__((target_clones("arch=sandybridge,default,sse4.2")))
 foo_inline2(void){ return 0; }
-// LINUX: define weak_odr ptr @foo_inline2.resolver() comdat
+// LINUX: define weak_odr ptr @foo_inline2.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @foo_inline2.arch_sandybridge.0
 // LINUX: ret ptr @foo_inline2.sse4.2.1
 // LINUX: ret ptr @foo_inline2.default.2
 
-// WINDOWS: define weak_odr dso_local i32 @foo_inline2() comdat
+// WINDOWS: define weak_odr dso_local i32 @foo_inline2() #{{[0-9]+}} comdat
 // WINDOWS: musttail call i32 @foo_inline2.arch_sandybridge.0
 // WINDOWS: musttail call i32 @foo_inline2.sse4.2.1
 // WINDOWS: musttail call i32 @foo_inline2.default.2
 
 
 int __attribute__((target_clones("default", "sse4.2")))
 foo_unused_no_defn(void);
 
 int __attribute__((target_clones("default", "sse4.2")))
 foo_used_no_defn(void);
 
 int test_foo_used_no_defn(void) {
   // LINUX: define {{.*}}i32 @test_foo_used_no_defn()
   // WINDOWS: define dso_local i32 @test_foo_used_no_defn()
   return foo_used_no_defn();
   // LINUX: call i32 @foo_used_no_defn.ifunc()
   // WINDOWS: call i32 @foo_used_no_defn()
 }
 
 
-// LINUX: define weak_odr ptr @foo_used_no_defn.resolver() comdat
+// LINUX: define weak_odr ptr @foo_used_no_defn.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @foo_used_no_defn.sse4.2.0
 // LINUX: ret ptr @foo_used_no_defn.default.1
 
-// WINDOWS: define weak_odr dso_local i32 @foo_used_no_defn() comdat
+// WINDOWS: define weak_odr dso_local i32 @foo_used_no_defn() #{{[0-9]+}} comdat
 // WINDOWS: musttail call i32 @foo_used_no_defn.sse4.2.0
 // WINDOWS: musttail call i32 @foo_used_no_defn.default.1
 
 
 // Deferred emission of inline definitions.
 
 // LINUX: define linkonce i32 @foo_inline.arch_sandybridge.0() #[[SB:[0-9]+]]
 // LINUX: define linkonce i32 @foo_inline.default.2() #[[DEF:[0-9]+]]

clang/test/CodeGen/attr-target-mv-va-args.c

 // LINUX: define{{.*}} i32 @foo.arch_ivybridge(i32 noundef %i, ...)
 // LINUX: ret i32 1
 // LINUX: define{{.*}} i32 @foo(i32 noundef %i, ...)
 // LINUX: ret i32 2
 // LINUX: define{{.*}} i32 @bar()
 // LINUX: call i32 (i32, ...) @foo.ifunc(i32 noundef 1, i32 noundef 97, double
 // LINUX: call i32 (i32, ...) @foo.ifunc(i32 noundef 2, double noundef 2.2{{[0-9Ee+]+}}, i8* noundef getelementptr inbounds
 
-// LINUX: define weak_odr i32 (i32, ...)* @foo.resolver() comdat
+// LINUX: define weak_odr i32 (i32, ...)* @foo.resolver() #{{[0-9]+}} comdat
 // LINUX: ret i32 (i32, ...)* @foo.arch_sandybridge
 // LINUX: ret i32 (i32, ...)* @foo.arch_ivybridge
 // LINUX: ret i32 (i32, ...)* @foo.sse4.2
 // LINUX: ret i32 (i32, ...)* @foo
 // LINUX: declare i32 @foo.arch_sandybridge(i32 noundef, ...)
 
 // NO-IFUNC: define dso_local i32 @foo.sse4.2(i32 noundef %i, ...)
 // NO-IFUNC: ret i32 0
 // NO-IFUNC: define dso_local i32 @foo.arch_ivybridge(i32 noundef %i, ...)
 // NO-IFUNC: ret i32 1
 // NO-IFUNC: define dso_local i32 @foo(i32 noundef %i, ...)
 // NO-IFUNC: ret i32 2
 // NO-IFUNC: define dso_local i32 @bar()
 // NO-IFUNC: call i32 (i32, ...) @foo.resolver(i32 noundef 1, i32 noundef 97, double
 // NO-IFUNC: call i32 (i32, ...) @foo.resolver(i32 noundef 2, double noundef 2.2{{[0-9Ee+]+}}, i8* noundef getelementptr inbounds
 
-// WINDOWS: define weak_odr dso_local i32 @foo.resolver(i32 %0, ...) comdat
-// FUCHSIA: define weak_odr i32 @foo.resolver(i32 %0, ...) comdat
+// WINDOWS: define weak_odr dso_local i32 @foo.resolver(i32 %0, ...) #{{[0-9]+}} comdat
+// FUCHSIA: define weak_odr i32 @foo.resolver(i32 %0, ...) #{{[0-9]+}} comdat
 // NO-IFUNC: musttail call i32 (i32, ...) @foo.arch_sandybridge
 // NO-IFUNC: musttail call i32 (i32, ...) @foo.arch_ivybridge
 // NO-IFUNC: musttail call i32 (i32, ...) @foo.sse4.2
 // NO-IFUNC: musttail call i32 (i32, ...) @foo
 // WINDOWS: declare dso_local i32 @foo.arch_sandybridge(i32 noundef, ...)
 // FUCHSIA: declare i32 @foo.arch_sandybridge(i32 noundef, ...)

clang/test/CodeGen/attr-target-mv.c

 // WINDOWS: ret i32 17
 // WINDOWS: define{{.*}} i32 @foo.arch_graniterapids()
 // WINDOWS: ret i32 18
 // WINDOWS: define dso_local i32 @foo()
 // WINDOWS: ret i32 2
 // WINDOWS: define dso_local i32 @bar()
 // WINDOWS: call i32 @foo.resolver()
 
-// LINUX: define weak_odr ptr @foo.resolver() comdat
+// LINUX: define weak_odr ptr @foo.resolver() #{{[0-9]+}} comdat
 // LINUX: call void @__cpu_indicator_init()
 // LINUX: ret ptr @foo.arch_sandybridge
 // LINUX: ret ptr @foo.arch_ivybridge
 // LINUX: ret ptr @foo.sse4.2
 // LINUX: ret ptr @foo
 
-// WINDOWS: define weak_odr dso_local i32 @foo.resolver() comdat
+// WINDOWS: define weak_odr dso_local i32 @foo.resolver() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call i32 @foo.arch_sandybridge
 // WINDOWS: call i32 @foo.arch_ivybridge
 // WINDOWS: call i32 @foo.sse4.2
 // WINDOWS: call i32 @foo
 
 // LINUX: define{{.*}} i32 @bar2()
 // LINUX: call i32 @foo_inline.ifunc()
 
 // WINDOWS: define dso_local i32 @bar2()
 // WINDOWS: call i32 @foo_inline.resolver()
 
-// LINUX: define weak_odr ptr @foo_inline.resolver() comdat
+// LINUX: define weak_odr ptr @foo_inline.resolver() #{{[0-9]+}} comdat
 // LINUX: call void @__cpu_indicator_init()
 // LINUX: ret ptr @foo_inline.arch_sandybridge
 // LINUX: ret ptr @foo_inline.arch_ivybridge
 // LINUX: ret ptr @foo_inline.sse4.2
 // LINUX: ret ptr @foo_inline
 
-// WINDOWS: define weak_odr dso_local i32 @foo_inline.resolver() comdat
+// WINDOWS: define weak_odr dso_local i32 @foo_inline.resolver() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call i32 @foo_inline.arch_sandybridge
 // WINDOWS: call i32 @foo_inline.arch_ivybridge
 // WINDOWS: call i32 @foo_inline.sse4.2
 // WINDOWS: call i32 @foo_inline
 
 // LINUX: define{{.*}} void @bar3()
 // LINUX: call void @foo_decls.ifunc()
 
 // WINDOWS: define dso_local void @bar3()
 // WINDOWS: call void @foo_decls.resolver()
 
-// LINUX: define weak_odr ptr @foo_decls.resolver() comdat
+// LINUX: define weak_odr ptr @foo_decls.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @foo_decls.sse4.2
 // LINUX: ret ptr @foo_decls
 
-// WINDOWS: define weak_odr dso_local void @foo_decls.resolver() comdat
+// WINDOWS: define weak_odr dso_local void @foo_decls.resolver() #{{[0-9]+}} comdat
 // WINDOWS: call void @foo_decls.sse4.2
 // WINDOWS: call void @foo_decls
 
 // LINUX: define{{.*}} void @bar4()
 // LINUX: call void @foo_multi.ifunc(i32 noundef 1, double noundef 5.{{[0+e]*}})
 
 // WINDOWS: define dso_local void @bar4()
 // WINDOWS: call void @foo_multi.resolver(i32 noundef 1, double noundef 5.{{[0+e]*}})
 
-// LINUX: define weak_odr ptr @foo_multi.resolver() comdat
+// LINUX: define weak_odr ptr @foo_multi.resolver() #{{[0-9]+}} comdat
 // LINUX: and i32 %{{.*}}, 4352
 // LINUX: icmp eq i32 %{{.*}}, 4352
 // LINUX: ret ptr @foo_multi.fma4_sse4.2
 // LINUX: icmp eq i32 %{{.*}}, 12
 // LINUX: and i32 %{{.*}}, 4352
 // LINUX: icmp eq i32 %{{.*}}, 4352
 // LINUX: ret ptr @foo_multi.arch_ivybridge_fma4_sse4.2
 // LINUX: and i32 %{{.*}}, 768
 // LINUX: icmp eq i32 %{{.*}}, 768
 // LINUX: ret ptr @foo_multi.avx_sse4.2
 // LINUX: ret ptr @foo_multi
 
-// WINDOWS: define weak_odr dso_local void @foo_multi.resolver(i32 %0, double %1) comdat
+// WINDOWS: define weak_odr dso_local void @foo_multi.resolver(i32 %0, double %1) #{{[0-9]+}} comdat
 // WINDOWS: and i32 %{{.*}}, 4352
 // WINDOWS: icmp eq i32 %{{.*}}, 4352
 // WINDOWS: call void @foo_multi.fma4_sse4.2(i32 %0, double %1)
 // WINDOWS-NEXT: ret void
 // WINDOWS: icmp eq i32 %{{.*}}, 12
 // WINDOWS: and i32 %{{.*}}, 4352
 // WINDOWS: icmp eq i32 %{{.*}}, 4352
 // WINDOWS: call void @foo_multi.arch_ivybridge_fma4_sse4.2(i32 %0, double %1)

 // LINUX: define{{.*}} void @bar5()
 // LINUX: call i32 @fwd_decl_default.ifunc()
 // LINUX: call i32 @fwd_decl_avx.ifunc()
 
 // WINDOWS: define dso_local void @bar5()
 // WINDOWS: call i32 @fwd_decl_default.resolver()
 // WINDOWS: call i32 @fwd_decl_avx.resolver()
 
-// LINUX: define weak_odr ptr @fwd_decl_default.resolver() comdat
+// LINUX: define weak_odr ptr @fwd_decl_default.resolver() #{{[0-9]+}} comdat
 // LINUX: call void @__cpu_indicator_init()
 // LINUX: ret ptr @fwd_decl_default
-// LINUX: define weak_odr ptr @fwd_decl_avx.resolver() comdat
+// LINUX: define weak_odr ptr @fwd_decl_avx.resolver() #{{[0-9]+}} comdat
 // LINUX: call void @__cpu_indicator_init()
 // LINUX: ret ptr @fwd_decl_avx.avx
 // LINUX: ret ptr @fwd_decl_avx
 
-// WINDOWS: define weak_odr dso_local i32 @fwd_decl_default.resolver() comdat
+// WINDOWS: define weak_odr dso_local i32 @fwd_decl_default.resolver() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call i32 @fwd_decl_default
-// WINDOWS: define weak_odr dso_local i32 @fwd_decl_avx.resolver() comdat
+// WINDOWS: define weak_odr dso_local i32 @fwd_decl_avx.resolver() #{{[0-9]+}} comdat
 // WINDOWS: call void @__cpu_indicator_init()
 // WINDOWS: call i32 @fwd_decl_avx.avx
 // WINDOWS: call i32 @fwd_decl_avx
 
 // LINUX: define{{.*}} i32 @changed_to_mv.avx()
 // LINUX: define{{.*}} i32 @changed_to_mv.fma4()
 
 // WINDOWS: define dso_local i32 @changed_to_mv.avx()

 // WINDOWS: call void @must_be_emitted
 // WINDOWS: define internal void @must_be_emitted()
 
 // LINUX: define linkonce void @pr50025c()
 // LINUX: call void @pr50025b.ifunc()
 // WINDOWS: define linkonce_odr dso_local void @pr50025c() #{{[0-9]*}} comdat
 // WINDOWS: call void @pr50025b.resolver()
 
-// LINUX: define weak_odr ptr @pr50025b.resolver() comdat
+// LINUX: define weak_odr ptr @pr50025b.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @pr50025b
 // LINUX: define linkonce void @pr50025b()
 // LINUX: call void @must_be_emitted()
-// WINDOWS: define weak_odr dso_local void @pr50025b.resolver() comdat
+// WINDOWS: define weak_odr dso_local void @pr50025b.resolver() #{{[0-9]+}} comdat
 // WINDOWS: musttail call void @pr50025b()
 // WINDOWS: define linkonce_odr dso_local void @pr50025b() #{{[0-9]*}} comdat
 // WINDOWS: call void @must_be_emitted()

clang/test/CodeGenCXX/RISCV/riscv-target-features-attr.cpp

int main () {
   int y = 0;
   double z = division(x, y);
   if (z > 0)
     return 0;
   else
     return 1;
 }
 
-// CHECK: declare ptr @__cxa_allocate_exception(i64) local_unnamed_addr
-// CHECK: declare void @__cxa_throw(ptr, ptr, ptr) local_unnamed_addr
-// CHECK: define dso_local noundef signext i32 @main() local_unnamed_addr #1 {
+// CHECK: declare ptr @__cxa_allocate_exception(i64) local_unnamed_addr #[[A:[0-9]+]]
+// CHECK: declare void @__cxa_throw(ptr, ptr, ptr) local_unnamed_addr #[[A:[0-9]+]]
+// CHECK: define dso_local noundef signext i32 @main() local_unnamed_addr #[[B:[0-9]+]] {
+// CHECK: attributes #[[A]] = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+64bit" }
+// CHECK: attributes #[[B]] = { mustprogress norecurse noreturn "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+64bit" }
 No newline at end of file

clang/test/CodeGenCXX/attr-cpuspecific.cpp

 // LINUX: @_ZN1S4FuncEv = weak_odr alias void (ptr), ptr @_ZN1S4FuncEv.ifunc
 // LINUX: @_ZN1S4FuncEv.ifunc = weak_odr ifunc void (ptr), ptr @_ZN1S4FuncEv.resolver
 // LINUX: define weak_odr ptr @_ZN1S4FuncEv.resolver
 // LINUX: ret ptr @_ZN1S4FuncEv.S
 // LINUX: ret ptr @_ZN1S4FuncEv.O
 // LINUX: declare void @_ZN1S4FuncEv.S
 // LINUX: define linkonce_odr void @_ZN1S4FuncEv.O
 
-// WINDOWS: define weak_odr dso_local void @"?Func@S@@QEAAXXZ"(ptr %0) comdat
+// WINDOWS: define weak_odr dso_local void @"?Func@S@@QEAAXXZ"(ptr %0) #{{[0-9]+}} comdat
 // WINDOWS: musttail call void @"?Func@S@@QEAAXXZ.S"(ptr %0)
 // WINDOWS: musttail call void @"?Func@S@@QEAAXXZ.O"(ptr %0)
 // WINDOWS: declare dso_local void @"?Func@S@@QEAAXXZ.S"
 // WINDOWS: define linkonce_odr dso_local void @"?Func@S@@QEAAXXZ.O"

clang/test/CodeGenCXX/attr-target-clones.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -std=c++11 -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix=LINUX
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++11 -triple x86_64-windows-pc -emit-llvm %s -o - | FileCheck %s --check-prefix=WINDOWS
 
 // Overloaded ifuncs
 // LINUX: @_Z10overloadedi.ifunc = weak_odr ifunc i32 (i32), i32 (i32)* ()* @_Z10overloadedi.resolver
 // LINUX: @_Z10overloadedPKc.ifunc = weak_odr ifunc i32 (i8*), i32 (i8*)* ()* @_Z10overloadedPKc.resolver
 // struct 'C' ifuncs, note the 'float, U' one doesn't get one.
 // LINUX: @_ZN1CIssE3fooEv.ifunc = weak_odr ifunc i32 (%struct.C*), i32 (%struct.C*)* ()* @_ZN1CIssE3fooEv.resolver
 // LINUX: @_ZN1CIisE3fooEv.ifunc = weak_odr ifunc i32 (%struct.C.0*), i32 (%struct.C.0*)* ()* @_ZN1CIisE3fooEv.resolver
 // LINUX: @_ZN1CIdfE3fooEv.ifunc = weak_odr ifunc i32 (%struct.C.2*), i32 (%struct.C.2*)* ()* @_ZN1CIdfE3fooEv.resolver
 
 int __attribute__((target_clones("sse4.2", "default"))) overloaded(int) { return 1; }
 // LINUX: define {{.*}}i32 @_Z10overloadedi.sse4.2.0(i32{{.+}})
 // LINUX: define {{.*}}i32 @_Z10overloadedi.default.1(i32{{.+}})
-// LINUX: define weak_odr i32 (i32)* @_Z10overloadedi.resolver() comdat
+// LINUX: define weak_odr i32 (i32)* @_Z10overloadedi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret i32 (i32)* @_Z10overloadedi.sse4.2.0
 // LINUX: ret i32 (i32)* @_Z10overloadedi.default.1
 
 // WINDOWS: define dso_local noundef i32 @"?overloaded@@[e-mail]4.2.0"(i32{{.+}})
 // WINDOWS: define dso_local noundef i32 @"?overloaded@@[e-mail].1"(i32{{.+}})
-// WINDOWS: define weak_odr dso_local i32 @"?overloaded@@YAHH@Z"(i32{{.+}}) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?overloaded@@YAHH@Z"(i32{{.+}}) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?overloaded@@[e-mail]4.2.0"
 // WINDOWS: call i32 @"?overloaded@@[e-mail].1"
 
 int __attribute__((target_clones("arch=ivybridge", "default"))) overloaded(const char *) { return 2; }
 // LINUX: define {{.*}}i32 @_Z10overloadedPKc.arch_ivybridge.0(i8*{{.+}})
 // LINUX: define {{.*}}i32 @_Z10overloadedPKc.default.1(i8*{{.+}})
-// LINUX: define weak_odr i32 (i8*)* @_Z10overloadedPKc.resolver() comdat
+// LINUX: define weak_odr i32 (i8*)* @_Z10overloadedPKc.resolver() #{{[0-9]+}} comdat
 // LINUX: ret i32 (i8*)* @_Z10overloadedPKc.arch_ivybridge.0
 // LINUX: ret i32 (i8*)* @_Z10overloadedPKc.default.1
 
 // WINDOWS: define dso_local noundef i32 @"?overloaded@@[e-mail]_ivybridge.0"(i8*{{.+}})
 // WINDOWS: define dso_local noundef i32 @"?overloaded@@[e-mail].1"(i8*{{.+}})
-// WINDOWS: define weak_odr dso_local i32 @"?overloaded@@YAHPEBD@Z"(i8*{{.+}}) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?overloaded@@YAHPEBD@Z"(i8*{{.+}}) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?overloaded@@[e-mail]_ivybridge.0"
 // WINDOWS: call i32 @"?overloaded@@[e-mail].1"
 
 void use_overloaded() {
   overloaded(1);
   // LINUX: call noundef i32 @_Z10overloadedi.ifunc
   // WINDOWS: call noundef i32 @"?overloaded@@YAHH@Z"
   overloaded(nullptr);
void uses_specialized() {
   // LINUX: call noundef i32 @_ZN1CIfsE3fooEv(%struct.C
   // WINDOWS: call noundef i32 @"?foo@?$C@MF@@QEAAHXZ"(%struct.C
   C<double, float> c4;
   c4.foo();
   // LINUX: call noundef i32 @_ZN1CIdfE3fooEv.ifunc(%struct.C
   // WINDOWS: call noundef i32 @"?foo@?$C@NM@@QEAAHXZ"(%struct.C
 }
 
-// LINUX: define weak_odr i32 (%struct.C*)* @_ZN1CIssE3fooEv.resolver() comdat
+// LINUX: define weak_odr i32 (%struct.C*)* @_ZN1CIssE3fooEv.resolver() #{{[0-9]+}} comdat
 // LINUX: ret i32 (%struct.C*)* @_ZN1CIssE3fooEv.sse4.2.0
 // LINUX: ret i32 (%struct.C*)* @_ZN1CIssE3fooEv.default.1
 
 // WINDOWS: define {{.*}}i32 @"?foo@?$C@FF@@QEAAHXZ"(%struct.C{{.+}})
 // WINDOWS: call i32 @"?foo@?$C@FF@@QEAAHXZ.sse4.2.0"
 // WINDOWS: call i32 @"?foo@?$C@FF@@QEAAHXZ.default.1"
 
-// LINUX: define weak_odr i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.resolver() comdat
+// LINUX: define weak_odr i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.resolver() #{{[0-9]+}} comdat
 // LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.sse4.2.0
 // LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.default.1
 
 // WINDOWS: define {{.*}}i32 @"?foo@?$C@HF@@QEAAHXZ"(%struct.C{{.+}})
 // WINDOWS: call i32 @"?foo@?$C@HF@@QEAAHXZ.sse4.2.0"
 // WINDOWS: call i32 @"?foo@?$C@HF@@QEAAHXZ.default.1"
 
-// LINUX: define weak_odr i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.resolver() comdat
+// LINUX: define weak_odr i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.resolver() #{{[0-9]+}} comdat
 // LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.sse4.2.0
 // LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.default.1
 
 // WINDOWS: define {{.*}}i32 @"?foo@?$C@NM@@QEAAHXZ"(%struct.C{{.+}})
 // WINDOWS: call i32 @"?foo@?$C@NM@@QEAAHXZ.sse4.2.0"
 // WINDOWS: call i32 @"?foo@?$C@NM@@QEAAHXZ.default.1"
 
 // LINUX: define {{.*}}i32 @_ZN1CIssE3fooEv.sse4.2.0(%struct.C{{.+}})

clang/test/CodeGenCXX/attr-target-mv-diff-ns.cpp

 // LINUX: define{{.*}} i32 @_Z3barv()
 // LINUX: call noundef i32 @_Z3fooi.ifunc(i32 noundef 1)
 // LINUX: call noundef i32 @_ZN2ns3fooEi.ifunc(i32 noundef 2)
 
 // WINDOWS: define dso_local noundef i32 @"?bar@@YAHXZ"()
 // WINDOWS: call noundef i32 @"?foo@@[e-mail]"(i32 noundef 1)
 // WINDOWS: call noundef i32 @"?foo@ns@@[e-mail]"(i32 noundef 2)
 
-// LINUX: define weak_odr ptr @_Z3fooi.resolver() comdat
+// LINUX: define weak_odr ptr @_Z3fooi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_Z3fooi.arch_sandybridge
 // LINUX: ret ptr @_Z3fooi.arch_ivybridge
 // LINUX: ret ptr @_Z3fooi.sse4.2
 // LINUX: ret ptr @_Z3fooi
 
-// WINDOWS: define weak_odr dso_local i32 @"?foo@@[e-mail]"(i32 %0) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?foo@@[e-mail]"(i32 %0) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?foo@@[e-mail]_sandybridge"(i32 %0)
 // WINDOWS: call i32 @"?foo@@[e-mail]_ivybridge"(i32 %0)
 // WINDOWS: call i32 @"?foo@@[e-mail]4.2"(i32 %0)
 // WINDOWS: call i32 @"?foo@@YAHH@Z"(i32 %0)
 
-// LINUX: define weak_odr ptr @_ZN2ns3fooEi.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN2ns3fooEi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN2ns3fooEi.arch_sandybridge
 // LINUX: ret ptr @_ZN2ns3fooEi.arch_ivybridge
 // LINUX: ret ptr @_ZN2ns3fooEi.sse4.2
 // LINUX: ret ptr @_ZN2ns3fooEi
 
-// WINDOWS: define weak_odr dso_local i32 @"?foo@ns@@[e-mail]"(i32 %0) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?foo@ns@@[e-mail]"(i32 %0) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?foo@ns@@[e-mail]_sandybridge"(i32 %0)
 // WINDOWS: call i32 @"?foo@ns@@[e-mail]_ivybridge"(i32 %0)
 // WINDOWS: call i32 @"?foo@ns@@[e-mail]4.2"(i32 %0)
 // WINDOWS: call i32 @"?foo@ns@@YAHH@Z"(i32 %0)
 
 // LINUX: declare noundef i32 @_Z3fooi.arch_sandybridge(i32 noundef)
 // LINUX: declare noundef i32 @_ZN2ns3fooEi.arch_sandybridge(i32 noundef)
 
 // WINDOWS: declare dso_local noundef i32 @"?foo@@[e-mail]_sandybridge"(i32 noundef)
 // WINDOWS: declare dso_local noundef i32 @"?foo@ns@@[e-mail]_sandybridge"(i32 noundef)

clang/test/CodeGenCXX/attr-target-mv-member-funcs.cpp

 // WINDOWS: %s = alloca %struct.S, align 1
 // WINDOWS: %s2 = alloca %struct.S, align 1
 // WINDOWS: %C = alloca %struct.ConvertTo, align 1
 // WINDOWS: call noundef nonnull align 1 dereferenceable(1) ptr @"??4S@@QEAAAEAU0@AEBU0@@Z.resolver"(ptr {{[^,]*}} %s2
 // WINDOWS: call void @"??BConvertTo@@QEBA?AUS@@XZ.resolver"(ptr {{[^,]*}} %C
 // WINDOWS: call noundef nonnull align 1 dereferenceable(1) ptr @"??4S@@QEAAAEAU0@AEBU0@@Z.resolver"(ptr {{[^,]*}} %s2
 // WINDOWS: call noundef i32 @"?foo@S@@[e-mail]"(ptr {{[^,]*}} %s, i32 noundef 0)
 
-// LINUX: define weak_odr ptr @_ZN1SaSERKS_.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN1SaSERKS_.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN1SaSERKS_.arch_ivybridge
 // LINUX: ret ptr @_ZN1SaSERKS_
 
 // WINDOWS: define weak_odr dso_local ptr @"??4S@@QEAAAEAU0@AEBU0@@Z.resolver"(ptr %0, ptr %1)
 // WINDOWS: call ptr @"??4S@@QEAAAEAU0@AEBU0@@Z.arch_ivybridge"
 // WINDOWS: call ptr @"??4S@@QEAAAEAU0@AEBU0@@Z"
 
-// LINUX: define weak_odr ptr @_ZNK9ConvertTocv1SEv.resolver() comdat
+// LINUX: define weak_odr ptr @_ZNK9ConvertTocv1SEv.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZNK9ConvertTocv1SEv.arch_ivybridge
 // LINUX: ret ptr @_ZNK9ConvertTocv1SEv
 
 // WINDOWS: define weak_odr dso_local void @"??BConvertTo@@QEBA?AUS@@XZ.resolver"(ptr %0, ptr %1)
 // WINDOWS: call void @"??BConvertTo@@QEBA?AUS@@XZ.arch_ivybridge"
 // WINDOWS: call void @"??BConvertTo@@QEBA?AUS@@XZ"
 
-// LINUX: define weak_odr ptr @_ZN1S3fooEi.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN1S3fooEi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN1S3fooEi.arch_sandybridge
 // LINUX: ret ptr @_ZN1S3fooEi.arch_ivybridge
 // LINUX: ret ptr @_ZN1S3fooEi.sse4.2
 // LINUX: ret ptr @_ZN1S3fooEi
 
 // WINDOWS: define weak_odr dso_local i32 @"?foo@S@@[e-mail]"(ptr %0, i32 %1)
 // WINDOWS: call i32 @"?foo@S@@[e-mail]_sandybridge"
 // WINDOWS: call i32 @"?foo@S@@[e-mail]_ivybridge"
 // WINDOWS: call i32 @"?foo@S@@[e-mail]4.2"
 // WINDOWS: call i32 @"?foo@S@@QEAAHH@Z"
 
 // LINUX: define{{.*}} i32 @_Z4bar2v()
 // LINUX: call noundef i32 @_ZN2S23fooEi.ifunc
 
 // WINDOWS: define dso_local noundef i32 @"?bar2@@YAHXZ"()
 // WINDOWS: call noundef i32 @"?foo@S2@@[e-mail]"
 
-// LINUX: define weak_odr ptr @_ZN2S23fooEi.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN2S23fooEi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN2S23fooEi.arch_sandybridge
 // LINUX: ret ptr @_ZN2S23fooEi.arch_ivybridge
 // LINUX: ret ptr @_ZN2S23fooEi.sse4.2
 // LINUX: ret ptr @_ZN2S23fooEi
 
 // WINDOWS: define weak_odr dso_local i32 @"?foo@S2@@[e-mail]"(ptr %0, i32 %1)
 // WINDOWS: call i32 @"?foo@S2@@[e-mail]_sandybridge"
 // WINDOWS: call i32 @"?foo@S2@@[e-mail]_ivybridge"

 // LINUX: define{{.*}} i32 @_Z9templ_usev()
 // LINUX: call noundef i32 @_ZN5templIiE3fooEi.ifunc
 // LINUX: call noundef i32 @_ZN5templIdE3fooEi.ifunc
 
 // WINDOWS: define dso_local noundef i32 @"?templ_use@@YAHXZ"()
 // WINDOWS: call noundef i32 @"?foo@?$templ@H@@[e-mail]"
 // WINDOWS: call noundef i32 @"?foo@?$templ@N@@[e-mail]"
 
-// LINUX: define weak_odr ptr @_ZN5templIiE3fooEi.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN5templIiE3fooEi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN5templIiE3fooEi.arch_sandybridge
 // LINUX: ret ptr @_ZN5templIiE3fooEi.arch_ivybridge
 // LINUX: ret ptr @_ZN5templIiE3fooEi.sse4.2
 // LINUX: ret ptr @_ZN5templIiE3fooEi
 
 // WINDOWS: define weak_odr dso_local i32 @"?foo@?$templ@H@@[e-mail]"(ptr %0, i32 %1)
 // WINDOWS: call i32 @"?foo@?$templ@H@@[e-mail]_sandybridge"
 // WINDOWS: call i32 @"?foo@?$templ@H@@[e-mail]_ivybridge"
 // WINDOWS: call i32 @"?foo@?$templ@H@@[e-mail]4.2"
 // WINDOWS: call i32 @"?foo@?$templ@H@@QEAAHH@Z"
 
-// LINUX: define weak_odr ptr @_ZN5templIdE3fooEi.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN5templIdE3fooEi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN5templIdE3fooEi.arch_sandybridge
 // LINUX: ret ptr @_ZN5templIdE3fooEi.arch_ivybridge
 // LINUX: ret ptr @_ZN5templIdE3fooEi.sse4.2
 // LINUX: ret ptr @_ZN5templIdE3fooEi
 
-// WINDOWS: define weak_odr dso_local i32 @"?foo@?$templ@N@@[e-mail]"(ptr %0, i32 %1) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?foo@?$templ@N@@[e-mail]"(ptr %0, i32 %1) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?foo@?$templ@N@@[e-mail]_sandybridge"
 // WINDOWS: call i32 @"?foo@?$templ@N@@[e-mail]_ivybridge"
 // WINDOWS: call i32 @"?foo@?$templ@N@@[e-mail]4.2"
 // WINDOWS: call i32 @"?foo@?$templ@N@@QEAAHH@Z"
 
 // LINUX: define linkonce_odr noundef i32 @_ZN1S3fooEi.sse4.2(ptr {{[^,]*}} %this, i32 noundef %0)
 // LINUX: ret i32 0
 

clang/test/CodeGenCXX/attr-target-mv-out-of-line-defs.cpp

 // LINUX: define{{.*}} i32 @_Z3barv()
 // LINUX: %s = alloca %struct.S, align 1
 // LINUX: %call = call noundef i32 @_ZN1S3fooEi.ifunc(ptr {{[^,]*}} %s, i32 noundef 0)
 
 // WINDOWS: define dso_local noundef i32 @"?bar@@YAHXZ"()
 // WINDOWS: %s = alloca %struct.S, align 1
 // WINDOWS: %call = call noundef i32 @"?foo@S@@[e-mail]"(ptr {{[^,]*}} %s, i32 noundef 0)
 
-// LINUX: define weak_odr ptr @_ZN1S3fooEi.resolver() comdat
+// LINUX: define weak_odr ptr @_ZN1S3fooEi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_ZN1S3fooEi.arch_sandybridge
 // LINUX: ret ptr @_ZN1S3fooEi.arch_ivybridge
 // LINUX: ret ptr @_ZN1S3fooEi.sse4.2
 // LINUX: ret ptr @_ZN1S3fooEi
 
-// WINDOWS: define weak_odr dso_local i32 @"?foo@S@@[e-mail]"(ptr %0, i32 %1) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?foo@S@@[e-mail]"(ptr %0, i32 %1) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?foo@S@@[e-mail]_sandybridge"(ptr %0, i32 %1)
 // WINDOWS: call i32 @"?foo@S@@[e-mail]_ivybridge"(ptr %0, i32 %1)
 // WINDOWS: call i32 @"?foo@S@@[e-mail]4.2"(ptr %0, i32 %1)
 // WINDOWS: call i32 @"?foo@S@@QEAAHH@Z"(ptr %0, i32 %1)
 
 // LINUX: declare noundef i32 @_ZN1S3fooEi.arch_sandybridge(ptr {{[^,]*}}, i32 noundef)
 
 // WINDOWS: declare dso_local noundef i32 @"?foo@S@@[e-mail]_sandybridge"(ptr {{[^,]*}}, i32 noundef)

clang/test/CodeGenCXX/attr-target-mv-overloads.cpp

 // LINUX: define{{.*}} i32 @_Z4bar2v()
 // LINUX: call noundef i32 @_Z12foo_overloadv.ifunc()
 // LINUX: call noundef i32 @_Z12foo_overloadi.ifunc(i32 noundef 1)
 
 // WINDOWS: define dso_local noundef i32 @"?bar2@@YAHXZ"()
 // WINDOWS: call noundef i32 @"?foo_overload@@YAHXZ.resolver"()
 // WINDOWS: call noundef i32 @"?foo_overload@@[e-mail]"(i32 noundef 1)
 
-// LINUX: define weak_odr ptr @_Z12foo_overloadv.resolver() comdat
+// LINUX: define weak_odr ptr @_Z12foo_overloadv.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_Z12foo_overloadv.arch_sandybridge
 // LINUX: ret ptr @_Z12foo_overloadv.arch_ivybridge
 // LINUX: ret ptr @_Z12foo_overloadv.sse4.2
 // LINUX: ret ptr @_Z12foo_overloadv
 
-// WINDOWS: define weak_odr dso_local i32 @"?foo_overload@@YAHXZ.resolver"() comdat
+// WINDOWS: define weak_odr dso_local i32 @"?foo_overload@@YAHXZ.resolver"() #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?foo_overload@@YAHXZ.arch_sandybridge"
 // WINDOWS: call i32 @"?foo_overload@@YAHXZ.arch_ivybridge"
 // WINDOWS: call i32 @"?foo_overload@@YAHXZ.sse4.2"
 // WINDOWS: call i32 @"?foo_overload@@YAHXZ"
 
-// LINUX: define weak_odr ptr @_Z12foo_overloadi.resolver() comdat
+// LINUX: define weak_odr ptr @_Z12foo_overloadi.resolver() #{{[0-9]+}} comdat
 // LINUX: ret ptr @_Z12foo_overloadi.arch_sandybridge
 // LINUX: ret ptr @_Z12foo_overloadi.arch_ivybridge
 // LINUX: ret ptr @_Z12foo_overloadi.sse4.2
 // LINUX: ret ptr @_Z12foo_overloadi
 
-// WINDOWS: define weak_odr dso_local i32 @"?foo_overload@@[e-mail]"(i32 %0) comdat
+// WINDOWS: define weak_odr dso_local i32 @"?foo_overload@@[e-mail]"(i32 %0) #{{[0-9]+}} comdat
 // WINDOWS: call i32 @"?foo_overload@@[e-mail]_sandybridge"
 // WINDOWS: call i32 @"?foo_overload@@[e-mail]_ivybridge"
 // WINDOWS: call i32 @"?foo_overload@@[e-mail]4.2"
 // WINDOWS: call i32 @"?foo_overload@@YAHH@Z"
 
 // LINUX: declare noundef i32 @_Z12foo_overloadv.arch_sandybridge()
 // LINUX: declare noundef i32 @_Z12foo_overloadi.arch_sandybridge(i32 noundef)
 
 // WINDOWS: declare dso_local noundef i32 @"?foo_overload@@YAHXZ.arch_sandybridge"()
 // WINDOWS: declare dso_local noundef i32 @"?foo_overload@@[e-mail]_sandybridge"(i32 noundef)

clang/test/CodeGenCXX/dynamic-cast.cpp

try {
     // CHECK:      landingpad { ptr, i32 }
     // CHECK-NEXT:   catch ptr null
   }
   return fail;
 }
 
 // CHECK: declare ptr @__dynamic_cast(ptr, ptr, ptr, i64) [[NUW_RO:#[0-9]+]]
 
-// CHECK: attributes [[NUW_RO]] = { nounwind memory(read) }
+// CHECK: attributes [[NUW_RO]] = { nounwind memory(read) {{.*}} }
 // CHECK: attributes [[NR]] = { noreturn }

clang/test/CodeGenCXX/runtimecc.cpp

namespace test0 {
 
   A global;
 // CHECK-LABEL:    define internal void @__cxx_global_var_init()
 // CHECK:      call noundef ptr @_ZN5test01AC1Ev(ptr {{[^,]*}} @_ZN5test06globalE)
 // CHECK-NEXT: call i32 @__cxa_atexit(ptr @_ZN5test01AD1Ev, ptr @_ZN5test06globalE, ptr @__dso_handle) [[NOUNWIND:#[0-9]+]]
 // CHECK-NEXT: ret void
 }
 
-// CHECK: declare i32 @__cxa_atexit(ptr, ptr, ptr) [[NOUNWIND]]
+// CHECK: declare i32 @__cxa_atexit(ptr, ptr, ptr) [[NOUNWIND1:#[0-9]+]]
 
 namespace test1 {
   void test() {
     throw 0;
   }
 
 // CHECK-LABEL:    define{{.*}} void @_ZN5test14testEv()
 // CHECK:      [[T0:%.*]] = call ptr @__cxa_allocate_exception(i32 4) [[NOUNWIND]]
 // CHECK-NEXT: store i32 0, ptr [[T0]]
 // CHECK-NEXT: call void @__cxa_throw(ptr [[T0]], ptr @_ZTIi, ptr null) [[NORETURN:#[0-9]+]]
 // CHECK-NEXT: unreachable
 }
 
 // CHECK: declare ptr @__cxa_allocate_exception(i32)
 
 // CHECK: declare void @__cxa_throw(ptr, ptr, ptr)
 
 // CHECK-LABEL: define internal void @_GLOBAL__sub_I_runtimecc.cpp()
 // CHECK:   call void @__cxx_global_var_init()
 
-
+// CHECK: attributes [[NOUNWIND1]] = { nounwind {{.*}} }
 // CHECK: attributes [[NOUNWIND]] = { nounwind }
 // CHECK: attributes [[NORETURN]] = { noreturn }

clang/test/CodeGenObjC/arc.m

 // CHECK: call void @llvm.objc.release(i8* %[[V10]]) #2, !clang.imprecise_release !10
 // CHECK: %[[V11:.*]] = load i8*, i8** %[[A_ADDR]], align 8
 // CHECK: call void @llvm.objc.release(i8* %[[V11]]) #2, !clang.imprecise_release !10
 
 void test72(id a, id b) {
   __strong id t[] = (__strong id[]){a, b};
 }
 
-// ARC-ALIEN: attributes [[NLB]] = { nonlazybind }
-// ARC-NATIVE: attributes [[NLB]] = { nonlazybind }
-// CHECK: attributes [[NUW]] = { nounwind }
+// ARC-ALIEN: attributes [[NLB]] = { nonlazybind {{.*}}}
+// ARC-NATIVE: attributes [[NLB]] = { nonlazybind {{.*}}}
+// CHECK: attributes [[NUW]] = { nounwind {{.*}}}

clang/test/CodeGenObjC/attr-objc-runtime-visible.m

 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-darwin -fobjc-runtime=macosx-10.9.0 -emit-llvm %s -o - | FileCheck %s
 
 // RUN: %clang_cc1 -no-opaque-pointers -triple i386-apple-darwin -fobjc-runtime=macosx-fragile-10.9.0 -emit-llvm %s -o - | FileCheck %s
 
 @interface Root
 +(Class)class;
 @end
 
 __attribute__((objc_runtime_visible))
 __attribute__((objc_runtime_name("MyRuntimeVisibleClass")))
 @interface A : Root
 @end
 
 // CHECK: [[CLASSNAME:@.*]] = private unnamed_addr constant [22 x i8] c"MyRuntimeVisibleClass
 // CHECK: define{{.*}} i8* @getClass() #0 {
 Class getClass(void) {
-  // CHECK: call i8* @objc_lookUpClass(i8* getelementptr inbounds ([22 x i8], [22 x i8]* [[CLASSNAME]], i32 0, i32 0)) #2
+  // CHECK: call i8* @objc_lookUpClass(i8* getelementptr inbounds ([22 x i8], [22 x i8]* [[CLASSNAME]], i32 0, i32 0)) #{{[0-9]+}}
   return [A class];
 }

clang/test/CodeGenObjC/class-stubs.m

 // CHECK:        [[DEST:%.*]] = getelementptr inbounds %struct._objc_super, %struct._objc_super* [[SUPER]], i32 0, i32 1
 // CHECK:        store i8* [[CAST_CLASS_REF]], i8** [[DEST]], align 8
 // CHECK:        call void bitcast (i8* (%struct._objc_super*, i8*, ...)* @objc_msgSendSuper2 to void (%struct._objc_super*, i8*)*)(%struct._objc_super* noundef [[SUPER]], i8* noundef {{%.*}})
 // CHECK:        ret void
 
 @end
 
 // -- calls to objc_loadClassRef() are readnone
-// CHECK: attributes [[ATTRLIST]] = { nounwind nonlazybind memory(none) }
+// CHECK: attributes [[ATTRLIST]] = { nounwind nonlazybind memory(none) {{.*}} }

clang/test/CodeGenObjC/nonlazy-msgSend.m

 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm %s -o - | FileCheck %s
 
 // CHECK: declare i8* @objc_msgSend(i8*, i8*, ...) [[NLB:#[0-9]+]]
 void f0(id x) {
   [x foo];
 }
 
-// CHECK: attributes [[NLB]] = { nonlazybind }
+// CHECK: attributes [[NLB]] = { nonlazybind {{.*}}}

clang/test/CodeGenObjC/objc-literal-debugger-test.m

#if __has_feature(objc_boxed_expressions)
   b = @("hello");
 #else
 #error "boxed expressions not supported"
 #endif
 }
 
 // CHECK: declare i8* @objc_msgSend(i8*, i8*, ...) [[NLB:#[0-9]+]]
 
-// CHECK: attributes [[NLB]] = { nonlazybind }
+// CHECK: attributes [[NLB]] = { nonlazybind "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }

clang/test/PCH/objc_container.m

 // CHECK-IR: define {{.*}}void @all() #0
 // CHECK-IR: {{call.*objc_msgSend}}
 // CHECK-IR: {{call.*objc_msgSend}}
 // CHECK-IR: {{call.*objc_msgSend}}
 // CHECK-IR: {{call.*objc_msgSend}}
 // CHECK-IR: ret void
 
 // CHECK-IR: attributes #0 = { noinline nounwind {{.*}} }
-// CHECK-IR: attributes #1 = { nonlazybind }
+// CHECK-IR: attributes #1 = { nonlazybind {{.*}} }