[UpdateTestChecks] Match define for labels

[sebastian-ne]

Summary

Previously, the label also matched function calls with the function
name, which caused tests to fail because the label matched on the wrong
line.
Add the define prefix, so only function defines are matched.

[lebedev.ri]

This is going to cause such a churn :(
[Un]fortunately, i think i've just yesterday run into that.
Could you please ensure that the utils/update_cc_test_checks.py is also being fixed, and maybe add a test?

[lebedev.ri]

(Also, it may be good to add the test with the actual problematic case...)

[sebastian-ne]

Thanks for the review!
I updated the update_cc_tests tests and added a test where the FileCheck failed previously.

[lebedev.ri]

LGTM.
I do think this is an important fix, not the least because i've also just hit that,
but i do want to explicitly call out that this will cause a massive test case churn,
so i do want a second reviewer here.

[mtrofin]

LGTM, but I'd wait for Johannes to review it, too (because of e67f6477fd1ed29acbeddf8482c25d8db826912f. I for one don't quite follow the reasoning there wrt adding the else)

[lebedev.ri]

In D139006#3960466, @mtrofin wrote:

LGTM, but I'd wait for Johannes to review it, too (because of e67f6477fd1ed29acbeddf8482c25d8db826912f. I for one don't quite follow the reasoning there wrt adding the else)

That commit explicitly links to https://reviews.llvm.org/D68819,
after reading that thread, it is obvious that rGe67f6477fd1ed29acbeddf8482c25d8db826912f
was made prevent the churn we are about to expirience.

[arichardson]

Agreed that the churn is annoying, but at least unlike the function-signature flag (which I'd quite like to have on by default tbh) it only affects a single line rather than also including variable captures.

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/define_after_call.ll.expected

14

Does this actually fail without the define match? I wouldn't expect it to?

[sebastian-ne]

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/define_after_call.ll.expected

14

Yes, it fails (which is why I put the opt | FileCheck line into the .test script as well).
CHECK-LABEL: @b( matches the call i32 @b(i32 0) line and and as labels are matched before check-lines, then the CHECK-NEXT: [[VAL:%.*]] = call i32 @b(i32 0) line doesn’t find its match anymore (or the ret i32 match, I’m not quite sure, but it definitely fails).

[sebastian-ne]

I guess this is fine to merge. I’ll leave it for a day in case someone has more comments.

[lebedev.ri]

In D139006#3981326, @sebastian-ne wrote:

I guess this is fine to merge. I’ll leave it for a day in case someone has more comments.

I guess, we could be pedantic and post an RFC to disscuss.
But this really is a bug, and the alternative solutions would only hide it.

[mkazantsev]

So now every single test needs to be regenerated? It'll create straw diff from nowhere...

[sebastian-ne]

In D139006#3988215, @mkazantsev wrote:

So now every single test needs to be regenerated? It'll create straw diff from nowhere...

We don’t need to regenerate every test.
Similar to how we don’t reformat all of LLVM after a change in clang-format, we can just do that when regenerating tests when they have changes anyway.
So, the churn is that we have extra changes when regenerating a test for a patch.
(In my personal experience there are often extra changes anyway, because metadata was added or similar changes that pass the old CHECKs but show up on a freshly regenerated test.)

[nikic]

In D139006#3988227, @sebastian-ne wrote:

In D139006#3988215, @mkazantsev wrote:

So now every single test needs to be regenerated? It'll create straw diff from nowhere...

We don’t need to regenerate every test.
Similar to how we don’t reformat all of LLVM after a change in clang-format, we can just do that when regenerating tests when they have changes anyway.
So, the churn is that we have extra changes when regenerating a test for a patch.

This kind of change requires generating check lines in a separate commit prior to the patch, because functional patches must not contain this kind of noise. This kind of change to UTC output is very annoying.

Please revert this patch pending further discussion.

I think there's three options here:

1. The status quo, which is that you must pass --function-signature if you encounter this issue.
2. What this patch does, which causes massive churn.
3. Something like adding --function-signature to UTC_ARGS by default for new tests, while not doing so for old ones.

If we are not content with the status quo, then we should do something along the lines of 3. Possibly not with --function-signature but something like a --version N flag that defaults to the latest but gets persisted in UTC_ARGS. This way we are free to improve UTC without being worried about test churn.

[spatel]

I agree with the revert - we'd need lots of commits like this:
b7232dafe69eb04c14217 (cc @arsenm)

Another possibility to fix this with less churn:
Add a warning during (re-)generation for any test where the CHECK-LABEL could be going wrong. So scan the file for a call to a function name that is also defined in that file?
We already have a warning like that for variables named %tmp. So if a test file contains the potentially buggy construct, then warn the user that they should regenerate with "--function-signature" to be safe.

[jdoerfert]

Why not just --function-define as a way to enable the define but not the captures, if that is really something necessary.
It is unclear to me why function-signature is not sufficient here and what the big problem with using it is.

FWIW, I also already redid all OpenMP and Attributor tests now, double churn!

[nikic]

In D139006#3999984, @jdoerfert wrote:

Why not just --function-define as a way to enable the define but not the captures, if that is really something necessary.
It is unclear to me why function-signature is not sufficient here and what the big problem with using it is.

I believe the motivation here is the default behavior: Experienced contributors know how to recognize this problem and use --function-signature to avoid it, but new contributors will not be aware of it, and the error message produced by FileCheck is not super helpful.

That's why I'm suggesting to change the default behavior for new tests, and @spatel suggests to add detection for the scenario and a warning that tells you to use --function-signature. Either of those should address the discoverability issue.

[sebastian-ne]

I believe the motivation here is the default behavior

Correct, update_test_checks produces a broken test for some input and I think this is a bug that we should fix.

Sorry for the test churn and thanks for the revert (I only got to work a few hours after nikic already reverted).

That's why I'm suggesting to change the default behavior for new tests

Adding --function-signature by default sounds like a good idea to me.
Is there any reason why we wouldn’t want to enable this by default (for new tests)?

[spatel]

In D139006#4000992, @sebastian-ne wrote:

Adding --function-signature by default sounds like a good idea to me.
Is there any reason why we wouldn’t want to enable this by default (for new tests)?

No objection from me for new files. There's some small time cost for added checks, but AFAIK nobody cares about that, so the added verification to also make sure we didn't accidentally swap function args during regex is worth it.

[arichardson]

I like the idea of defaulting to --function-signature for new tests a lot, so I've implemented that in D140212

clang/test/utils/update_cc_test_checks/Inputs/basic-cplusplus.cpp.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // Basic C++ test for update_cc_test_checks
 // RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
 class Foo {
   int x;
 
 public:
   explicit Foo(int x);
   ~Foo();
-// CHECK-LABEL: @_ZNK3Foo23function_defined_inlineEi(
+// CHECK-LABEL: define {{[^@]+}}@_ZNK3Foo23function_defined_inlineEi(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %class.Foo*, align 8
 // CHECK-NEXT:    [[ARG_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store %class.Foo* [[THIS:%.*]], %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[ARG:%.*]], i32* [[ARG_ADDR]], align 4
 // CHECK-NEXT:    [[THIS1:%.*]] = load %class.Foo*, %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[ARG_ADDR]], align 4
 // CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds [[CLASS_FOO:%.*]], %class.Foo* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[X]], align 4
 // CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    ret i32 [[ADD]]
 //
   inline int function_defined_inline(int arg) const {
     return arg + x;
   }
   inline int function_defined_out_of_line(int arg) const;
 };
 
-// CHECK-LABEL: @_ZN3FooC1Ei(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooC1Ei(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %class.Foo*, align 8
 // CHECK-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store %class.Foo* [[THIS:%.*]], %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[X:%.*]], i32* [[X_ADDR]], align 4
 // CHECK-NEXT:    [[THIS1:%.*]] = load %class.Foo*, %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[X_ADDR]], align 4
 // CHECK-NEXT:    call void @_ZN3FooC2Ei(%class.Foo* noundef nonnull align 4 dereferenceable(4) [[THIS1]], i32 noundef [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 Foo::Foo(int x) : x(x) {}
-// CHECK-LABEL: @_ZN3FooD1Ev(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooD1Ev(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %class.Foo*, align 8
 // CHECK-NEXT:    store %class.Foo* [[THIS:%.*]], %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %class.Foo*, %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    call void @_ZN3FooD2Ev(%class.Foo* noundef nonnull align 4 dereferenceable(4) [[THIS1]]) #[[ATTR3:[0-9]+]]
 // CHECK-NEXT:    ret void
 //
 Foo::~Foo() {}
-// CHECK-LABEL: @_ZNK3Foo28function_defined_out_of_lineEi(
+// CHECK-LABEL: define {{[^@]+}}@_ZNK3Foo28function_defined_out_of_lineEi(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %class.Foo*, align 8
 // CHECK-NEXT:    [[ARG_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store %class.Foo* [[THIS:%.*]], %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[ARG:%.*]], i32* [[ARG_ADDR]], align 4
 // CHECK-NEXT:    [[THIS1:%.*]] = load %class.Foo*, %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds [[CLASS_FOO:%.*]], %class.Foo* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[X]], align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[ARG_ADDR]], align 4
 // CHECK-NEXT:    [[SUB:%.*]] = sub nsw i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    ret i32 [[SUB]]
 //
 int Foo::function_defined_out_of_line(int arg) const { return x - arg; }
 
 // Call the inline methods to ensure the LLVM IR is generated:
-// CHECK-LABEL: @main(
+// CHECK-LABEL: define {{[^@]+}}@main(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[F:%.*]] = alloca [[CLASS_FOO:%.*]], align 4
 // CHECK-NEXT:    call void @_ZN3FooC1Ei(%class.Foo* noundef nonnull align 4 dereferenceable(4) [[F]], i32 noundef 1)
 // CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_ZNK3Foo23function_defined_inlineEi(%class.Foo* noundef nonnull align 4 dereferenceable(4) [[F]], i32 noundef 2)
 // CHECK-NEXT:    [[CALL1:%.*]] = call noundef i32 @_ZNK3Foo28function_defined_out_of_lineEi(%class.Foo* noundef nonnull align 4 dereferenceable(4) [[F]], i32 noundef 3)
 // CHECK-NEXT:    call void @_ZN3FooD1Ev(%class.Foo* noundef nonnull align 4 dereferenceable(4) [[F]]) #[[ATTR3]]
 // CHECK-NEXT:    ret i32 0
 //
 int main() {
   Foo f(1);
   f.function_defined_inline(2);
   f.function_defined_out_of_line(3);
 }

clang/test/utils/update_cc_test_checks/Inputs/check-attributes.cpp.funcattrs.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-attributes
 // RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 struct RT {
   char A;
   int B[10][20];
   char C;
 };
 struct ST {
   int X;
   double Y;
   struct RT Z;
 };
 
 // CHECK: Function Attrs: mustprogress noinline nounwind optnone
-// CHECK-LABEL: @_Z3fooP2ST(
+// CHECK-LABEL: define {{[^@]+}}@_Z3fooP2ST(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[S_ADDR:%.*]] = alloca %struct.ST*, align 8
 // CHECK-NEXT:    store %struct.ST* [[S:%.*]], %struct.ST** [[S_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[S_ADDR]], align 8
 // CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i64 1
 // CHECK-NEXT:    [[Z:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ARRAYIDX]], i32 0, i32 2
 // CHECK-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_RT:%.*]], %struct.RT* [[Z]], i32 0, i32 1
 // CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x [20 x i32]], [10 x [20 x i32]]* [[B]], i64 0, i64 5
 // CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [20 x i32], [20 x i32]* [[ARRAYIDX1]], i64 0, i64 13
 // CHECK-NEXT:    ret i32* [[ARRAYIDX2]]
 //
 int *foo(struct ST *s) {
   return &s[1].Z.B[5][13];
 }

clang/test/utils/update_cc_test_checks/Inputs/check-attributes.cpp.plain.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 struct RT {
   char A;
   int B[10][20];
   char C;
 };
 struct ST {
   int X;
   double Y;
   struct RT Z;
 };
 
-// CHECK-LABEL: @_Z3fooP2ST(
+// CHECK-LABEL: define {{[^@]+}}@_Z3fooP2ST(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[S_ADDR:%.*]] = alloca %struct.ST*, align 8
 // CHECK-NEXT:    store %struct.ST* [[S:%.*]], %struct.ST** [[S_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[S_ADDR]], align 8
 // CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i64 1
 // CHECK-NEXT:    [[Z:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ARRAYIDX]], i32 0, i32 2
 // CHECK-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_RT:%.*]], %struct.RT* [[Z]], i32 0, i32 1
 // CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x [20 x i32]], [10 x [20 x i32]]* [[B]], i64 0, i64 5
 // CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [20 x i32], [20 x i32]* [[ARRAYIDX1]], i64 0, i64 13
 // CHECK-NEXT:    ret i32* [[ARRAYIDX2]]
 //
 int *foo(struct ST *s) {
   return &s[1].Z.B[5][13];
 }

clang/test/utils/update_cc_test_checks/Inputs/def-and-decl.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // Check that the CHECK lines are generated before the definition and not the declaration
 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s
 
 int foo(int arg);
 
 void empty_function(void);
 
-// CHECK-LABEL: @main(
+// CHECK-LABEL: define {{[^@]+}}@main(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i32 0, i32* [[RETVAL]], align 4
 // CHECK-NEXT:    call void @empty_function()
 // CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo(i32 noundef 1)
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
 int main(void) {
   empty_function();
   return foo(1);
 }
 
-// CHECK-LABEL: @foo(
+// CHECK-LABEL: define {{[^@]+}}@foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[ARG_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[ARG:%.*]], i32* [[ARG_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[ARG_ADDR]], align 4
 // CHECK-NEXT:    ret i32 [[TMP0]]
 //
 int foo(int arg) {
   return arg;
 }
 
-// CHECK-LABEL: @empty_function(
+// CHECK-LABEL: define {{[^@]+}}@empty_function(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret void
 //
 void empty_function(void) {}

clang/test/utils/update_cc_test_checks/Inputs/exec-all-runlines.c.expected

 // RUN: %clang_cc1 -no-opaque-pointers -triple powerpc64le-unknown-linux-gnu -include-pch %t %s.copy.c -emit-llvm -o - | FileCheck %s --check-prefix=CHECK3
 
 
 #ifndef HEADER
 #define HEADER
 
 void use(int);
 
-// CHECK1-LABEL: @test(
+// CHECK1-LABEL: define {{[^@]+}}@test(
 // CHECK1-NEXT:  entry:
 // CHECK1-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK1-NEXT:    store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
 // CHECK1-NEXT:    ret void
 //
-// CHECK2-LABEL: @test(
+// CHECK2-LABEL: define {{[^@]+}}@test(
 // CHECK2-NEXT:  entry:
 // CHECK2-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
 // CHECK2-NEXT:    ret void
 //
-// CHECK3-LABEL: @test(
+// CHECK3-LABEL: define {{[^@]+}}@test(
 // CHECK3-NEXT:  entry:
 // CHECK3-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK3-NEXT:    store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
 // CHECK3-NEXT:    ret void
 //
 void test(int a)
 {
 }
 
 #endif

clang/test/utils/update_cc_test_checks/Inputs/explicit-template-instantiation.cpp.expected

 struct Baz : Foo<T> {
 public:
   Baz(T x) : Foo<T>(x) {}
   ~Baz() {}
 };
 
 // These two specializations should generate lines for all of Foo's methods.
 
-// CHECK-LABEL: @_ZN3FooIcEC1Ec(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIcEC1Ec(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo*, align 8
 // CHECK-NEXT:    [[X_ADDR:%.*]] = alloca i8, align 1
 // CHECK-NEXT:    store %struct.Foo* [[THIS:%.*]], %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i8 [[X:%.*]], i8* [[X_ADDR]], align 1
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo*, %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X_ADDR]], align 1
 // CHECK-NEXT:    call void @_ZN3FooIcEC2Ec(%struct.Foo* noundef nonnull align 1 dereferenceable(1) [[THIS1]], i8 noundef signext [[TMP0]])
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3FooIcED1Ev(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIcED1Ev(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo*, align 8
 // CHECK-NEXT:    store %struct.Foo* [[THIS:%.*]], %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo*, %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    call void @_ZN3FooIcED2Ev(%struct.Foo* noundef nonnull align 1 dereferenceable(1) [[THIS1]]) #[[ATTR2:[0-9]+]]
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3FooIcE3getEv(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIcE3getEv(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo*, align 8
 // CHECK-NEXT:    store %struct.Foo* [[THIS:%.*]], %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo*, %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_FOO:%.*]], %struct.Foo* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    [[TMP0:%.*]] = load i8, i8* [[X]], align 1
 // CHECK-NEXT:    ret i8 [[TMP0]]
 //
-// CHECK-LABEL: @_ZN3FooIcE3setEc(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIcE3setEc(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo*, align 8
 // CHECK-NEXT:    [[_X_ADDR:%.*]] = alloca i8, align 1
 // CHECK-NEXT:    store %struct.Foo* [[THIS:%.*]], %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i8 [[_X:%.*]], i8* [[_X_ADDR]], align 1
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo*, %struct.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i8, i8* [[_X_ADDR]], align 1
 // CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_FOO:%.*]], %struct.Foo* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    store i8 [[TMP0]], i8* [[X]], align 1
 // CHECK-NEXT:    ret void
 //
 template struct Foo<char>;
 
-// CHECK-LABEL: @_ZN3FooIsEC1Es(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIsEC1Es(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo.0*, align 8
 // CHECK-NEXT:    [[X_ADDR:%.*]] = alloca i16, align 2
 // CHECK-NEXT:    store %struct.Foo.0* [[THIS:%.*]], %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i16 [[X:%.*]], i16* [[X_ADDR]], align 2
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo.0*, %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i16, i16* [[X_ADDR]], align 2
 // CHECK-NEXT:    call void @_ZN3FooIsEC2Es(%struct.Foo.0* noundef nonnull align 2 dereferenceable(2) [[THIS1]], i16 noundef signext [[TMP0]])
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3FooIsED1Ev(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIsED1Ev(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo.0*, align 8
 // CHECK-NEXT:    store %struct.Foo.0* [[THIS:%.*]], %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo.0*, %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    call void @_ZN3FooIsED2Ev(%struct.Foo.0* noundef nonnull align 2 dereferenceable(2) [[THIS1]]) #[[ATTR2]]
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3FooIsE3getEv(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIsE3getEv(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo.0*, align 8
 // CHECK-NEXT:    store %struct.Foo.0* [[THIS:%.*]], %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo.0*, %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_FOO_0:%.*]], %struct.Foo.0* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    [[TMP0:%.*]] = load i16, i16* [[X]], align 2
 // CHECK-NEXT:    ret i16 [[TMP0]]
 //
-// CHECK-LABEL: @_ZN3FooIsE3setEs(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3FooIsE3setEs(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Foo.0*, align 8
 // CHECK-NEXT:    [[_X_ADDR:%.*]] = alloca i16, align 2
 // CHECK-NEXT:    store %struct.Foo.0* [[THIS:%.*]], %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i16 [[_X:%.*]], i16* [[_X_ADDR]], align 2
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Foo.0*, %struct.Foo.0** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i16, i16* [[_X_ADDR]], align 2
 // CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds [[STRUCT_FOO_0:%.*]], %struct.Foo.0* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    store i16 [[TMP0]], i16* [[X]], align 2
 // CHECK-NEXT:    ret void
 //
 template struct Foo<short>;
 
 // This should not generate lines for the implicit specialization of Foo, but
 // should generate lines for the explicit specialization of Bar.
 
-// CHECK-LABEL: @_ZN3BarIiEC1Ei(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3BarIiEC1Ei(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Bar*, align 8
 // CHECK-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store %struct.Bar* [[THIS:%.*]], %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[X:%.*]], i32* [[X_ADDR]], align 4
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Bar*, %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[X_ADDR]], align 4
 // CHECK-NEXT:    call void @_ZN3BarIiEC2Ei(%struct.Bar* noundef nonnull align 4 dereferenceable(4) [[THIS1]], i32 noundef [[TMP0]])
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3BarIiED1Ev(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3BarIiED1Ev(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Bar*, align 8
 // CHECK-NEXT:    store %struct.Bar* [[THIS:%.*]], %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Bar*, %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    call void @_ZN3BarIiED2Ev(%struct.Bar* noundef nonnull align 4 dereferenceable(4) [[THIS1]]) #[[ATTR2]]
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3BarIiE3getEv(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3BarIiE3getEv(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Bar*, align 8
 // CHECK-NEXT:    store %struct.Bar* [[THIS:%.*]], %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Bar*, %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[FOO:%.*]] = getelementptr inbounds [[STRUCT_BAR:%.*]], %struct.Bar* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_ZN3FooIiE3getEv(%struct.Foo.1* noundef nonnull align 4 dereferenceable(4) [[FOO]])
 // CHECK-NEXT:    ret i32 [[CALL]]
 //
-// CHECK-LABEL: @_ZN3BarIiE3setEi(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3BarIiE3setEi(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Bar*, align 8
 // CHECK-NEXT:    [[_X_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store %struct.Bar* [[THIS:%.*]], %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[_X:%.*]], i32* [[_X_ADDR]], align 4
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Bar*, %struct.Bar** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[FOO:%.*]] = getelementptr inbounds [[STRUCT_BAR:%.*]], %struct.Bar* [[THIS1]], i32 0, i32 0
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[_X_ADDR]], align 4
 // CHECK-NEXT:    call void @_ZN3FooIiE3setEi(%struct.Foo.1* noundef nonnull align 4 dereferenceable(4) [[FOO]], i32 noundef [[TMP0]])
 // CHECK-NEXT:    ret void
 //
 template struct Bar<int>;
 
 // This should not generate lines for the implicit specialization of Foo, but
 // should generate lines for the explicit specialization of Baz.
 
-// CHECK-LABEL: @_ZN3BazIlEC1El(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3BazIlEC1El(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Baz*, align 8
 // CHECK-NEXT:    [[X_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    store %struct.Baz* [[THIS:%.*]], %struct.Baz** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    store i64 [[X:%.*]], i64* [[X_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Baz*, %struct.Baz** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[X_ADDR]], align 8
 // CHECK-NEXT:    call void @_ZN3BazIlEC2El(%struct.Baz* noundef nonnull align 8 dereferenceable(8) [[THIS1]], i64 noundef [[TMP0]])
 // CHECK-NEXT:    ret void
 //
-// CHECK-LABEL: @_ZN3BazIlED1Ev(
+// CHECK-LABEL: define {{[^@]+}}@_ZN3BazIlED1Ev(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %struct.Baz*, align 8
 // CHECK-NEXT:    store %struct.Baz* [[THIS:%.*]], %struct.Baz** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %struct.Baz*, %struct.Baz** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    call void @_ZN3BazIlED2Ev(%struct.Baz* noundef nonnull align 8 dereferenceable(8) [[THIS1]]) #[[ATTR2]]
 // CHECK-NEXT:    ret void
 //
 template struct Baz<long>;

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs-regex.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__([a-z]+)_offloading_[a-z0-9]+_[a-z0-9]+_(.*)_l[0-9]+" "somevar_[a-z0-9]+_"
 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck %s
 
 void __test_offloading_42_abcdef_bar_l123(void);
 void use(int);
 
 void foo(int a)
 {
     #pragma omp target
         use(a);
 
     __test_offloading_42_abcdef_bar_l123();
     int somevar_abc123_;
 }
-// CHECK-LABEL: @foo(
+// CHECK-LABEL: define {{[^@]+}}@foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    [[A_CASTED:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    %{{somevar_[a-z0-9]+_}} = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A_ADDR]], align 4
 // CHECK-NEXT:    [[CONV:%.*]] = bitcast i64* [[A_CASTED]] to i32*
 // CHECK-NEXT:    store i32 [[TMP0]], i32* [[CONV]], align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i64, i64* [[A_CASTED]], align 8
 // CHECK-NEXT:    call void @{{__omp_offloading_[a-z0-9]+_[a-z0-9]+_foo_l[0-9]+}}(i64 [[TMP1]]) #[[ATTR3:[0-9]+]]
 // CHECK-NEXT:    call void @{{__test_offloading_[a-z0-9]+_[a-z0-9]+_bar_l[0-9]+}}()
 // CHECK-NEXT:    ret void
 //
 //
-// CHECK-LABEL: @{{__omp_offloading_[a-z0-9]+_[a-z0-9]+_foo_l[0-9]+}}(
+// CHECK-LABEL: define {{[^@]+}}@{{__omp_offloading_[a-z0-9]+_[a-z0-9]+_foo_l[0-9]+}}(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
 // CHECK-NEXT:    [[CONV:%.*]] = bitcast i64* [[A_ADDR]] to i32*
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[CONV]], align 4
 // CHECK-NEXT:    call void @use(i32 noundef [[TMP0]])
 // CHECK-NEXT:    ret void
 //

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs.c.generated.expected

 void foo(void) {
   int i = 0;
 
 #pragma omp parallel for
   for (i = 0; i < size; ++i) {
     A[i] = 1.0;
   }
 }
-// OMP-LABEL: @main(
+// OMP-LABEL: define {{[^@]+}}@main(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
 // OMP-NEXT:    store i32 0, i32* [[I]], align 4
 // OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2:[0-9]+]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
 // OMP-NEXT:    call void @foo()
 // OMP-NEXT:    ret i32 0
 //
 //
-// OMP-LABEL: @.omp_outlined.(
+// OMP-LABEL: define {{[^@]+}}@.omp_outlined.(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[TMP:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4

 // OMP-NEXT:    br label [[OMP_INNER_FOR_COND]]
 // OMP:       omp.inner.for.end:
 // OMP-NEXT:    br label [[OMP_LOOP_EXIT:%.*]]
 // OMP:       omp.loop.exit:
 // OMP-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[TMP1]])
 // OMP-NEXT:    ret void
 //
 //
-// OMP-LABEL: @foo(
+// OMP-LABEL: define {{[^@]+}}@foo(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, i32* [[I]], align 4
 // OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 to void (i32*, i32*, ...)*))
 // OMP-NEXT:    ret void
 //
 //
-// OMP-LABEL: @.omp_outlined..1(
+// OMP-LABEL: define {{[^@]+}}@.omp_outlined..1(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[TMP:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4

 // OMP-NEXT:    br label [[OMP_INNER_FOR_COND]]
 // OMP:       omp.inner.for.end:
 // OMP-NEXT:    br label [[OMP_LOOP_EXIT:%.*]]
 // OMP:       omp.loop.exit:
 // OMP-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[TMP1]])
 // OMP-NEXT:    ret void
 //
 //
-// NOOMP-LABEL: @main(
+// NOOMP-LABEL: define {{[^@]+}}@main(
 // NOOMP-NEXT:  entry:
 // NOOMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND:%.*]]
 // NOOMP:       for.cond:

 // NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
 // NOOMP-NEXT:    store i32 [[INC]], i32* [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP2:![0-9]+]]
 // NOOMP:       for.end:
 // NOOMP-NEXT:    call void @foo()
 // NOOMP-NEXT:    ret i32 0
 //
 //
-// NOOMP-LABEL: @foo(
+// NOOMP-LABEL: define {{[^@]+}}@foo(
 // NOOMP-NEXT:  entry:
 // NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND:%.*]]
 // NOOMP:       for.cond:
 // NOOMP-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
 // NOOMP-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], 33554432

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs.c.no-generated.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // Check that the CHECK lines are generated for clang-generated functions
 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck --check-prefix=NOOMP %s
 
 const int size = 1024 * 1024 * 32;
 
 double A[size];
 
 void foo(void);
 
-// OMP-LABEL: @main(
+// OMP-LABEL: define {{[^@]+}}@main(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
 // OMP-NEXT:    store i32 0, i32* [[I]], align 4
 // OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2:[0-9]+]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
 // OMP-NEXT:    call void @foo()
 // OMP-NEXT:    ret i32 0
 //
-// NOOMP-LABEL: @main(
+// NOOMP-LABEL: define {{[^@]+}}@main(
 // NOOMP-NEXT:  entry:
 // NOOMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND:%.*]]
 // NOOMP:       for.cond:
for (i = 0; i < size; ++i) {
     A[i] = 0.0;
   }
 
   foo();
 
   return 0;
 }
 
-// OMP-LABEL: @foo(
+// OMP-LABEL: define {{[^@]+}}@foo(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, i32* [[I]], align 4
 // OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 to void (i32*, i32*, ...)*))
 // OMP-NEXT:    ret void
 //
-// NOOMP-LABEL: @foo(
+// NOOMP-LABEL: define {{[^@]+}}@foo(
 // NOOMP-NEXT:  entry:
 // NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND:%.*]]
 // NOOMP:       for.cond:
 // NOOMP-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
 // NOOMP-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], 33554432

clang/test/utils/update_cc_test_checks/Inputs/global-hex-value-regex.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals --global-value-regex "foo\..*" "bar\..*" --global-hex-value-regex ".*\.hex"
 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
 //.
 // CHECK: @foo.hex = internal global i32 [[#0x10]], align 4
 // CHECK: @foo.dec = internal global i32 10, align 4
 // CHECK: @bar.hex = internal global i32 [[#0x20]], align 4
 // CHECK: @bar.dec = internal global i32 20, align 4
 //.
-// CHECK-LABEL: @foo(
+// CHECK-LABEL: define {{[^@]+}}@foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret void
 //
 void foo(void) {
   static int hex = 0x10;
   static int dec = 10;
 }
-// CHECK-LABEL: @bar(
+// CHECK-LABEL: define {{[^@]+}}@bar(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret void
 //
 void bar(void) {
   static int hex = 0x20;
   static int dec = 20;
 }

clang/test/utils/update_cc_test_checks/Inputs/global-value-regex.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals --global-value-regex "foo\.."
 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
 //.
 // CHECK: @foo.i = internal global i32 0, align 4
 // CHECK: @foo.j = internal global i32 0, align 4
 //.
-// CHECK-LABEL: @foo(
+// CHECK-LABEL: define {{[^@]+}}@foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret void
 //
 void foo(void) {
   static int i, j;
 }
-// CHECK-LABEL: @bar(
+// CHECK-LABEL: define {{[^@]+}}@bar(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret void
 //
 void bar(void) {
   static int i, j;
 }

clang/test/utils/update_cc_test_checks/Inputs/ifdef.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK %s
 // RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -DFOO | FileCheck -check-prefixes=CHECK,FOO %s
 
 #ifdef FOO
-// FOO-LABEL: @foo(
+// FOO-LABEL: define {{[^@]+}}@foo(
 // FOO-NEXT:  entry:
 // FOO-NEXT:    ret i32 1
 //
 int foo() {
   return 1;
 }
 #endif
 
-// CHECK-LABEL: @bar(
+// CHECK-LABEL: define {{[^@]+}}@bar(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret i32 2
 //
 int bar() {
   return 2;
 }

clang/test/utils/update_cc_test_checks/Inputs/mangled_names.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // Example input for update_cc_test_checks
 // RUN: %clang_cc1 -no-opaque-pointers -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
-// CHECK-LABEL: @test(
+// CHECK-LABEL: define {{[^@]+}}@test(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[B:%.*]], i32* [[B_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B_ADDR]], align 4
 // CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP1]] to i64
 // CHECK-NEXT:    [[ADD:%.*]] = add nsw i64 [[TMP0]], [[CONV]]
 // CHECK-NEXT:    ret i64 [[ADD]]
 //
 long test(long a, int b) {
   return a + b;
 }
 
 // A function with a mangled name
-// CHECK-LABEL: @_Z4testlii(
+// CHECK-LABEL: define {{[^@]+}}@_Z4testlii(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    [[C_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
 // CHECK-NEXT:    store i32 [[B:%.*]], i32* [[B_ADDR]], align 4
 // CHECK-NEXT:    store i32 [[C:%.*]], i32* [[C_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8

clang/test/utils/update_cc_test_checks/Inputs/on_the_fly_arg_change.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
-// CHECK-LABEL: @checks_please(
+// CHECK-LABEL: define {{[^@]+}}@checks_please(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret i32 1
 //
 int checks_please(void) {
   return 1;
 }
 
 // UTC_ARGS: --disable
 
 int no_checks_please(void) {
   // Manual CHECK line should be retained:
   // CHECK: manual check line
   return -1;
 }
 
 // UTC_ARGS: --enable
 
 
-// CHECK-LABEL: @checks_again(
+// CHECK-LABEL: define {{[^@]+}}@checks_again(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    ret i32 2
 //
 int checks_again(void) {
   return 2;
 }

clang/test/utils/update_cc_test_checks/Inputs/replace-value-regex-across-runs.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+"
 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -emit-llvm -o - %s | \
 // RUN:     FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -emit-llvm -o - %s | \
 // RUN:     FileCheck %s
 
-// CHECK-LABEL: @foo(
+// CHECK-LABEL: define {{[^@]+}}@foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_foo_l7() #[[ATTR2:[0-9]+]]
 // CHECK-NEXT:    ret void
 //
 void foo(void) {
   #pragma omp target
   ;
 }

clang/test/utils/update_cc_test_checks/check-globals.test

BOTH-EMPTY:
   IGF-NEXT:  static int i, j;
   IGF-NEXT:}
  BOTH-NEXT://.
  BOTH-NEXT:// CHECK: @foo.i = internal global i32 0, align 4
  BOTH-NEXT:// CHECK: @foo.j = internal global i32 0, align 4
  BOTH-NEXT:// CHECK: @bar.i = internal global i32 0, align 4
  BOTH-NEXT:// CHECK: @bar.j = internal global i32 0, align 4
  BOTH-NEXT://.
- BOTH-NEXT:// CHECK-LABEL: @foo(
+ BOTH-NEXT:// CHECK-LABEL: define {{.+}}@foo(
  BOTH-NEXT:// CHECK-NEXT:  entry:
  BOTH-NEXT:// CHECK-NEXT:    ret void
  BOTH-NEXT://
   NRM-NEXT:void foo(void) {
   NRM-NEXT:  static int i, j;
   NRM-NEXT:}
   IGF-NEXT://
- BOTH-NEXT:// CHECK-LABEL: @bar(
+ BOTH-NEXT:// CHECK-LABEL: define {{.+}}@bar(
  BOTH-NEXT:// CHECK-NEXT:  entry:
  BOTH-NEXT:// CHECK-NEXT:    ret void
  BOTH-NEXT://
   NRM-NEXT:void bar(void) {
   NRM-NEXT:  static int i, j;
   NRM-NEXT:}
  BOTH-NEXT://.
  BOTH-NEXT:// CHECK: attributes {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/argument_name_reuse.ll.plain.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -S | FileCheck %s
 
 define i32 @reuse_arg_names(i32 %X, i32 %Y) {
-; CHECK-LABEL: @reuse_arg_names(
+; CHECK-LABEL: define {{[^@]+}}@reuse_arg_names(
 ; CHECK-NEXT:    [[Z:%.*]] = sub i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[Q:%.*]] = add i32 [[Z]], [[Y]]
 ; CHECK-NEXT:    ret i32 [[Q]]
 ;
   %Z = sub i32 %X, %Y
   %Q = add i32 %Z, %Y
   ret i32 %Q
 }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/basic.ll.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Example input for update_test_checks (taken from test/Transforms/InstSimplify/add.ll)
 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
 
 define i32 @common_sub_operand(i32 %X, i32 %Y) {
-; CHECK-LABEL: @common_sub_operand(
+; CHECK-LABEL: define {{[^@]+}}@common_sub_operand(
 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %Z = sub i32 %X, %Y
   %Q = add i32 %Z, %Y
   ret i32 %Q
 }
 
 define i32 @negated_operand(i32 %x) {
-; CHECK-LABEL: @negated_operand(
+; CHECK-LABEL: define {{[^@]+}}@negated_operand(
 ; CHECK-NEXT:    ret i32 0
 ;
   %negx = sub i32 0, %x
   %r = add i32 %negx, %x
   ret i32 %r
 }
 
 define <2 x i32> @negated_operand_commute_vec(<2 x i32> %x) {
-; CHECK-LABEL: @negated_operand_commute_vec(
+; CHECK-LABEL: define {{[^@]+}}@negated_operand_commute_vec(
 ; CHECK-NEXT:    ret <2 x i32> zeroinitializer
 ;
   %negx = sub <2 x i32> zeroinitializer, %x
   %r = add <2 x i32> %x, %negx
   ret <2 x i32> %r
 }
 
 define i8 @knownnegation(i8 %x, i8 %y) {
-; CHECK-LABEL: @knownnegation(
+; CHECK-LABEL: define {{[^@]+}}@knownnegation(
 ; CHECK-NEXT:    ret i8 0
 ;
   %xy = sub i8 %x, %y
   %yx = sub i8 %y, %x
   %r = add i8 %xy, %yx
   ret i8 %r
 }
 
 define <2 x i8> @knownnegation_commute_vec(<2 x i8> %x, <2 x i8> %y) {
-; CHECK-LABEL: @knownnegation_commute_vec(
+; CHECK-LABEL: define {{[^@]+}}@knownnegation_commute_vec(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %xy = sub <2 x i8> %x, %y
   %yx = sub <2 x i8> %y, %x
   %r = add <2 x i8> %yx, %xy
   ret <2 x i8> %r
 }
 
 define i32 @nameless_value(i32 %X) {
-; CHECK-LABEL: @nameless_value(
+; CHECK-LABEL: define {{[^@]+}}@nameless_value(
 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 42, [[X:%.*]]
 ; CHECK-NEXT:    ret i32 [[TMP1]]
 ;
   %1 = sub i32 42, %X
   ret i32 %1
 }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/custom-tool.ll.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --tool llvm-extract
 ; RUN: llvm-extract -S --func=foo %s | FileCheck --check-prefixes=CHECK %s
 
 define i32 @foo(i32 %x) {
-; CHECK-LABEL: @foo(
+; CHECK-LABEL: define {{[^@]+}}@foo(
 ; CHECK-NEXT:    [[Y:%.*]] = add i32 [[X:%.*]], 1
 ; CHECK-NEXT:    ret i32 [[Y]]
 ;
   %y = add i32 %x, 1
   ret i32 %y
 }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/define_after_call.ll

+; RUN: opt < %s -S | FileCheck %s
+
+define i32 @a() {
+  %val = call i32 @b(i32 0)
+  ret i32 %val
+}
+
+define i32 @b(i32 %arg) {
+  ret i32 %arg
+}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/define_after_call.ll.expected

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -S | FileCheck %s
+
+define i32 @a() {
+; CHECK-LABEL: define {{[^@]+}}@a(
+; CHECK-NEXT:    [[VAL:%.*]] = call i32 @b(i32 0)
+; CHECK-NEXT:    ret i32 [[VAL]]
+;
+  %val = call i32 @b(i32 0)
+  ret i32 %val
+}
+
+define i32 @b(i32 %arg) {
+; CHECK-LABEL: define {{[^@]+}}@b(
+; CHECK-NEXT:    ret i32 [[ARG:%.*]]
+;
+  ret i32 %arg
+}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll.generated.expected

sink:
   unreachable
 
 exit:
   ret void
 }
 
 declare void @llvm.trap() noreturn cold
 declare void @_Z10sideeffectv()
-; CHECK-LABEL: @foo(
+; CHECK-LABEL: define {{[^@]+}}@foo(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 ;
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 ;
-; CHECK-LABEL: @foo.cold.1(
+; CHECK-LABEL: define {{[^@]+}}@foo.cold.1(
 ; CHECK-NEXT:  newFuncRoot:
 ; CHECK-NEXT:    br label [[SINK:%.*]]
 ; CHECK:       sink:
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    call void @llvm.trap()
 ; CHECK-NEXT:    unreachable
 ;
 ;
-; CHECK-LABEL: @bar.cold.1(
+; CHECK-LABEL: define {{[^@]+}}@bar.cold.1(
 ; CHECK-NEXT:  newFuncRoot:
 ; CHECK-NEXT:    br label [[SINK:%.*]]
 ; CHECK:       sink:
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    call void @llvm.trap()
 ; CHECK-NEXT:    unreachable
 ;

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll.generated.globals.expected

exit:
   ret void
 }
 
 declare void @llvm.trap() noreturn cold
 declare void @_Z10sideeffectv()
 ;.
 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external dso_local global i32, align 4
 ;.
-; CHECK-LABEL: @foo(
+; CHECK-LABEL: define {{[^@]+}}@foo(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 ;
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 ;
-; CHECK-LABEL: @foo.cold.1(
+; CHECK-LABEL: define {{[^@]+}}@foo.cold.1(
 ; CHECK-NEXT:  newFuncRoot:
 ; CHECK-NEXT:    br label [[SINK:%.*]]
 ; CHECK:       sink:
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    call void @llvm.trap()
 ; CHECK-NEXT:    unreachable
 ;
 ;
-; CHECK-LABEL: @bar.cold.1(
+; CHECK-LABEL: define {{[^@]+}}@bar.cold.1(
 ; CHECK-NEXT:  newFuncRoot:
 ; CHECK-NEXT:    br label [[SINK:%.*]]
 ; CHECK:       sink:
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    call void @llvm.trap()
 ; CHECK-NEXT:    unreachable
 ;
 ;.
 ; CHECK: attributes #[[ATTR0:[0-9]+]] = { cold noreturn nounwind }
 ; CHECK: attributes #[[ATTR1:[0-9]+]] = { cold minsize noreturn }
 ; CHECK: attributes #[[ATTR2]] = { noinline }
 ;.

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll.nogenerated.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 @G = external dso_local global i32, align 4
 
 define void @foo(i32) {
-; CHECK-LABEL: @foo(
+; CHECK-LABEL: define {{[^@]+}}@foo(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 define void @bar(i32) {
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs.ll.nogenerated.globals.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 @G = external dso_local global i32, align 4
 
 ;.
 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external dso_local global i32, align 4
 ;.
 define void @foo(i32) {
-; CHECK-LABEL: @foo(
+; CHECK-LABEL: define {{[^@]+}}@foo(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 define void @bar(i32) {
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    tail call void @_Z10sideeffectv()
 ; CHECK-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; CHECK:       codeRepl:
 ; CHECK-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs_prefix_reuse.ll.generated.expected

sink:
   unreachable
 
 exit:
   ret void
 }
 
 declare void @llvm.trap() noreturn cold
 declare void @_Z10sideeffectv()
-; REUSE-LABEL: @foo(
+; REUSE-LABEL: define {{[^@]+}}@foo(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void
 ;
 ;
-; REUSE-LABEL: @bar(
+; REUSE-LABEL: define {{[^@]+}}@bar(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void
 ;
 ;
-; REUSE-LABEL: @foo.cold.1(
+; REUSE-LABEL: define {{[^@]+}}@foo.cold.1(
 ; REUSE-NEXT:  newFuncRoot:
 ; REUSE-NEXT:    br label [[SINK:%.*]]
 ; REUSE:       sink:
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    call void @llvm.trap()
 ; REUSE-NEXT:    unreachable
 ;
 ;
-; REUSE-LABEL: @bar.cold.1(
+; REUSE-LABEL: define {{[^@]+}}@bar.cold.1(
 ; REUSE-NEXT:  newFuncRoot:
 ; REUSE-NEXT:    br label [[SINK:%.*]]
 ; REUSE:       sink:
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    call void @llvm.trap()
 ; REUSE-NEXT:    unreachable
 ;

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs_prefix_reuse.ll.generated.globals.expected

exit:
   ret void
 }
 
 declare void @llvm.trap() noreturn cold
 declare void @_Z10sideeffectv()
 ;.
 ; REUSE: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external dso_local global i32, align 4
 ;.
-; REUSE-LABEL: @foo(
+; REUSE-LABEL: define {{[^@]+}}@foo(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void
 ;
 ;
-; REUSE-LABEL: @bar(
+; REUSE-LABEL: define {{[^@]+}}@bar(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void
 ;
 ;
-; REUSE-LABEL: @foo.cold.1(
+; REUSE-LABEL: define {{[^@]+}}@foo.cold.1(
 ; REUSE-NEXT:  newFuncRoot:
 ; REUSE-NEXT:    br label [[SINK:%.*]]
 ; REUSE:       sink:
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    call void @llvm.trap()
 ; REUSE-NEXT:    unreachable
 ;
 ;
-; REUSE-LABEL: @bar.cold.1(
+; REUSE-LABEL: define {{[^@]+}}@bar.cold.1(
 ; REUSE-NEXT:  newFuncRoot:
 ; REUSE-NEXT:    br label [[SINK:%.*]]
 ; REUSE:       sink:
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    call void @llvm.trap()
 ; REUSE-NEXT:    unreachable
 ;
 ;.
 ; REUSE: attributes #[[ATTR0:[0-9]+]] = { cold noreturn nounwind }
 ; REUSE: attributes #[[ATTR1:[0-9]+]] = { cold minsize noreturn }
 ; REUSE: attributes #[[ATTR2]] = { noinline }
 ;.

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs_prefix_reuse.ll.nogenerated.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s --check-prefix=REUSE
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s --check-prefix=REUSE
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 @G = external dso_local global i32, align 4
 
 define void @foo(i32) {
-; REUSE-LABEL: @foo(
+; REUSE-LABEL: define {{[^@]+}}@foo(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void
 ;
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 define void @bar(i32) {
-; REUSE-LABEL: @bar(
+; REUSE-LABEL: define {{[^@]+}}@bar(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/generated_funcs_prefix_reuse.ll.nogenerated.globals.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s --check-prefix=REUSE
 ; RUN: opt -passes=hotcoldsplit -hotcoldsplit-threshold=0 -S < %s | FileCheck %s --check-prefix=REUSE
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.14.0"
 
 @G = external dso_local global i32, align 4
 
 ;.
 ; REUSE: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external dso_local global i32, align 4
 ;.
 define void @foo(i32) {
-; REUSE-LABEL: @foo(
+; REUSE-LABEL: define {{[^@]+}}@foo(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @foo.cold.1() #[[ATTR2:[0-9]+]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void
 ;
   %2 = icmp eq i32 %0, 0
   tail call void @_Z10sideeffectv()
   br i1 %2, label %sink, label %exit
 
 sink:
   tail call void @_Z10sideeffectv()
   call void @llvm.trap()
   unreachable
 
 exit:
   ret void
 }
 
 define void @bar(i32) {
-; REUSE-LABEL: @bar(
+; REUSE-LABEL: define {{[^@]+}}@bar(
 ; REUSE-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[TMP0:%.*]], 0
 ; REUSE-NEXT:    tail call void @_Z10sideeffectv()
 ; REUSE-NEXT:    br i1 [[TMP2]], label [[CODEREPL:%.*]], label [[EXIT:%.*]]
 ; REUSE:       codeRepl:
 ; REUSE-NEXT:    call void @bar.cold.1() #[[ATTR2]]
 ; REUSE-NEXT:    ret void
 ; REUSE:       exit:
 ; REUSE-NEXT:    ret void

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/scrub_attrs.ll.plain.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S < %s | FileCheck %s
 
 declare void @foo()
 
 define internal void @bar() {
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:    call void @foo() #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ;
   call void @foo() readnone
   ret void
 }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/scrub_attrs.ll.scrub.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --scrub-attributes
 ; RUN: opt -S < %s | FileCheck %s
 
 declare void @foo()
 
 define internal void @bar() {
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    ret void
 ;
   call void @foo() readnone
   ret void
 }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/sometimes_deleted_function.ll.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S < %s | FileCheck %s --check-prefixes=ALL,ALL_BUT_TWO,ALL_BUT_THREE,ALL_BUT_FOUR,ONE_AND_TWO,ONE_AND_THREE,ONE_AND_FOUR,ONE
 ; RUN: opt -S -passes=globalopt < %s | FileCheck %s --check-prefixes=ALL,ALL_BUT_ONE,ALL_BUT_THREE,ALL_BUT_FOUR,ONE_AND_TWO,TWO_AND_THREE,TWO_AND_FOUR,TWO
 ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s --check-prefixes=ALL,ALL_BUT_ONE,ALL_BUT_TWO,ALL_BUT_FOUR,ONE_AND_THREE,TWO_AND_THREE,THREE_AND_FOUR,THREE
 ; RUN: opt -S < %s | FileCheck %s --check-prefixes=ALL,ALL_BUT_ONE,ALL_BUT_TWO,ALL_BUT_THREE,ONE_AND_FOUR,TWO_AND_FOUR,THREE_AND_FOUR,FOUR
 ;
 ; Make sure we don't use anything to check for @sometimes_here that contains "ALL" or "TWO".
 ; Also verify we use "ONE_AND_FOUR" for the unmodified @sometimes_here version and "THREE" for the version without the add.
 
 define internal void @sometimes_here() {
-; ONE_AND_FOUR-LABEL: @sometimes_here(
+; ONE_AND_FOUR-LABEL: define {{[^@]+}}@sometimes_here(
 ; ONE_AND_FOUR-NEXT:    [[C:%.*]] = add i32 undef, undef
 ; ONE_AND_FOUR-NEXT:    ret void
 ;
-; THREE-LABEL: @sometimes_here(
+; THREE-LABEL: define {{[^@]+}}@sometimes_here(
 ; THREE-NEXT:    ret void
 ;
   %c = add i32 undef, undef
   ret void
 }
 
 define void @always_here() {
-; ALL-LABEL: @always_here(
+; ALL-LABEL: define {{[^@]+}}@always_here(
 ; ALL-NEXT:    ret void
 ;
   ret void
 }
 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 ; ALL_BUT_FOUR: {{.*}}
 ; ALL_BUT_ONE: {{.*}}
 ; ALL_BUT_THREE: {{.*}}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/various_ir_values.ll.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Just run it through opt, no passes needed.
 ; RUN: opt < %s -S | FileCheck %s
 
 ; ModuleID = 'various_ir_values.c'
 source_filename = "various_ir_values.c"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define dso_local void @foo(i32* %A) #0 !dbg !7 {
-; CHECK-LABEL: @foo(
+; CHECK-LABEL: define {{[^@]+}}@foo(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32*, align 8
 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32* [[A:%.*]], i32** [[A_ADDR]], align 8, !tbaa [[TBAA16:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32** [[A_ADDR]], metadata [[META13:![0-9]+]], metadata !DIExpression()), !dbg [[DBG20:![0-9]+]]
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[I]] to i8*, !dbg [[DBG21:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* [[TMP0]]) #[[ATTR3:[0-9]+]], !dbg [[DBG21]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32* [[I]], metadata [[META14:![0-9]+]], metadata !DIExpression()), !dbg [[DBG22:![0-9]+]]

 ; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #2
 
 ; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #2
 
 ; Function Attrs: nounwind uwtable
 define dso_local void @bar(i32* %A) #0 !dbg !39 {
-; CHECK-LABEL: @bar(
+; CHECK-LABEL: define {{[^@]+}}@bar(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32*, align 8
 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32* [[A:%.*]], i32** [[A_ADDR]], align 8, !tbaa [[TBAA16]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32** [[A_ADDR]], metadata [[META42:![0-9]+]], metadata !DIExpression()), !dbg [[DBG45:![0-9]+]]
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[I]] to i8*, !dbg [[DBG46:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* [[TMP0]]) #[[ATTR3]], !dbg [[DBG46]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32* [[I]], metadata [[META43:![0-9]+]], metadata !DIExpression()), !dbg [[DBG47:![0-9]+]]

llvm/test/tools/UpdateTestChecks/update_test_checks/define_after_call.test

+# Verify that calls and defines of the same function can be mixed
+# RUN: cp -f %S/Inputs/define_after_call.ll %t.ll && %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/define_after_call.ll.expected
+# RUN: opt < %t.ll -S | FileCheck %t.ll

llvm/utils/UpdateTestChecks/common.py

for checkprefix in checkprefixes:
           global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
       break
   return printed_prefixes
 
 def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
                   func_name, preserve_names, function_sig,
                   global_vars_seen_dict, is_filtered):
   # Label format is based on IR string.
-  function_def_regex = 'define {{[^@]+}}' if function_sig else ''
+  function_def_regex = 'define {{[^@]+}}'
   check_label_format = '{} %s-LABEL: {}@%s%s%s'.format(comment_marker, function_def_regex)
   return add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
                     check_label_format, False, preserve_names, global_vars_seen_dict,
                     is_filtered)
 
 def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, is_filtered):
   check_label_format = '{} %s-LABEL: \'%s%s%s\''.format(comment_marker)
   global_vars_seen_dict = {}