[UTC] Add fallback support for specific metadata, and check their defs

[hnrklssn]

Summary

This prevents update_cc_tests.py from emitting hard-coded identifiers
for metadata (global variable checkers still check hard-coded
identifiers). Instead it emits regex checkers that match even if the
identifiers change. Also adds a new mode for --check-globals: instead of
simply being on or off, it now has the options 'none', 'smart' and
'all', with 'none' and 'all' corresponding to the previous modes.

The 'smart' mode only emits checks for global definitions referenced
in the IR or other metadata that itself has a definition checker
emitted, making the rule transitive. It does not emit checks for
attribute sets, since that is better checked by --check-attributes. This
mode is made the new default. To make the change in default mode
backwards compatible a version bump is introduced (to v3), and the
default remains 'none' in v1 & v2.

This will result in metadata checks being emitted more often, so filters
are added to not check absolute file paths and compiler version git
hashes.

rdar://105239218

[hnrklssn]

I'm not familiar with any upstream ways to trigger !annotations so I unfortunately don't have any test updates to upstream at this time. I'm open to suggestions for adding ways to test the change though.

[arichardson]

Change looks good to me, but if clang can't emit these yet we should probably wait until committing this? Do you have a link to a review that uses this metadata?

[nikic]

We should probably just use the META fallback for all metadata not already explicitly handled. I think there's pretty little value in adding a special name for each metadata kind.

[hnrklssn]

Add test case emitting !annotation from clang.
Make annotation matching a generic metadata fallback.

[hnrklssn]

In D148216#4266174, @arichardson wrote:

Change looks good to me, but if clang can't emit these yet we should probably wait until committing this? Do you have a link to a review that uses this metadata?

It can emit them, we just use them a bit more frequently downstream. I've found an example and added a lit test as an example of how it works.

[hnrklssn]

In D148216#4266201, @nikic wrote:

We should probably just use the META fallback for all metadata not already explicitly handled. I think there's pretty little value in adding a special name for each metadata kind.

I added a fallback, and some logic to extract the metadata kind name from the IR, because I do find it useful to emit checks named after the type of IR they match against.

[delcypher]

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

13

@hnrklssn I just noticed we don't have a CHECK for what META2 actually refers to. Should we?

Not something that has to be fixed in this patch, more just an observation.

llvm/utils/UpdateTestChecks/common.py

873–874

Is this call to re.search(...) guaranteed to always succeed?

978

There may be some value in having !annotations matched explicitly as well as there being a fallback. In the current patch it looks like:

• metadata is assigned variables with the META prefix on CHECK lines
• !annotation is assigned variables with the META prefix on CHECK lines
• Anything else that matches r'![a-z.]+ ' is assigned variables with the META prefix on CHECK lines

When looking a large test having everything lumped into META variables could make the generated tests a little harder to read.

[hnrklssn]

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

13

Indeed this is true for metadata in general, presumably because the RHS often refer to things like other metadata identifiers. In the case of annotations they seem to always refer to simple strings however, so it would be feasible to do a straight match without having to do recursive matching or complex regexes to determine which part of the metadata to match against.

In many cases with metadata attached to IR nodes, multiple nodes refer to the same metadata node, so at least you verify that they still are consistent. But I agree that verifying the content would be a great future addition.

llvm/utils/UpdateTestChecks/common.py

873–874

Yes. match is a match object from a combined regex concatenated from both the IR prefix (![a-z.]+ ) and the IR regexp (![0-9]+), so it will always contain a substring matching the IR prefix.

978

In a way, yes. At the same time, since we're not matching against the definition of the metadata node, all uses (while named META#) will still be prefixed by !annotation. On the other hand again, we have explicitly enumerated so many other types of metadata, so it is a bit inconsistent.

[nikic]

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

13

You need to pass --check-globals to check the actual metadata.

[hnrklssn]

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

13

When I add that to this test case it adds

//.
// CHECK: attributes #0 = { noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
//.
// CHECK: !0 = !{i32 1, !"wchar_size", i32 4}
// CHECK: !1 = !{!"clang version 17.0.0 ([e-mail]:llvm/llvm-project.git 684914f47cf59e9ab6d8b0f73c58ca6272ea28d4)"}
// CHECK: !2 = !{!"auto-init"}
//.

So it seems to just be doing a simple literal matching on all metadata, regardless of whether we captured that metadata in any filecheck variable. And it still doesn't use the META2 variable to match the definition. Am I missing something? If we use the literal metadata names instead of variable matching for the definitions, there isn't much point in doing variable matching for the metadata uses either, since the test still very much relies on the metadata numbering being stable.

[hnrklssn]

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

13

@nikic Do you have more information to add about how metadata definition matchers can be generated without hardcoding everything (which is kind of the opposite of what this patch is trying to do), or in general if you're happy with the state of the PR?

[nikic]

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

13

This works fine with update_test_checks, so it must be some bug in update_cc_test_checks in particular. From a quick look, I suspect it's because https://github.com/llvm/llvm-project/blob/3d05ab6d3e24e76ff53b8d7d623c436b4be5b809/llvm/utils/update_cc_test_checks.py#L447 hardcodes a True value, while update_test_checks makes this dependent on --preserve-names, which is disabled by default there.

[nikic]

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

13

Or maybe just test this with update_test_checks? This change is valuable for that script as well, and it doesn't have this extra issue.

[hnrklssn]

Overhauled how update_cc_tests.py checks globals

It now:

• no longer matches the literal names, like update_test_checks.py does unless --preserve-names (which doesn't seem to see much use, at least not upstream, so did not add option to update_cc_tests.py) is set
• (along with update_test_checks.py) now adds checks for any definitions of globals referenced in the IR (by default, can still check all globals using "--check-globals all")
• (along with update_test_checks.py) can also be configured to emit checks for any definitions of globals referenced by other globals referenced in the IR, using "--check-globals transitive"
• (along with update_test_checks.py) filters out unstable metadata output, so that literal directory names and git hashes are not matched against

[hnrklssn]

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

13

I couldn't find any uses of
--preserve-names in the entire repo (not even in tests for update_test_checks), so I went ahead and changed update_cc_test_checks to pass True instead.

While at it I added 2 new options to match some, but not necessarily all, globals. I set the least verbose one (other than "none") as the default, emitting checks for the definitions of all globals that we emit matches for in the IR. Do you agree that this is reasonable?

[nikic]

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

13

That sounds like a nice approach. My main question would be whether --check-globals seen is the right default: My gut feeling here is that this will introduce additional checks for attributes/metadata in tests that don't actually care about it, but I'm not particularly sure about that.

You might want to do some mass test regeneration and take a look over the diff to see how useful the changes would be.

If we do change the default, the default change likely need to be part of --version 3 to avoid substantial test churn.

[hnrklssn]

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

13

I've regenerated checks before and after my patch and compared them. Some findings:

• there's a surprising number of custom metadata types that didn't get variable checkers but instead checked hardcoded metadata IDs (!sloc, !pcsections, !alias.scope, !noalias, !nonnull, !noundef, !dereferenceable, !nontemporal, !fpmath etc.). The tests often have checkers, but were removed when regenerating them before my patch, so something seems to have broken.
• I'm split on whether global variables should match the exact name or get a matcher. Right now the patch handles them like any other global, but I'm assuming that the name actually carries significance for linking?
• matching attributes seems useful in some cases, not matter too much in others, but often there aren't that many attributes so it does not pollute much. Tests where attribute matchers pollute should probably use --scrub-attributes in update_check_tests (does not exist in update_cc_check_tests) anyways
• tests that include debug info generally do so deliberately, so matching against that seems reasonable
• TBAA metadata doesn't give too much insight unless transitive/all. That said not all TBAA tests check metadata at all today (at least not llvm/test/Transforms/ArgumentPromotion/reserve-tbaa.ll)
• Similar goes for !llvm.loop, the useful info is pointed to indirectly
• Profile info doesn't seem to be included very often. It's probably reasonable to match against it when it's there. Found one test that was specifically created to check profile info metadata but lost the check during conversion to update_check_tests (llvm/test/Transforms/ArgumentPromotion/profile.ll)

Since the transitive setting provides substantially more insight than the seen setting for loop and tbaa, and only really explodes for debug info (which is rarely included, and deliberately so when done) I'm open to making it the default instead. For opt based tests I kind of think that all should be the default since any metadata in the output was either created by the tested passes, or explicitly included in the input.

[nikic]

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

13

I've regenerated checks before and after my patch and compared them. Some findings:

• there's a surprising number of custom metadata types that didn't get variable checkers but instead checked hardcoded metadata IDs (!sloc, !pcsections, !alias.scope, !noalias, !nonnull, !noundef, !dereferenceable, !nontemporal, !fpmath etc.). The tests often have checkers, but were removed when regenerating them before my patch, so something seems to have broken.

Yes, which is why I'm happy to have the generic implementation here -- many of these were handled by manually adjusting the update_test_checks output...

• I'm split on whether global variables should match the exact name or get a matcher. Right now the patch handles them like any other global, but I'm assuming that the name actually carries significance for linking?

I'm thinking we should probably retain the name of globals, the same way we do for functions. Unlike things like local variable names, and attribute/metadata IDs, these tend to be stable and semantically meaningful. (Also the wildcard generated for them breaks syntax highlighting in vim. Grumble, grumble.)

• matching attributes seems useful in some cases, not matter too much in others, but often there aren't that many attributes so it does not pollute much. Tests where attribute matchers pollute should probably use --scrub-attributes in update_check_tests (does not exist in update_cc_check_tests) anyways
• tests that include debug info generally do so deliberately, so matching against that seems reasonable
• TBAA metadata doesn't give too much insight unless transitive/all. That said not all TBAA tests check metadata at all today (at least not llvm/test/Transforms/ArgumentPromotion/reserve-tbaa.ll)
• Similar goes for !llvm.loop, the useful info is pointed to indirectly
• Profile info doesn't seem to be included very often. It's probably reasonable to match against it when it's there. Found one test that was specifically created to check profile info metadata but lost the check during conversion to update_check_tests (llvm/test/Transforms/ArgumentPromotion/profile.ll)

Since the transitive setting provides substantially more insight than the seen setting for loop and tbaa, and only really explodes for debug info (which is rarely included, and deliberately so when done) I'm open to making it the default instead. For opt based tests I kind of think that all should be the default since any metadata in the output was either created by the tested passes, or explicitly included in the input.

I think there's broadly two cases:

1. There are globals/attributes/metadata in the input, which are needed to make the test work, but not important for the test output, because they will just be preserved. E.g. an InstSimplify test might use globals/attributes/metadata, but won't ever change them, and checking that fact is not particularly useful.

2. Tests for passes that do modify/add attributes/metadata, such as IPO inference passes. It's worth noting that there is a separate --check-attributes flag that covers some of these cases, which will match the attributes printed before the function definition, which is generally more convenient than matching the attributes at the end of the module.

The first the use case we generally do not want to match any globals, and for the latter we probably want either --check-attributes (if testing function attributes in particular) or --check-globals transitive (if testing something metadata or call-site attributes).

I'm still not really sure what the right default would be. I guess one could argue that for the former case, having a few extra attributes at the test isn't a big deal -- one can just ignore them. But that does also mean that whenever we for example change attributes on an intrinsic, this will now suddenly affect hundreds of tests that encode those attributes.

[hnrklssn]

Revert checker behaviour for global variables to check hard-coded identifiers
Remove 'seen' mode
Replace 'transitive' mode with 'smart', where attributes are no longer checked as metadata
Introduce version bump to v3, and make 'smart' mode the default in v3

[hnrklssn]

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

13

I replaced --checked-globals transitive with --checked-globals smart, with the addition that it doesn't check attributes, and made it the default mode in the new version 3. If attributes need to be checked --check-attributes can be used, or --check-globals all.

Emitting checks for metadata that hasn't been changed by the passes when testing with opt may result in some extra noise in the test, but is unlikely to result in significant extra work to maintain, since if the metadata format for that metadata kind changes, the metadata input needs to change also. For test cases where it adds significant noise --check-globals none is always an option.

Also reverted the behaviour for global variables to check the exact identifier again.

[hnrklssn]

@nikic Did you have a look at the new patch?

[hnrklssn]

@nikic Ping :)

[nikic]

Could you please rebase the patch to current main? I wasn't able to apply it.

The behavior you describe sounds reasonable to me.

llvm/utils/UpdateTestChecks/common.py

1710

We should also not print the all argument for --check-globals argument for version < 3, otherwise that will introduce a spurious change in all such tests.

[jdoerfert]

could you put a little more information in the commit message please. "It won't do X when we do Y", could mean a lot of things. We don't do Y anymore, or we do X' now, with various choices for X'.

[hnrklssn]

Rebase after reformatting with Black, update commit message

[hnrklssn]

In D148216#4431456, @jdoerfert wrote:

could you put a little more information in the commit message please. "It won't do X when we do Y", could mean a lot of things. We don't do Y anymore, or we do X' now, with various choices for X'.

I've updated the commit message to clarify what it means to not emit hardcoded identifiers, and that we instead emit regex checkers. Was that what you were aiming for, or are there other parts that you would like me to clarify?

llvm/utils/UpdateTestChecks/common.py

1710

I don't know how to dynamically change the --check-globals option between store_true and choices, since the behaviour can itself be affected by which argument is passed to the --version option. So the way I see it there's no way of knowing how to parse between two different option types ahead of time. For the default when no option is specified the parsing is the same however, so we can simply infer later what option is implied based on the version.

[nikic]

llvm/utils/UpdateTestChecks/common.py

1710

It's not necessary to change the option, just how it is printed. I.e. add something like this:

if args.version < 3 and value == "all":
    # Don't include argument value in older versions.
    autogenerated_note_args += "--check-globals "
    continue

[nikic]

llvm/utils/UpdateTestChecks/common.py

1710

Ah, I get what you're saying now -- old UTC_ARGS are not accepted at all anymore, and trying to update existing tests will just fail with an error!

We do need old UTC_ARGS to work. I think you can make the argument value optional using these options:

nargs="?", 
const="default",
default="default",
choices=["none", "smart", "all", "default"],

Or possibly omit const/default and handle None instead.

[nikic]

llvm/utils/UpdateTestChecks/common.py

1710

Correction, I think the right options are:

nargs="?",
const="all",
default="default",
choices=["none", "smart", "all"],

That is, use "default" is it's not specified at all, use "all" if only --check-globals is passed and also accept --check-globals none|smart|all.

[hnrklssn]

Keep supporting --check-globals without explicit level as meaning '--check-globals all'

[hnrklssn]

llvm/utils/UpdateTestChecks/common.py

1710

Ah nice, I did not expect the library to support this use case!

[nikic]

There are some test failures.

I believe there is one bug with the handling of unnamed globals. Previously we produced this:

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals --version 2
; RUN: opt -S < %s | FileCheck %s
@0 = global i32 0

;.
; CHECK: @[[GLOB0:[0-9]+]] = global i32 0
;.
define i32 @test() {
; CHECK-LABEL: define i32 @test() {
; CHECK-NEXT:    [[V:%.*]] = load i32, ptr @[[GLOB0]], align 4
; CHECK-NEXT:    ret i32 [[V]]
;
  %v = load i32, ptr @0
  ret i32 %v
}

And now we instead check CHECK: @0 = global i32 0, so there is a mismatch between definition and use. I believe it does make sense to keep the wildcard names for unnamed globals.

On the same test case, if I keep rerunning update_test_checks on the same file, it keeps adding extra CHECK: @0 = global i32 0 lines at the start (before the first ;.. That didn't happen previously.

clang/test/utils/update_cc_test_checks/Inputs/annotations.c

2

It would be more typical to pass --version 3 when calling update_cc_test_checks. (Note that this is only a quirk of the test setup. Outside tests the --version 3 is implied for new tests.)

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/check_attrs.ll.funcattrs.expected

9 ↗

(On Diff #532719)

Huh, where does this change come from?

llvm/utils/UpdateTestChecks/common.py

1016

Does this still comply with the formatter?

[hnrklssn]

Added back regex matchers for anonymous global values

[hnrklssn]

In D148216#4434171, @nikic wrote:

There are some test failures.

I believe there is one bug with the handling of unnamed globals. Previously we produced this:

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals --version 2
; RUN: opt -S < %s | FileCheck %s
@0 = global i32 0

;.
; CHECK: @[[GLOB0:[0-9]+]] = global i32 0
;.
define i32 @test() {
; CHECK-LABEL: define i32 @test() {
; CHECK-NEXT:    [[V:%.*]] = load i32, ptr @[[GLOB0]], align 4
; CHECK-NEXT:    ret i32 [[V]]
;
  %v = load i32, ptr @0
  ret i32 %v
}

And now we instead check CHECK: @0 = global i32 0, so there is a mismatch between definition and use. I believe it does make sense to keep the wildcard names for unnamed globals.

On the same test case, if I keep rerunning update_test_checks on the same file, it keeps adding extra CHECK: @0 = global i32 0 lines at the start (before the first ;.. That didn't happen previously.

Fixed. Does this test case exist somewhere? I couldn't find it upstream.

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/check_attrs.ll.funcattrs.expected

9 ↗

(On Diff #532719)

I thought it was an existing test failure upstream, but it seems to have disappeared after doing a full rebuild clang+llvm.

llvm/utils/UpdateTestChecks/common.py

1016

No, I guess maintaining this structure isn't worth it long term with the autoformatter

[hnrklssn]

@nikic Ping :)

[hnrklssn]

@nikic Are you happy with the current patchset?

[nikic]

LGTM

Fixed. Does this test case exist somewhere? I couldn't find it upstream.

That wasn't an existing test case. Though if you add a --check-globals all variant to generated-funcs.c, I believe that would cover that case.

[hnrklssn]

Add unnamed global test case

Added cases in generated-funcs.c with --check-globals all, testing that named and unnamed globals are matched differently.

[nikic]

(The patch description could use an update...)

[hnrklssn]

Update test cases after rebasing on ToT

[jdoerfert]

When you commit things, can you please add the Differential Revision into the commit message so it is closed here and we can easily find the review for a change.

Committed as 8a3fdf7b908978625e9a7e57fbb443e4e6f98976.

[jdoerfert]

This is broken: https://github.com/llvm/llvm-project/issues/63746

[jdoerfert]

I might pull this later today until a fix is available. It makes updates of files with globals super cumbersome (you need to manually remove the duplicates).

[jdoerfert]

In D148216#4486400, @jdoerfert wrote:

I might pull this later today until a fix is available. It makes updates of files with globals super cumbersome (you need to manually remove the duplicates).

FWIW, the duplication happens if you pass -p already. It's an existing problem made worse by effectively forcing -p for globals.

clang/test/utils/update_cc_test_checks/Inputs/annotations.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=zero %s -emit-llvm -o - | FileCheck %s
+
+int foo() {
+    int x = x + 1;
+    return x;
+}

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

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// UTC_ARGS: --version 3
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=zero %s -emit-llvm -o - | FileCheck %s
+
+// CHECK-LABEL: define @foo(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[X:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i32 0, ptr [[X]], align 4, !annotation [[META2:![0-9]+]]
+// CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X]], align 4
+// CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP0]], 1
+// CHECK-NEXT:    store i32 [[ADD]], ptr [[X]], align 4
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X]], align 4
+// CHECK-NEXT:    ret i32 [[TMP1]]
+//
+int foo() {
+    int x = x + 1;
+    return x;
+}
+//.
+// CHECK: [[META2]] = !{!"auto-init"}
+//.

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

-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals --include-generated-funcs
 // Check that the CHECK lines are generated for clang-generated functions
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
 // RUN: %clang_cc1 -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) {
   int i = 0;
 
 #pragma omp parallel for
   for (i = 0; i < size; ++i) {
     A[i] = 1.0;
   }
 }
+//.
+// OMP: @[[GLOB0:[0-9]+]] = private unnamed_addr constant [23 x i8] c"
+// OMP: @[[GLOB1:[0-9]+]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 514, i32 0, i32 22, ptr @[[GLOB0]] }, align 8
+// OMP: @[[GLOB2:[0-9]+]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @[[GLOB0]] }, align 8
+//.
+// OMP: @A = global [33554432 x double] zeroinitializer, align 16
+// OMP: @size = constant i32 33554432, align 4
+//.
+// NOOMP: @size = constant i32 33554432, align 4
+// NOOMP: @A = global [33554432 x double] zeroinitializer, align 16
+//.
 // OMP-LABEL: @main(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, ptr [[RETVAL]], align 4
 // OMP-NEXT:    store i32 0, ptr [[I]], align 4
-// OMP-NEXT:    call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @[[GLOB2:[0-9]+]], i32 0, ptr @main.omp_outlined)
+// OMP-NEXT:    call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @[[GLOB2]], i32 0, ptr @main.omp_outlined)
 // OMP-NEXT:    call void @foo()
 // OMP-NEXT:    ret i32 0
 //
 //
 // OMP-LABEL: @main.omp_outlined(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca ptr, align 8
 // OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca ptr, 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:    [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store ptr [[DOTGLOBAL_TID_:%.*]], ptr [[DOTGLOBAL_TID__ADDR]], align 8
 // OMP-NEXT:    store ptr [[DOTBOUND_TID_:%.*]], ptr [[DOTBOUND_TID__ADDR]], align 8
 // OMP-NEXT:    store i32 0, ptr [[DOTOMP_LB]], align 4
 // OMP-NEXT:    store i32 33554431, ptr [[DOTOMP_UB]], align 4
 // OMP-NEXT:    store i32 1, ptr [[DOTOMP_STRIDE]], align 4
 // OMP-NEXT:    store i32 0, ptr [[DOTOMP_IS_LAST]], align 4
 // OMP-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[DOTGLOBAL_TID__ADDR]], align 8
 // OMP-NEXT:    [[TMP1:%.*]] = load i32, ptr [[TMP0]], align 4
-// OMP-NEXT:    call void @__kmpc_for_static_init_4(ptr @[[GLOB1:[0-9]+]], i32 [[TMP1]], i32 34, ptr [[DOTOMP_IS_LAST]], ptr [[DOTOMP_LB]], ptr [[DOTOMP_UB]], ptr [[DOTOMP_STRIDE]], i32 1, i32 1)
+// OMP-NEXT:    call void @__kmpc_for_static_init_4(ptr @[[GLOB1]], i32 [[TMP1]], i32 34, ptr [[DOTOMP_IS_LAST]], ptr [[DOTOMP_LB]], ptr [[DOTOMP_UB]], ptr [[DOTOMP_STRIDE]], i32 1, i32 1)
 // OMP-NEXT:    [[TMP2:%.*]] = load i32, ptr [[DOTOMP_UB]], align 4
 // OMP-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP2]], 33554431
 // OMP-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
 // OMP:       cond.true:
 // OMP-NEXT:    br label [[COND_END:%.*]]
 // OMP:       cond.false:
 // OMP-NEXT:    [[TMP3:%.*]] = load i32, ptr [[DOTOMP_UB]], align 4
 // OMP-NEXT:    br label [[COND_END]]

 // NOOMP:       for.inc:
 // NOOMP-NEXT:    [[TMP2:%.*]] = load i32, ptr [[I]], align 4
 // NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
 // NOOMP-NEXT:    store i32 [[INC]], ptr [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP4:![0-9]+]]
 // NOOMP:       for.end:
 // NOOMP-NEXT:    ret void
 //
+//.
+// OMP: attributes #[[ATTR0:[0-9]+]] = { noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// OMP: attributes #[[ATTR1:[0-9]+]] = { noinline norecurse nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// OMP: attributes #[[ATTR2:[0-9]+]] = { nounwind }
+//.
+// NOOMP: attributes #[[ATTR0:[0-9]+]] = { noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+//.
+// OMP: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
+// OMP: [[META1:![0-9]+]] = !{i32 7, !"openmp", i32 51}
+// OMP: [[META2:![0-9]+]] = !{!"clang version {{.*}}"}
+// OMP: [[META3:![0-9]+]] = !{[[META4:![0-9]+]]}
+// OMP: [[META4]] = !{i64 2, i64 -1, i64 -1, i1 true}
+//.
+// NOOMP: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
+// NOOMP: [[META1:![0-9]+]] = !{!"clang version {{.*}}"}
+// NOOMP: [[LOOP2]] = distinct !{[[LOOP2]], [[META3:![0-9]+]]}
+// NOOMP: [[META3]] = !{!"llvm.loop.mustprogress"}
+// NOOMP: [[LOOP4]] = distinct !{[[LOOP4]], [[META3]]}
+//.

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

-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals smart --include-generated-funcs
 // Check that the CHECK lines are generated for clang-generated functions
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck --check-prefix=NOOMP %s
 
 const int size = 1024 * 1024 * 32;
 
 double A[size];
 

 // NOOMP:       for.inc:
 // NOOMP-NEXT:    [[TMP2:%.*]] = load i32, ptr [[I]], align 4
 // NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
 // NOOMP-NEXT:    store i32 [[INC]], ptr [[I]], align 4
 // NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP4:![0-9]+]]
 // NOOMP:       for.end:
 // NOOMP-NEXT:    ret void
 //
+//.
+// NOOMP: [[LOOP2]] = distinct !{[[LOOP2]], [[META3:![0-9]+]]}
+// NOOMP: [[META3]] = !{!"llvm.loop.mustprogress"}
+// NOOMP: [[LOOP4]] = distinct !{[[LOOP4]], [[META3]]}
+//.

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

-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals
 // Check that the CHECK lines are generated for clang-generated functions
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
 // RUN: %clang_cc1 -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: @[[GLOB0:[0-9]+]] = private unnamed_addr constant [23 x i8] c"
+// OMP: @[[GLOB1:[0-9]+]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 514, i32 0, i32 22, ptr @[[GLOB0]] }, align 8
+// OMP: @[[GLOB2:[0-9]+]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @[[GLOB0]] }, align 8
+//.
+// OMP: @A = global [33554432 x double] zeroinitializer, align 16
+// OMP: @size = constant i32 33554432, align 4
+//.
+// NOOMP: @size = constant i32 33554432, align 4
+// NOOMP: @A = global [33554432 x double] zeroinitializer, align 16
+//.
 // OMP-LABEL: @main(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, ptr [[RETVAL]], align 4
 // OMP-NEXT:    store i32 0, ptr [[I]], align 4
-// OMP-NEXT:    call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @[[GLOB2:[0-9]+]], i32 0, ptr @main.omp_outlined)
+// OMP-NEXT:    call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @[[GLOB2]], i32 0, ptr @main.omp_outlined)
 // OMP-NEXT:    call void @foo()
 // OMP-NEXT:    ret i32 0
 //
 // NOOMP-LABEL: @main(
 // NOOMP-NEXT:  entry:
 // NOOMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // NOOMP-NEXT:    store i32 0, ptr [[RETVAL]], align 4

 void foo(void) {
   int i = 0;
 
 #pragma omp parallel for
   for (i = 0; i < size; ++i) {
     A[i] = 1.0;
   }
 }
+//.
+// OMP: attributes #[[ATTR0:[0-9]+]] = { noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// OMP: attributes #[[ATTR1:[0-9]+]] = { noinline norecurse nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+// OMP: attributes #[[ATTR2:[0-9]+]] = { nounwind }
+//.
+// NOOMP: attributes #[[ATTR0:[0-9]+]] = { noinline nounwind optnone "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+mmx,+sse,+sse2,+x87" }
+//.
+// OMP: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
+// OMP: [[META1:![0-9]+]] = !{i32 7, !"openmp", i32 51}
+// OMP: [[META2:![0-9]+]] = !{!"clang version {{.*}}"}
+// OMP: [[META3:![0-9]+]] = !{[[META4:![0-9]+]]}
+// OMP: [[META4]] = !{i64 2, i64 -1, i64 -1, i1 true}
+//.
+// NOOMP: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
+// NOOMP: [[META1:![0-9]+]] = !{!"clang version {{.*}}"}
+// NOOMP: [[LOOP2]] = distinct !{[[LOOP2]], [[META3:![0-9]+]]}
+// NOOMP: [[META3]] = !{!"llvm.loop.mustprogress"}
+// NOOMP: [[LOOP4]] = distinct !{[[LOOP4]], [[META3]]}
+//.

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
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals smart
 // Check that the CHECK lines are generated for clang-generated functions
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
 // RUN: %clang_cc1 -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) {
   int i = 0;
 
 #pragma omp parallel for
   for (i = 0; i < size; ++i) {
     A[i] = 1.0;
   }
 }
+//.
+// NOOMP: [[LOOP2]] = distinct !{[[LOOP2]], [[META3:![0-9]+]]}
+// NOOMP: [[META3]] = !{!"llvm.loop.mustprogress"}
+// NOOMP: [[LOOP4]] = distinct !{[[LOOP4]], [[META3]]}
+//.

clang/test/utils/update_cc_test_checks/annotations.test

+## Test that !annotation metadata is matched correctly
+
+# RUN: cp %S/Inputs/annotations.c %t.c && %update_cc_test_checks --version 3 %t.c
+# RUN: diff -u %S/Inputs/annotations.c.expected %t.c

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

 RUN: rm -rf %t && mkdir %t
 
-# Check --check-globals in normal mode and in --include-generated-funcs mode.
+# Check --check-globals all in normal mode and in --include-generated-funcs mode.
 
 RUN: cp %S/Inputs/check-globals.c %t/norm.c
-RUN: %update_cc_test_checks %t/norm.c --check-globals
+RUN: %update_cc_test_checks %t/norm.c --check-globals all
 RUN: FileCheck %s --input-file=%t/norm.c --match-full-lines -strict-whitespace \
 RUN:   -check-prefixes=BOTH,NRM
 
 RUN: cp %S/Inputs/check-globals.c %t/igf.c
-RUN: %update_cc_test_checks %t/igf.c --check-globals --include-generated-funcs
+RUN: %update_cc_test_checks %t/igf.c --check-globals all --include-generated-funcs
 RUN: FileCheck %s --input-file=%t/igf.c --match-full-lines -strict-whitespace \
 RUN:   -check-prefixes=BOTH,IGF
 
 # Check that repeating doesn't change it, such as duplicating '//.' occurrences.
 
 RUN: cp %t/norm.c %t/norm-again.c
-RUN: %update_cc_test_checks %t/norm-again.c --check-globals
+RUN: %update_cc_test_checks %t/norm-again.c --check-globals all
 RUN: diff -u %t/norm.c %t/norm-again.c
 RUN: rm %t/norm-again.c
 
 RUN: cp %t/igf.c %t/igf-again.c
-RUN: %update_cc_test_checks %t/igf-again.c --check-globals \
+RUN: %update_cc_test_checks %t/igf-again.c --check-globals all \
 RUN:     --include-generated-funcs
 RUN: diff -u %t/igf.c %t/igf-again.c
 RUN: rm %t/igf-again.c
 
 # Check that the generated directives actually work correctly.  For example,
 # they're not in the wrong order.
 
 RUN: cp %S/Inputs/lit.cfg.example %t/lit.cfg
 # Show lit failures while avoiding confusing FileCheck input dump nesting.
 RUN: %lit %t
 # Lit was successful.  Sanity-check the results with deterministic test order.
 RUN: rm %t/.lit_test_times.txt
 RUN: %lit %t 2>&1 | FileCheck -check-prefix=LIT-RUN %s
 
 END.
 
   BOTH-NOT:{{.}}
-       NRM:// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals
-       IGF:// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals --include-generated-funcs
+       NRM:// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals all
+       IGF:// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals all --include-generated-funcs
  BOTH-NEXT:// {{.*}}
  BOTH-NEXT:// RUN: true
  BOTH-NEXT:// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s
 BOTH-EMPTY:
   IGF-NEXT:void foo(void) {
   IGF-NEXT:  static int i, j;
   IGF-NEXT:}
   IGF-NEXT:void bar(void) {

  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 {{.*}}
  BOTH-NEXT://.
- BOTH-NEXT:// CHECK: !0 = {{.*}}
- BOTH-NEXT:// CHECK: !1 = {{.*}}
+ BOTH-NEXT:// CHECK: {{\[\[META0:!\[0-9\]\+\]\]}} = {{.*}}
+ BOTH-NEXT:// CHECK: {{\[\[META1:!\[0-9\]\+\]\]}} = {{.*}}
  BOTH-NEXT://.
   BOTH-NOT:{{.}}
 
 LIT-RUN: Testing: 2 tests
 LIT-RUN: PASS: {{.*}} igf.c
 LIT-RUN: PASS: {{.*}} norm.c

clang/test/utils/update_cc_test_checks/generated-funcs.test

 ## Test that CHECK lines are generated for clang-generated functions
 
-# RUN: cp %S/Inputs/generated-funcs.c %t-generated.c && %update_cc_test_checks --include-generated-funcs %t-generated.c
+# RUN: cp %S/Inputs/generated-funcs.c %t-generated.c && %update_cc_test_checks --include-generated-funcs --check-globals smart %t-generated.c
 # RUN: diff -u %S/Inputs/generated-funcs.c.generated.expected %t-generated.c
-# RUN: cp %S/Inputs/generated-funcs.c %t-no-generated.c && %update_cc_test_checks %t-no-generated.c
+# RUN: cp %S/Inputs/generated-funcs.c %t-no-generated.c && %update_cc_test_checks --check-globals smart %t-no-generated.c
 # RUN: diff -u %S/Inputs/generated-funcs.c.no-generated.expected %t-no-generated.c
 
 ## Check that re-running update_cc_test_checks doesn't change the output
 # RUN: %update_cc_test_checks --include-generated-funcs %t-generated.c
 # RUN: diff -u %S/Inputs/generated-funcs.c.generated.expected %t-generated.c
 # RUN: %update_cc_test_checks %t-no-generated.c
 # RUN: diff -u %S/Inputs/generated-funcs.c.no-generated.expected %t-no-generated.c
+
+## Same as above for --check-globals all
+# RUN: cp %S/Inputs/generated-funcs.c %t-generated.c && %update_cc_test_checks --include-generated-funcs --check-globals all %t-generated.c
+# RUN: diff -u %S/Inputs/generated-funcs.c.generated.all.expected %t-generated.c
+# RUN: cp %S/Inputs/generated-funcs.c %t-no-generated.c && %update_cc_test_checks --check-globals all %t-no-generated.c
+# RUN: diff -u %S/Inputs/generated-funcs.c.no-generated.all.expected %t-no-generated.c
+
+## Check that re-running update_cc_test_checks doesn't change the output
+# RUN: %update_cc_test_checks --include-generated-funcs %t-generated.c
+# RUN: diff -u %S/Inputs/generated-funcs.c.generated.all.expected %t-generated.c
+# RUN: %update_cc_test_checks %t-no-generated.c
+# RUN: diff -u %S/Inputs/generated-funcs.c.no-generated.all.expected %t-no-generated.c

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: @G = external dso_local global i32, align 4
 ;.
 ; CHECK-LABEL: @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

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
+; CHECK: @G = external dso_local global i32, align 4
 ;.
 define void @foo(i32) {
 ; CHECK-LABEL: @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]+]]

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: @G = external dso_local global i32, align 4
 ;.
 ; REUSE-LABEL: @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

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
+; REUSE: @G = external dso_local global i32, align 4
 ;.
 define void @foo(i32) {
 ; REUSE-LABEL: @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]+]]

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

 !61 = !{!"branch_weights", i32 1, i32 1048575}
 !62 = distinct !DIAssignID()
 ;.
 ; CHECK: attributes #[[ATTR0]] = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,ieee" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
 ; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
 ; CHECK: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
 ; CHECK: attributes #[[ATTR3]] = { nounwind }
 ;.
-; CHECK: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
-; CHECK: [[META1:![0-9]+]] = !DIFile(filename: "various_ir_values.c", directory: "/data/build/llvm-project")
-; CHECK: [[META2:![0-9]+]] = !{}
+; CHECK: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: [[META1:![0-9]+]], producer: "clang version {{.*}}", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: [[META2:![0-9]+]], splitDebugInlining: false, nameTableKind: None)
+; CHECK: [[META1]] = !DIFile(filename: "various_ir_values.c", directory: {{.*}})
+; CHECK: [[META2]] = !{}
 ; CHECK: [[META3:![0-9]+]] = !{i32 7, !"Dwarf Version", i32 4}
 ; CHECK: [[META4:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
 ; CHECK: [[META5:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
-; CHECK: [[META6:![0-9]+]] = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)"}
-; CHECK: [[DBG7]] = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
-; CHECK: [[META8:![0-9]+]] = !DISubroutineType(types: !9)
-; CHECK: [[META9:![0-9]+]] = !{null, !10}
-; CHECK: [[META10:![0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
-; CHECK: [[META11:![0-9]+]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-; CHECK: [[META12:![0-9]+]] = !{!13, !14}
-; CHECK: [[META13]] = !DILocalVariable(name: "A", arg: 1, scope: !7, file: !1, line: 1, type: !10)
-; CHECK: [[META14]] = !DILocalVariable(name: "i", scope: !15, file: !1, line: 3, type: !11)
-; CHECK: [[META15:![0-9]+]] = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
+; CHECK: [[META6:![0-9]+]] = !{!"clang version {{.*}}"}
+; CHECK: [[DBG7]] = distinct !DISubprogram(name: "foo", scope: [[META1]], file: [[META1]], line: 1, type: [[META8:![0-9]+]], scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: [[META0]], retainedNodes: [[META12:![0-9]+]])
+; CHECK: [[META8]] = !DISubroutineType(types: [[META9:![0-9]+]])
+; CHECK: [[META9]] = !{null, [[META10:![0-9]+]]}
+; CHECK: [[META10]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: [[META11:![0-9]+]], size: 64)
+; CHECK: [[META11]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+; CHECK: [[META12]] = !{[[META13]], [[META14]]}
+; CHECK: [[META13]] = !DILocalVariable(name: "A", arg: 1, scope: [[DBG7]], file: [[META1]], line: 1, type: [[META10]])
+; CHECK: [[META14]] = !DILocalVariable(name: "i", scope: [[META15:![0-9]+]], file: [[META1]], line: 3, type: [[META11]])
+; CHECK: [[META15]] = distinct !DILexicalBlock(scope: [[DBG7]], file: [[META1]], line: 3, column: 3)
 ; CHECK: [[DIASSIGNID16]] = distinct !DIAssignID()
-; CHECK: [[DBG17]] = !DILocation(line: 1, column: 15, scope: !7)
-; CHECK: [[TBAA18]] = !{!19, !19, i64 0}
-; CHECK: [[META19:![0-9]+]] = !{!"any pointer", !20, i64 0}
-; CHECK: [[META20:![0-9]+]] = !{!"omnipotent char", !21, i64 0}
-; CHECK: [[META21:![0-9]+]] = !{!"Simple C/C++ TBAA"}
-; CHECK: [[DBG22]] = !DILocation(line: 3, column: 8, scope: !15)
-; CHECK: [[DBG23]] = !DILocation(line: 3, column: 12, scope: !15)
-; CHECK: [[TBAA24]] = !{!25, !25, i64 0}
-; CHECK: [[META25:![0-9]+]] = !{!"int", !20, i64 0}
-; CHECK: [[DBG26]] = !DILocation(line: 3, column: 19, scope: !27)
-; CHECK: [[META27:![0-9]+]] = distinct !DILexicalBlock(scope: !15, file: !1, line: 3, column: 3)
-; CHECK: [[DBG28]] = !DILocation(line: 3, column: 24, scope: !27)
-; CHECK: [[DBG29]] = !DILocation(line: 3, column: 23, scope: !27)
-; CHECK: [[DBG30]] = !DILocation(line: 3, column: 21, scope: !27)
-; CHECK: [[DBG31]] = !DILocation(line: 3, column: 3, scope: !15)
+; CHECK: [[DBG17]] = !DILocation(line: 1, column: 15, scope: [[DBG7]])
+; CHECK: [[TBAA18]] = !{[[META19:![0-9]+]], [[META19]], i64 0}
+; CHECK: [[META19]] = !{!"any pointer", [[META20:![0-9]+]], i64 0}
+; CHECK: [[META20]] = !{!"omnipotent char", [[META21:![0-9]+]], i64 0}
+; CHECK: [[META21]] = !{!"Simple C/C++ TBAA"}
+; CHECK: [[DBG22]] = !DILocation(line: 3, column: 8, scope: [[META15]])
+; CHECK: [[DBG23]] = !DILocation(line: 3, column: 12, scope: [[META15]])
+; CHECK: [[TBAA24]] = !{[[META25:![0-9]+]], [[META25]], i64 0}
+; CHECK: [[META25]] = !{!"int", [[META20]], i64 0}
+; CHECK: [[DBG26]] = !DILocation(line: 3, column: 19, scope: [[META27:![0-9]+]])
+; CHECK: [[META27]] = distinct !DILexicalBlock(scope: [[META15]], file: [[META1]], line: 3, column: 3)
+; CHECK: [[DBG28]] = !DILocation(line: 3, column: 24, scope: [[META27]])
+; CHECK: [[DBG29]] = !DILocation(line: 3, column: 23, scope: [[META27]])
+; CHECK: [[DBG30]] = !DILocation(line: 3, column: 21, scope: [[META27]])
+; CHECK: [[DBG31]] = !DILocation(line: 3, column: 3, scope: [[META15]])
 ; CHECK: [[PROF32]] = !{!"branch_weights", i32 1, i32 1048575}
-; CHECK: [[DBG33]] = !DILocation(line: 3, column: 3, scope: !27)
-; CHECK: [[DBG34]] = !DILocation(line: 4, column: 5, scope: !27)
-; CHECK: [[DBG35]] = !DILocation(line: 4, column: 7, scope: !27)
-; CHECK: [[DBG36]] = !DILocation(line: 4, column: 10, scope: !27)
-; CHECK: [[DBG37]] = !DILocation(line: 3, column: 27, scope: !27)
-; CHECK: [[LOOP38]] = distinct !{!38, !31, !39}
-; CHECK: [[META39:![0-9]+]] = !DILocation(line: 4, column: 12, scope: !15)
-; CHECK: [[DBG40]] = !DILocation(line: 5, column: 1, scope: !7)
-; CHECK: [[DBG41]] = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 7, type: !8, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !42)
-; CHECK: [[META42:![0-9]+]] = !{!43, !44}
-; CHECK: [[META43]] = !DILocalVariable(name: "A", arg: 1, scope: !41, file: !1, line: 7, type: !10)
-; CHECK: [[META44]] = !DILocalVariable(name: "i", scope: !45, file: !1, line: 9, type: !11)
-; CHECK: [[META45:![0-9]+]] = distinct !DILexicalBlock(scope: !41, file: !1, line: 9, column: 3)
-; CHECK: [[DBG46]] = !DILocation(line: 7, column: 15, scope: !41)
-; CHECK: [[DBG47]] = !DILocation(line: 9, column: 8, scope: !45)
-; CHECK: [[DBG48]] = !DILocation(line: 9, column: 12, scope: !45)
-; CHECK: [[DBG49]] = !DILocation(line: 9, column: 19, scope: !50)
-; CHECK: [[META50:![0-9]+]] = distinct !DILexicalBlock(scope: !45, file: !1, line: 9, column: 3)
-; CHECK: [[DBG51]] = !DILocation(line: 9, column: 24, scope: !50)
-; CHECK: [[DBG52]] = !DILocation(line: 9, column: 23, scope: !50)
-; CHECK: [[DBG53]] = !DILocation(line: 9, column: 21, scope: !50)
-; CHECK: [[DBG54]] = !DILocation(line: 9, column: 3, scope: !45)
-; CHECK: [[DBG55]] = !DILocation(line: 9, column: 3, scope: !50)
-; CHECK: [[DBG56]] = !DILocation(line: 10, column: 5, scope: !50)
-; CHECK: [[DBG57]] = !DILocation(line: 10, column: 7, scope: !50)
-; CHECK: [[DBG58]] = !DILocation(line: 10, column: 10, scope: !50)
-; CHECK: [[DBG59]] = !DILocation(line: 9, column: 27, scope: !50)
-; CHECK: [[LOOP60]] = distinct !{!60, !54, !61}
-; CHECK: [[META61:![0-9]+]] = !DILocation(line: 10, column: 12, scope: !45)
-; CHECK: [[DBG62]] = !DILocation(line: 11, column: 1, scope: !41)
+; CHECK: [[DBG33]] = !DILocation(line: 3, column: 3, scope: [[META27]])
+; CHECK: [[DBG34]] = !DILocation(line: 4, column: 5, scope: [[META27]])
+; CHECK: [[DBG35]] = !DILocation(line: 4, column: 7, scope: [[META27]])
+; CHECK: [[DBG36]] = !DILocation(line: 4, column: 10, scope: [[META27]])
+; CHECK: [[DBG37]] = !DILocation(line: 3, column: 27, scope: [[META27]])
+; CHECK: [[LOOP38]] = distinct !{[[LOOP38]], [[DBG31]], [[META39:![0-9]+]]}
+; CHECK: [[META39]] = !DILocation(line: 4, column: 12, scope: [[META15]])
+; CHECK: [[DBG40]] = !DILocation(line: 5, column: 1, scope: [[DBG7]])
+; CHECK: [[DBG41]] = distinct !DISubprogram(name: "bar", scope: [[META1]], file: [[META1]], line: 7, type: [[META8]], scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: [[META0]], retainedNodes: [[META42:![0-9]+]])
+; CHECK: [[META42]] = !{[[META43]], [[META44]]}
+; CHECK: [[META43]] = !DILocalVariable(name: "A", arg: 1, scope: [[DBG41]], file: [[META1]], line: 7, type: [[META10]])
+; CHECK: [[META44]] = !DILocalVariable(name: "i", scope: [[META45:![0-9]+]], file: [[META1]], line: 9, type: [[META11]])
+; CHECK: [[META45]] = distinct !DILexicalBlock(scope: [[DBG41]], file: [[META1]], line: 9, column: 3)
+; CHECK: [[DBG46]] = !DILocation(line: 7, column: 15, scope: [[DBG41]])
+; CHECK: [[DBG47]] = !DILocation(line: 9, column: 8, scope: [[META45]])
+; CHECK: [[DBG48]] = !DILocation(line: 9, column: 12, scope: [[META45]])
+; CHECK: [[DBG49]] = !DILocation(line: 9, column: 19, scope: [[META50:![0-9]+]])
+; CHECK: [[META50]] = distinct !DILexicalBlock(scope: [[META45]], file: [[META1]], line: 9, column: 3)
+; CHECK: [[DBG51]] = !DILocation(line: 9, column: 24, scope: [[META50]])
+; CHECK: [[DBG52]] = !DILocation(line: 9, column: 23, scope: [[META50]])
+; CHECK: [[DBG53]] = !DILocation(line: 9, column: 21, scope: [[META50]])
+; CHECK: [[DBG54]] = !DILocation(line: 9, column: 3, scope: [[META45]])
+; CHECK: [[DBG55]] = !DILocation(line: 9, column: 3, scope: [[META50]])
+; CHECK: [[DBG56]] = !DILocation(line: 10, column: 5, scope: [[META50]])
+; CHECK: [[DBG57]] = !DILocation(line: 10, column: 7, scope: [[META50]])
+; CHECK: [[DBG58]] = !DILocation(line: 10, column: 10, scope: [[META50]])
+; CHECK: [[DBG59]] = !DILocation(line: 9, column: 27, scope: [[META50]])
+; CHECK: [[LOOP60]] = distinct !{[[LOOP60]], [[DBG54]], [[META61:![0-9]+]]}
+; CHECK: [[META61]] = !DILocation(line: 10, column: 12, scope: [[META45]])
+; CHECK: [[DBG62]] = !DILocation(line: 11, column: 1, scope: [[DBG41]])
 ;.

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

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-globals
+; 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(ptr %A) #0 !dbg !7 {
-; CHECK-LABEL: define {{[^@]+}}@foo
-; CHECK-SAME: (ptr [[A:%.*]]) #[[ATTR0:[0-9]+]] !dbg [[DBG7:![0-9]+]] {
+; CHECK-LABEL: @foo(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8, !DIAssignID [[DIASSIGNID16:![0-9]+]]
 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    call void @llvm.dbg.assign(metadata i1 undef, metadata [[META13:![0-9]+]], metadata !DIExpression(), metadata [[DIASSIGNID16]], metadata ptr [[A_ADDR]], metadata !DIExpression()), !dbg [[DBG17:![0-9]+]]
-; CHECK-NEXT:    store ptr [[A]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18:![0-9]+]]
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[A_ADDR]], metadata [[META13]], metadata !DIExpression()), !dbg [[DBG17]]
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I]]) #[[ATTR3:[0-9]+]], !dbg [[DBG22:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[I]], metadata [[META14:![0-9]+]], metadata !DIExpression()), !dbg [[DBG23:![0-9]+]]
 ; CHECK-NEXT:    store i32 0, ptr [[I]], align 4, !dbg [[DBG23]], !tbaa [[TBAA24:![0-9]+]]
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]], !dbg [[DBG22]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[I]], align 4, !dbg [[DBG26:![0-9]+]], !tbaa [[TBAA24]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8, !dbg [[DBG28:![0-9]+]], !tbaa [[TBAA18]]

 ; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #2
 
 ; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #2
 
 ; Function Attrs: nounwind uwtable
 define dso_local void @bar(ptr %A) #0 !dbg !39 {
-; CHECK-LABEL: define {{[^@]+}}@bar
-; CHECK-SAME: (ptr [[A:%.*]]) #[[ATTR0]] !dbg [[DBG41:![0-9]+]] {
+; CHECK-LABEL: @bar(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8
 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store ptr [[A]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18]]
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[A_ADDR]], metadata [[META43:![0-9]+]], metadata !DIExpression()), !dbg [[DBG46:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I]]) #[[ATTR3]], !dbg [[DBG47:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[I]], metadata [[META44:![0-9]+]], metadata !DIExpression()), !dbg [[DBG48:![0-9]+]]
 ; CHECK-NEXT:    store i32 0, ptr [[I]], align 4, !dbg [[DBG48]], !tbaa [[TBAA24]]
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]], !dbg [[DBG47]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[I]], align 4, !dbg [[DBG49:![0-9]+]], !tbaa [[TBAA24]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8, !dbg [[DBG51:![0-9]+]], !tbaa [[TBAA18]]

 !55 = !DILocation(line: 10, column: 7, scope: !48)
 !56 = !DILocation(line: 10, column: 10, scope: !48)
 !57 = !DILocation(line: 9, column: 27, scope: !48)
 !58 = distinct !{!58, !52, !59}
 !59 = !DILocation(line: 10, column: 12, scope: !43)
 !60 = !DILocation(line: 11, column: 1, scope: !39)
 !61 = !{!"branch_weights", i32 1, i32 1048575}
 !62 = distinct !DIAssignID()
-;.
-; CHECK: attributes #[[ATTR0]] = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,ieee" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
-; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
-; CHECK: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
-; CHECK: attributes #[[ATTR3]] = { nounwind }
-;.
-; CHECK: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
-; CHECK: [[META1:![0-9]+]] = !DIFile(filename: "various_ir_values.c", directory: "/data/build/llvm-project")
-; CHECK: [[META2:![0-9]+]] = !{}
-; CHECK: [[META3:![0-9]+]] = !{i32 7, !"Dwarf Version", i32 4}
-; CHECK: [[META4:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
-; CHECK: [[META5:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
-; CHECK: [[META6:![0-9]+]] = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)"}
-; CHECK: [[DBG7]] = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
-; CHECK: [[META8:![0-9]+]] = !DISubroutineType(types: !9)
-; CHECK: [[META9:![0-9]+]] = !{null, !10}
-; CHECK: [[META10:![0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
-; CHECK: [[META11:![0-9]+]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-; CHECK: [[META12:![0-9]+]] = !{!13, !14}
-; CHECK: [[META13]] = !DILocalVariable(name: "A", arg: 1, scope: !7, file: !1, line: 1, type: !10)
-; CHECK: [[META14]] = !DILocalVariable(name: "i", scope: !15, file: !1, line: 3, type: !11)
-; CHECK: [[META15:![0-9]+]] = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
-; CHECK: [[DIASSIGNID16]] = distinct !DIAssignID()
-; CHECK: [[DBG17]] = !DILocation(line: 1, column: 15, scope: !7)
-; CHECK: [[TBAA18]] = !{!19, !19, i64 0}
-; CHECK: [[META19:![0-9]+]] = !{!"any pointer", !20, i64 0}
-; CHECK: [[META20:![0-9]+]] = !{!"omnipotent char", !21, i64 0}
-; CHECK: [[META21:![0-9]+]] = !{!"Simple C/C++ TBAA"}
-; CHECK: [[DBG22]] = !DILocation(line: 3, column: 8, scope: !15)
-; CHECK: [[DBG23]] = !DILocation(line: 3, column: 12, scope: !15)
-; CHECK: [[TBAA24]] = !{!25, !25, i64 0}
-; CHECK: [[META25:![0-9]+]] = !{!"int", !20, i64 0}
-; CHECK: [[DBG26]] = !DILocation(line: 3, column: 19, scope: !27)
-; CHECK: [[META27:![0-9]+]] = distinct !DILexicalBlock(scope: !15, file: !1, line: 3, column: 3)
-; CHECK: [[DBG28]] = !DILocation(line: 3, column: 24, scope: !27)
-; CHECK: [[DBG29]] = !DILocation(line: 3, column: 23, scope: !27)
-; CHECK: [[DBG30]] = !DILocation(line: 3, column: 21, scope: !27)
-; CHECK: [[DBG31]] = !DILocation(line: 3, column: 3, scope: !15)
-; CHECK: [[PROF32]] = !{!"branch_weights", i32 1, i32 1048575}
-; CHECK: [[DBG33]] = !DILocation(line: 3, column: 3, scope: !27)
-; CHECK: [[DBG34]] = !DILocation(line: 4, column: 5, scope: !27)
-; CHECK: [[DBG35]] = !DILocation(line: 4, column: 7, scope: !27)
-; CHECK: [[DBG36]] = !DILocation(line: 4, column: 10, scope: !27)
-; CHECK: [[DBG37]] = !DILocation(line: 3, column: 27, scope: !27)
-; CHECK: [[LOOP38]] = distinct !{!38, !31, !39}
-; CHECK: [[META39:![0-9]+]] = !DILocation(line: 4, column: 12, scope: !15)
-; CHECK: [[DBG40]] = !DILocation(line: 5, column: 1, scope: !7)
-; CHECK: [[DBG41]] = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 7, type: !8, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !42)
-; CHECK: [[META42:![0-9]+]] = !{!43, !44}
-; CHECK: [[META43]] = !DILocalVariable(name: "A", arg: 1, scope: !41, file: !1, line: 7, type: !10)
-; CHECK: [[META44]] = !DILocalVariable(name: "i", scope: !45, file: !1, line: 9, type: !11)
-; CHECK: [[META45:![0-9]+]] = distinct !DILexicalBlock(scope: !41, file: !1, line: 9, column: 3)
-; CHECK: [[DBG46]] = !DILocation(line: 7, column: 15, scope: !41)
-; CHECK: [[DBG47]] = !DILocation(line: 9, column: 8, scope: !45)
-; CHECK: [[DBG48]] = !DILocation(line: 9, column: 12, scope: !45)
-; CHECK: [[DBG49]] = !DILocation(line: 9, column: 19, scope: !50)
-; CHECK: [[META50:![0-9]+]] = distinct !DILexicalBlock(scope: !45, file: !1, line: 9, column: 3)
-; CHECK: [[DBG51]] = !DILocation(line: 9, column: 24, scope: !50)
-; CHECK: [[DBG52]] = !DILocation(line: 9, column: 23, scope: !50)
-; CHECK: [[DBG53]] = !DILocation(line: 9, column: 21, scope: !50)
-; CHECK: [[DBG54]] = !DILocation(line: 9, column: 3, scope: !45)
-; CHECK: [[DBG55]] = !DILocation(line: 9, column: 3, scope: !50)
-; CHECK: [[DBG56]] = !DILocation(line: 10, column: 5, scope: !50)
-; CHECK: [[DBG57]] = !DILocation(line: 10, column: 7, scope: !50)
-; CHECK: [[DBG58]] = !DILocation(line: 10, column: 10, scope: !50)
-; CHECK: [[DBG59]] = !DILocation(line: 9, column: 27, scope: !50)
-; CHECK: [[LOOP60]] = distinct !{!60, !54, !61}
-; CHECK: [[META61:![0-9]+]] = !DILocation(line: 10, column: 12, scope: !45)
-; CHECK: [[DBG62]] = !DILocation(line: 11, column: 1, scope: !41)
-;.

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

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-globals
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals smart
 ; 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(ptr %A) #0 !dbg !7 {
-; CHECK-LABEL: define {{[^@]+}}@foo
-; CHECK-SAME: (ptr [[A:%.*]]) #[[ATTR0:[0-9]+]] !dbg [[DBG7:![0-9]+]] {
+; CHECK-LABEL: @foo(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8, !DIAssignID [[DIASSIGNID16:![0-9]+]]
 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    call void @llvm.dbg.assign(metadata i1 undef, metadata [[META13:![0-9]+]], metadata !DIExpression(), metadata [[DIASSIGNID16]], metadata ptr [[A_ADDR]], metadata !DIExpression()), !dbg [[DBG17:![0-9]+]]
-; CHECK-NEXT:    store ptr [[A]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18:![0-9]+]]
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[A_ADDR]], metadata [[META13]], metadata !DIExpression()), !dbg [[DBG17]]
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I]]) #[[ATTR3:[0-9]+]], !dbg [[DBG22:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[I]], metadata [[META14:![0-9]+]], metadata !DIExpression()), !dbg [[DBG23:![0-9]+]]
 ; CHECK-NEXT:    store i32 0, ptr [[I]], align 4, !dbg [[DBG23]], !tbaa [[TBAA24:![0-9]+]]
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]], !dbg [[DBG22]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[I]], align 4, !dbg [[DBG26:![0-9]+]], !tbaa [[TBAA24]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8, !dbg [[DBG28:![0-9]+]], !tbaa [[TBAA18]]

 ; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #2
 
 ; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #2
 
 ; Function Attrs: nounwind uwtable
 define dso_local void @bar(ptr %A) #0 !dbg !39 {
-; CHECK-LABEL: define {{[^@]+}}@bar
-; CHECK-SAME: (ptr [[A:%.*]]) #[[ATTR0]] !dbg [[DBG41:![0-9]+]] {
+; CHECK-LABEL: @bar(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8
 ; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store ptr [[A]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18]]
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8, !tbaa [[TBAA18]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[A_ADDR]], metadata [[META43:![0-9]+]], metadata !DIExpression()), !dbg [[DBG46:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[I]]) #[[ATTR3]], !dbg [[DBG47:![0-9]+]]
 ; CHECK-NEXT:    call void @llvm.dbg.declare(metadata ptr [[I]], metadata [[META44:![0-9]+]], metadata !DIExpression()), !dbg [[DBG48:![0-9]+]]
 ; CHECK-NEXT:    store i32 0, ptr [[I]], align 4, !dbg [[DBG48]], !tbaa [[TBAA24]]
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]], !dbg [[DBG47]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[I]], align 4, !dbg [[DBG49:![0-9]+]], !tbaa [[TBAA24]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8, !dbg [[DBG51:![0-9]+]], !tbaa [[TBAA18]]

 !56 = !DILocation(line: 10, column: 10, scope: !48)
 !57 = !DILocation(line: 9, column: 27, scope: !48)
 !58 = distinct !{!58, !52, !59}
 !59 = !DILocation(line: 10, column: 12, scope: !43)
 !60 = !DILocation(line: 11, column: 1, scope: !39)
 !61 = !{!"branch_weights", i32 1, i32 1048575}
 !62 = distinct !DIAssignID()
 ;.
-; CHECK: attributes #[[ATTR0]] = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,ieee" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
-; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
-; CHECK: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
-; CHECK: attributes #[[ATTR3]] = { nounwind }
-;.
-; CHECK: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
-; CHECK: [[META1:![0-9]+]] = !DIFile(filename: "various_ir_values.c", directory: "/data/build/llvm-project")
-; CHECK: [[META2:![0-9]+]] = !{}
-; CHECK: [[META3:![0-9]+]] = !{i32 7, !"Dwarf Version", i32 4}
-; CHECK: [[META4:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
-; CHECK: [[META5:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
-; CHECK: [[META6:![0-9]+]] = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)"}
-; CHECK: [[DBG7]] = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
-; CHECK: [[META8:![0-9]+]] = !DISubroutineType(types: !9)
-; CHECK: [[META9:![0-9]+]] = !{null, !10}
-; CHECK: [[META10:![0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
-; CHECK: [[META11:![0-9]+]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-; CHECK: [[META12:![0-9]+]] = !{!13, !14}
-; CHECK: [[META13]] = !DILocalVariable(name: "A", arg: 1, scope: !7, file: !1, line: 1, type: !10)
-; CHECK: [[META14]] = !DILocalVariable(name: "i", scope: !15, file: !1, line: 3, type: !11)
-; CHECK: [[META15:![0-9]+]] = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
+; CHECK: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: [[META1:![0-9]+]], producer: "clang version {{.*}}", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: [[META2:![0-9]+]], splitDebugInlining: false, nameTableKind: None)
+; CHECK: [[META1]] = !DIFile(filename: "various_ir_values.c", directory: {{.*}})
+; CHECK: [[META2]] = !{}
+; CHECK: [[META7:![0-9]+]] = distinct !DISubprogram(name: "foo", scope: [[META1]], file: [[META1]], line: 1, type: [[META8:![0-9]+]], scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: [[META0]], retainedNodes: [[META12:![0-9]+]])
+; CHECK: [[META8]] = !DISubroutineType(types: [[META9:![0-9]+]])
+; CHECK: [[META9]] = !{null, [[META10:![0-9]+]]}
+; CHECK: [[META10]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: [[META11:![0-9]+]], size: 64)
+; CHECK: [[META11]] = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+; CHECK: [[META12]] = !{[[META13]], [[META14]]}
+; CHECK: [[META13]] = !DILocalVariable(name: "A", arg: 1, scope: [[META7]], file: [[META1]], line: 1, type: [[META10]])
+; CHECK: [[META14]] = !DILocalVariable(name: "i", scope: [[META15:![0-9]+]], file: [[META1]], line: 3, type: [[META11]])
+; CHECK: [[META15]] = distinct !DILexicalBlock(scope: [[META7]], file: [[META1]], line: 3, column: 3)
 ; CHECK: [[DIASSIGNID16]] = distinct !DIAssignID()
-; CHECK: [[DBG17]] = !DILocation(line: 1, column: 15, scope: !7)
-; CHECK: [[TBAA18]] = !{!19, !19, i64 0}
-; CHECK: [[META19:![0-9]+]] = !{!"any pointer", !20, i64 0}
-; CHECK: [[META20:![0-9]+]] = !{!"omnipotent char", !21, i64 0}
-; CHECK: [[META21:![0-9]+]] = !{!"Simple C/C++ TBAA"}
-; CHECK: [[DBG22]] = !DILocation(line: 3, column: 8, scope: !15)
-; CHECK: [[DBG23]] = !DILocation(line: 3, column: 12, scope: !15)
-; CHECK: [[TBAA24]] = !{!25, !25, i64 0}
-; CHECK: [[META25:![0-9]+]] = !{!"int", !20, i64 0}
-; CHECK: [[DBG26]] = !DILocation(line: 3, column: 19, scope: !27)
-; CHECK: [[META27:![0-9]+]] = distinct !DILexicalBlock(scope: !15, file: !1, line: 3, column: 3)
-; CHECK: [[DBG28]] = !DILocation(line: 3, column: 24, scope: !27)
-; CHECK: [[DBG29]] = !DILocation(line: 3, column: 23, scope: !27)
-; CHECK: [[DBG30]] = !DILocation(line: 3, column: 21, scope: !27)
-; CHECK: [[DBG31]] = !DILocation(line: 3, column: 3, scope: !15)
+; CHECK: [[DBG17]] = !DILocation(line: 1, column: 15, scope: [[META7]])
+; CHECK: [[TBAA18]] = !{[[META19:![0-9]+]], [[META19]], i64 0}
+; CHECK: [[META19]] = !{!"any pointer", [[META20:![0-9]+]], i64 0}
+; CHECK: [[META20]] = !{!"omnipotent char", [[META21:![0-9]+]], i64 0}
+; CHECK: [[META21]] = !{!"Simple C/C++ TBAA"}
+; CHECK: [[DBG22]] = !DILocation(line: 3, column: 8, scope: [[META15]])
+; CHECK: [[DBG23]] = !DILocation(line: 3, column: 12, scope: [[META15]])
+; CHECK: [[TBAA24]] = !{[[META25:![0-9]+]], [[META25]], i64 0}
+; CHECK: [[META25]] = !{!"int", [[META20]], i64 0}
+; CHECK: [[DBG26]] = !DILocation(line: 3, column: 19, scope: [[META27:![0-9]+]])
+; CHECK: [[META27]] = distinct !DILexicalBlock(scope: [[META15]], file: [[META1]], line: 3, column: 3)
+; CHECK: [[DBG28]] = !DILocation(line: 3, column: 24, scope: [[META27]])
+; CHECK: [[DBG29]] = !DILocation(line: 3, column: 23, scope: [[META27]])
+; CHECK: [[DBG30]] = !DILocation(line: 3, column: 21, scope: [[META27]])
+; CHECK: [[DBG31]] = !DILocation(line: 3, column: 3, scope: [[META15]])
 ; CHECK: [[PROF32]] = !{!"branch_weights", i32 1, i32 1048575}
-; CHECK: [[DBG33]] = !DILocation(line: 3, column: 3, scope: !27)
-; CHECK: [[DBG34]] = !DILocation(line: 4, column: 5, scope: !27)
-; CHECK: [[DBG35]] = !DILocation(line: 4, column: 7, scope: !27)
-; CHECK: [[DBG36]] = !DILocation(line: 4, column: 10, scope: !27)
-; CHECK: [[DBG37]] = !DILocation(line: 3, column: 27, scope: !27)
-; CHECK: [[LOOP38]] = distinct !{!38, !31, !39}
-; CHECK: [[META39:![0-9]+]] = !DILocation(line: 4, column: 12, scope: !15)
-; CHECK: [[DBG40]] = !DILocation(line: 5, column: 1, scope: !7)
-; CHECK: [[DBG41]] = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 7, type: !8, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !42)
-; CHECK: [[META42:![0-9]+]] = !{!43, !44}
-; CHECK: [[META43]] = !DILocalVariable(name: "A", arg: 1, scope: !41, file: !1, line: 7, type: !10)
-; CHECK: [[META44]] = !DILocalVariable(name: "i", scope: !45, file: !1, line: 9, type: !11)
-; CHECK: [[META45:![0-9]+]] = distinct !DILexicalBlock(scope: !41, file: !1, line: 9, column: 3)
-; CHECK: [[DBG46]] = !DILocation(line: 7, column: 15, scope: !41)
-; CHECK: [[DBG47]] = !DILocation(line: 9, column: 8, scope: !45)
-; CHECK: [[DBG48]] = !DILocation(line: 9, column: 12, scope: !45)
-; CHECK: [[DBG49]] = !DILocation(line: 9, column: 19, scope: !50)
-; CHECK: [[META50:![0-9]+]] = distinct !DILexicalBlock(scope: !45, file: !1, line: 9, column: 3)
-; CHECK: [[DBG51]] = !DILocation(line: 9, column: 24, scope: !50)
-; CHECK: [[DBG52]] = !DILocation(line: 9, column: 23, scope: !50)
-; CHECK: [[DBG53]] = !DILocation(line: 9, column: 21, scope: !50)
-; CHECK: [[DBG54]] = !DILocation(line: 9, column: 3, scope: !45)
-; CHECK: [[DBG55]] = !DILocation(line: 9, column: 3, scope: !50)
-; CHECK: [[DBG56]] = !DILocation(line: 10, column: 5, scope: !50)
-; CHECK: [[DBG57]] = !DILocation(line: 10, column: 7, scope: !50)
-; CHECK: [[DBG58]] = !DILocation(line: 10, column: 10, scope: !50)
-; CHECK: [[DBG59]] = !DILocation(line: 9, column: 27, scope: !50)
-; CHECK: [[LOOP60]] = distinct !{!60, !54, !61}
-; CHECK: [[META61:![0-9]+]] = !DILocation(line: 10, column: 12, scope: !45)
-; CHECK: [[DBG62]] = !DILocation(line: 11, column: 1, scope: !41)
+; CHECK: [[DBG33]] = !DILocation(line: 3, column: 3, scope: [[META27]])
+; CHECK: [[DBG34]] = !DILocation(line: 4, column: 5, scope: [[META27]])
+; CHECK: [[DBG35]] = !DILocation(line: 4, column: 7, scope: [[META27]])
+; CHECK: [[DBG36]] = !DILocation(line: 4, column: 10, scope: [[META27]])
+; CHECK: [[DBG37]] = !DILocation(line: 3, column: 27, scope: [[META27]])
+; CHECK: [[LOOP38]] = distinct !{[[LOOP38]], [[DBG31]], [[META39:![0-9]+]]}
+; CHECK: [[META39]] = !DILocation(line: 4, column: 12, scope: [[META15]])
+; CHECK: [[DBG40]] = !DILocation(line: 5, column: 1, scope: [[META7]])
+; CHECK: [[META41:![0-9]+]] = distinct !DISubprogram(name: "bar", scope: [[META1]], file: [[META1]], line: 7, type: [[META8]], scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: [[META0]], retainedNodes: [[META42:![0-9]+]])
+; CHECK: [[META42]] = !{[[META43]], [[META44]]}
+; CHECK: [[META43]] = !DILocalVariable(name: "A", arg: 1, scope: [[META41]], file: [[META1]], line: 7, type: [[META10]])
+; CHECK: [[META44]] = !DILocalVariable(name: "i", scope: [[META45:![0-9]+]], file: [[META1]], line: 9, type: [[META11]])
+; CHECK: [[META45]] = distinct !DILexicalBlock(scope: [[META41]], file: [[META1]], line: 9, column: 3)
+; CHECK: [[DBG46]] = !DILocation(line: 7, column: 15, scope: [[META41]])
+; CHECK: [[DBG47]] = !DILocation(line: 9, column: 8, scope: [[META45]])
+; CHECK: [[DBG48]] = !DILocation(line: 9, column: 12, scope: [[META45]])
+; CHECK: [[DBG49]] = !DILocation(line: 9, column: 19, scope: [[META50:![0-9]+]])
+; CHECK: [[META50]] = distinct !DILexicalBlock(scope: [[META45]], file: [[META1]], line: 9, column: 3)
+; CHECK: [[DBG51]] = !DILocation(line: 9, column: 24, scope: [[META50]])
+; CHECK: [[DBG52]] = !DILocation(line: 9, column: 23, scope: [[META50]])
+; CHECK: [[DBG53]] = !DILocation(line: 9, column: 21, scope: [[META50]])
+; CHECK: [[DBG54]] = !DILocation(line: 9, column: 3, scope: [[META45]])
+; CHECK: [[DBG55]] = !DILocation(line: 9, column: 3, scope: [[META50]])
+; CHECK: [[DBG56]] = !DILocation(line: 10, column: 5, scope: [[META50]])
+; CHECK: [[DBG57]] = !DILocation(line: 10, column: 7, scope: [[META50]])
+; CHECK: [[DBG58]] = !DILocation(line: 10, column: 10, scope: [[META50]])
+; CHECK: [[DBG59]] = !DILocation(line: 9, column: 27, scope: [[META50]])
+; CHECK: [[LOOP60]] = distinct !{[[LOOP60]], [[DBG54]], [[META61:![0-9]+]]}
+; CHECK: [[META61]] = !DILocation(line: 10, column: 12, scope: [[META45]])
+; CHECK: [[DBG62]] = !DILocation(line: 11, column: 1, scope: [[META41]])
 ;.

llvm/test/tools/UpdateTestChecks/update_test_checks/various_ir_values.test

 ## the -SAME: lines since the generated file will have --function-signature in
 ## an UTC_ARGS: comment in the first line (from the invocation above) which is
 ## added to the update invocation below.
 # RUN: %update_test_checks %t.ll
 # RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.funcsig.expected
 ## Also try the --check-globals flag
 # RUN: %update_test_checks %t.ll --check-globals
 # RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.funcsig.globals.expected
+# RUN: cp -f %S/Inputs/various_ir_values.ll %t.ll && %update_test_checks %t.ll --function-signature --check-globals all
+# RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.funcsig.globals.expected
+# RUN: cp -f %S/Inputs/various_ir_values.ll %t.ll && %update_test_checks %t.ll --check-globals none
+# RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.funcsig.noglobals.expected
+# RUN: cp -f %S/Inputs/various_ir_values.ll %t.ll && %update_test_checks %t.ll --check-globals smart
+# RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.funcsig.transitiveglobals.expected

llvm/utils/UpdateTestChecks/common.py

 _prefix_filecheck_ir_name = ""
 
 """
 Version changelog:
 
 1: Initial version, used by tests that don't specify --version explicitly.
 2: --function-signature is now enabled by default and also checks return
    type/attributes.
+3: --check-globals now has a third option ('smart'). The others are now called
+   'none' and 'all'. 'smart' is the default.
 """
-DEFAULT_VERSION = 2
+DEFAULT_VERSION = 3
 
 
 class Regex(object):
     """Wrap a compiled regular expression object to allow deep copy of a regexp.
     This is required for the deep copy done in do_scrub.
 
     """
 
def parse_commandline_args(parser):
     _global_hex_value_regex = args.global_hex_value_regex
     return args
 
 
 def parse_args(parser, argv):
     args = parser.parse_args(argv)
     if args.version >= 2:
         args.function_signature = True
+    if "check_globals" in args and args.check_globals == "default":
+        args.check_globals = "none" if args.version < 3 else "smart"
     return args
 
 
 class InputLineInfo(object):
     def __init__(self, line, line_number, args, argv):
         self.line = line
         self.line_number = line_number
         self.args = args

 
 ##### Generator of LLVM IR CHECK lines
 
 SCRUB_IR_COMMENT_RE = re.compile(r"\s*;.*")
 
 # TODO: We should also derive check lines for global, debug, loop declarations, etc..
 
 
 class NamelessValue:
     def __init__(
         self,
         check_prefix,
         check_key,
         ir_prefix,
         ir_regexp,
         global_ir_rhs_regexp,
         *,
         is_before_functions=False,
         is_number=False,
-        replace_number_with_counter=False
+        replace_number_with_counter=False,
+        match_literally=False,
     ):
         self.check_prefix = check_prefix
         self.check_key = check_key
         self.ir_prefix = ir_prefix
         self.ir_regexp = ir_regexp
         self.global_ir_rhs_regexp = global_ir_rhs_regexp
         self.is_before_functions = is_before_functions
         self.is_number = is_number
         # Some variable numbers (e.g. MCINST1234) will change based on unrelated
         # modifications to LLVM, replace those with an incrementing counter.
         self.replace_number_with_counter = replace_number_with_counter
+        self.match_literally = match_literally
         self.variable_mapping = {}
 
     # Return true if this kind of IR value is "local", basically if it matches '%{{.*}}'.
     def is_local_def_ir_value_match(self, match):
         return self.ir_prefix == "%"
 
     # Return true if this kind of IR value is "global", basically if it matches '#{{.*}}'.
     def is_global_scope_ir_value_match(self, match):
         return self.global_ir_rhs_regexp is not None
 
     # Return the IR prefix and check prefix we use for this kind or IR value,
-    # e.g., (%, TMP) for locals.
+    # e.g., (%, TMP) for locals. If the IR prefix is a regex, return the prefix
+    # used in the IR output
     def get_ir_prefix_from_ir_value_match(self, match):
-        return self.ir_prefix, self.check_prefix
+        return re.search(self.ir_prefix, match[0])[0], self.check_prefix
 
     # Return the IR regexp we use for this kind or IR value, e.g., [\w.-]+? for locals
     def get_ir_regex_from_ir_value_re_match(self, match):
         # for backwards compatibility we check locals with '.*'
         if self.is_local_def_ir_value_match(match):
             return ".*"
         return self.ir_regexp
 
def get_value_use(self, var, match, var_prefix=None):
         return prefix + capture_start + self.get_value_name(var, var_prefix) + "]]"
 
 
 # Description of the different "unnamed" values we match in the IR, e.g.,
 # (local) ssa values, (debug) metadata, etc.
 ir_nameless_values = [
     #            check_prefix   check_key  ir_prefix           ir_regexp                global_ir_rhs_regexp
     NamelessValue(r"TMP", "%", r"%", r"[\w$.-]+?", None),
     NamelessValue(r"ATTR", "#", r"#", r"[0-9]+", None),
     NamelessValue(r"ATTR", "#", r"attributes #", r"[0-9]+", r"{[^}]*}"),
     NamelessValue(r"GLOB", "@", r"@", r"[0-9]+", None),
+    NamelessValue(r"GLOB", "@", r"@", r"[0-9]+", r".+", is_before_functions=True),
     NamelessValue(
-        r"GLOB", "@", r"@", r'[a-zA-Z0-9_$"\\.-]+', r".+", is_before_functions=True
+        r"GLOBNAMED",
+        "@",
+        r"@",
+        r"[a-zA-Z0-9_$\"\\.-]*[a-zA-Z_$\"\\.-][a-zA-Z0-9_$\"\\.-]*",
+        r".+",
+        is_before_functions=True,
+        match_literally=True,
     ),
     NamelessValue(r"DBG", "!", r"!dbg ", r"![0-9]+", None),
     NamelessValue(r"DIASSIGNID", "!", r"!DIAssignID ", r"![0-9]+", None),
     NamelessValue(r"PROF", "!", r"!prof ", r"![0-9]+", None),
     NamelessValue(r"TBAA", "!", r"!tbaa ", r"![0-9]+", None),
     NamelessValue(r"TBAA_STRUCT", "!", r"!tbaa.struct ", r"![0-9]+", None),
     NamelessValue(r"RNG", "!", r"!range ", r"![0-9]+", None),
     NamelessValue(r"LOOP", "!", r"!llvm.loop ", r"![0-9]+", None),
     NamelessValue(r"META", "!", r"metadata ", r"![0-9]+", None),
     NamelessValue(r"META", "!", r"", r"![0-9]+", r"(?:distinct |)!.*"),
     NamelessValue(r"ACC_GRP", "!", r"!llvm.access.group ", r"![0-9]+", None),
+    NamelessValue(r"META", "!", r"![a-z.]+ ", r"![0-9]+", None),
+]
+
+global_nameless_values = [
+    nameless_value
+    for nameless_value in ir_nameless_values
+    if nameless_value.global_ir_rhs_regexp is not None
+]
+# global variable names should be matched literally
+global_nameless_values_w_unstable_ids = [
+    nameless_value
+    for nameless_value in global_nameless_values
+    if not nameless_value.match_literally
 ]
 
 asm_nameless_values = [
     NamelessValue(
         r"MCINST",
         "Inst#",
         "<MCInst #",
         r"\d+",
         r".+",
         is_number=True,
         replace_number_with_counter=True,

 # other locations will need adjustment as well.
 IR_VALUE_REGEXP_PREFIX = r"(\s*)"
 IR_VALUE_REGEXP_STRING = r""
 for nameless_value in ir_nameless_values:
     match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp)
     if nameless_value.global_ir_rhs_regexp is not None:
         match = "^" + match
     IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, match)
-IR_VALUE_REGEXP_SUFFIX = r"([,\s\(\)]|\Z)"
+IR_VALUE_REGEXP_SUFFIX = r"([,\s\(\)\}]|\Z)"
 IR_VALUE_RE = re.compile(
     IR_VALUE_REGEXP_PREFIX
     + r"("
     + IR_VALUE_REGEXP_STRING
     + r")"
     + IR_VALUE_REGEXP_SUFFIX
 )
 
+GLOBAL_VALUE_REGEXP_STRING = r""
+for nameless_value in global_nameless_values_w_unstable_ids:
+    match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp)
+    GLOBAL_VALUE_REGEXP_STRING = createOrRegexp(GLOBAL_VALUE_REGEXP_STRING, match)
+GLOBAL_VALUE_RE = re.compile(
+    IR_VALUE_REGEXP_PREFIX
+    + r"("
+    + GLOBAL_VALUE_REGEXP_STRING
+    + r")"
+    + IR_VALUE_REGEXP_SUFFIX
+)
+
 # Build the regexp that matches an "ASM value" (currently only for --asm-show-inst comments).
 ASM_VALUE_REGEXP_STRING = ""
 for nameless_value in asm_nameless_values:
     match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp)
     ASM_VALUE_REGEXP_STRING = createOrRegexp(ASM_VALUE_REGEXP_STRING, match)
 ASM_VALUE_REGEXP_SUFFIX = r"([>\s]|\Z)"
 ASM_VALUE_RE = re.compile(
     r"((?:#|//)\s*)" + "(" + ASM_VALUE_REGEXP_STRING + ")" + ASM_VALUE_REGEXP_SUFFIX
 )
 
 # The entire match is group 0, the prefix has one group (=1), the entire
 # IR_VALUE_REGEXP_STRING is one group (=2), and then the nameless values start.
 first_nameless_group_in_ir_value_match = 3
 
 # constants for the group id of special matches
 variable_group_in_ir_value_match = 3
 attribute_group_in_ir_value_match = 4
 
+
 # Check a match for IR_VALUE_RE and inspect it to determine if it was a local
 # value, %..., global @..., debug number !dbg !..., etc. See the PREFIXES above.
 def get_idx_from_ir_value_match(match):
     for i in range(first_nameless_group_in_ir_value_match, match.lastindex):
         if match.group(i) is not None:
             return i - first_nameless_group_in_ir_value_match
     error("Unable to identify the kind of IR value from the match!")
     return 0
return generalize_check_lines_common(
         vars_seen,
         global_vars_seen,
         ir_nameless_values,
         IR_VALUE_RE,
         False,
     )
 
 
+def generalize_global_check_line(line, is_analyze, global_vars_seen):
+    [new_line] = generalize_check_lines_common(
+        [line],
+        is_analyze,
+        set(),
+        global_vars_seen,
+        global_nameless_values_w_unstable_ids,
+        GLOBAL_VALUE_RE,
+        False,
+    )
+    return new_line
+
+
 def generalize_asm_check_lines(lines, vars_seen, global_vars_seen):
     return generalize_check_lines_common(
         lines,
         False,
         vars_seen,
         global_vars_seen,
         asm_nameless_values,
         ASM_VALUE_RE,
return add_checks(
         True,
         1,
         global_vars_seen_dict,
         is_filtered,
     )
 
 
 def build_global_values_dictionary(glob_val_dict, raw_tool_output, prefixes):
-    for nameless_value in itertools.chain(ir_nameless_values, asm_nameless_values):
+    for nameless_value in itertools.chain(global_nameless_values, asm_nameless_values):
         if nameless_value.global_ir_rhs_regexp is None:
             continue
 
         lhs_re_str = nameless_value.ir_prefix + nameless_value.ir_regexp
         rhs_re_str = nameless_value.global_ir_rhs_regexp
 
         global_ir_value_re_str = r"^" + lhs_re_str + r"\s=\s" + rhs_re_str + r"$"
         global_ir_value_re = re.compile(global_ir_value_re_str, flags=(re.M))
for nameless_value in itertools.chain(global_nameless_values, asm_nameless_values):
                 if prefix == prefixes[-1]:
                     warn("Found conflicting asm under the same prefix: %r!" % (prefix,))
                 else:
                     glob_val_dict[prefix][nameless_value.check_prefix] = None
                     continue
             glob_val_dict[prefix][nameless_value.check_prefix] = lines
 
 
+def filter_globals_according_to_preference(
+    global_val_lines, global_vars_seen, nameless_value, global_check_setting
+):
+    if global_check_setting == "none":
+        return []
+    if global_check_setting == "all":
+        return global_val_lines
+    assert global_check_setting == "smart"
+
+    if nameless_value.check_key == "#":
+        # attribute sets are usually better checked by --check-attributes
+        return []
+
+    def extract(line, nv):
+        p = (
+            "^"
+            + nv.ir_prefix
+            + "("
+            + nv.ir_regexp
+            + ") = ("
+            + nv.global_ir_rhs_regexp
+            + ")"
+        )
+        match = re.match(p, line)
+        return (match.group(1), re.findall(nv.ir_regexp, match.group(2)))
+
+    transitively_visible = set()
+    contains_refs_to = {}
+
+    def add(var):
+        nonlocal transitively_visible
+        nonlocal contains_refs_to
+        if var in transitively_visible:
+            return
+        transitively_visible.add(var)
+        if not var in contains_refs_to:
+            return
+        for x in contains_refs_to[var]:
+            add(x)
+
+    for line in global_val_lines:
+        (var, refs) = extract(line, nameless_value)
+        contains_refs_to[var] = refs
+    for var, check_key in global_vars_seen:
+        if check_key != nameless_value.check_key:
+            continue
+        add(var)
+    return [
+        line
+        for line in global_val_lines
+        if extract(line, nameless_value)[0] in transitively_visible
+    ]
+
+
+# The capture group is kept as is, followed by a {{.*}} glob
+METADATA_FILTERS = [
+    r"(\w+ version )[\d.]+ \(git@[\w.:/-]+\.git \w+\)",
+    r'(!DIFile\(filename: ".+", directory: )".+"',
+]
+METADATA_FILTERS_RE = [re.compile(s) for s in METADATA_FILTERS]
+
+
+def filter_unstable_metadata(line):
+    for f in METADATA_FILTERS_RE:
+        line = f.sub(r"\1{{.*}}", line)
+    return line
+
+
 def add_global_checks(
     glob_val_dict,
     comment_marker,
     prefix_list,
     output_lines,
     global_vars_seen_dict,
     is_analyze,
     is_before_functions,
+    global_check_setting,
 ):
     printed_prefixes = set()
-    for nameless_value in ir_nameless_values:
-        if nameless_value.global_ir_rhs_regexp is None:
-            continue
+    for nameless_value in global_nameless_values:
         if nameless_value.is_before_functions != is_before_functions:
             continue
         for p in prefix_list:
             global_vars_seen = {}
             checkprefixes = p[0]
             if checkprefixes is None:
                 continue
             for checkprefix in checkprefixes:
                 if checkprefix in global_vars_seen_dict:
                     global_vars_seen.update(global_vars_seen_dict[checkprefix])
                 else:
                     global_vars_seen_dict[checkprefix] = {}
                 if (checkprefix, nameless_value.check_prefix) in printed_prefixes:
                     break
                 if not glob_val_dict[checkprefix]:
                     continue
                 if nameless_value.check_prefix not in glob_val_dict[checkprefix]:
                     continue
                 if not glob_val_dict[checkprefix][nameless_value.check_prefix]:
                     continue
 
                 check_lines = []
                 global_vars_seen_before = [key for key in global_vars_seen.keys()]
-                for line in glob_val_dict[checkprefix][nameless_value.check_prefix]:
+                lines = glob_val_dict[checkprefix][nameless_value.check_prefix]
+                lines = filter_globals_according_to_preference(
+                    lines, global_vars_seen_before, nameless_value, global_check_setting
+                )
+                for line in lines:
                     if _global_value_regex:
                         matched = False
                         for regex in _global_value_regex:
-                            if re.match("^@" + regex + " = ", line):
+                            if re.match("^@" + regex + " = ", line) or re.match(
+                                "^!" + regex + " = ", line
+                            ):
                                 matched = True
                                 break
                         if not matched:
                             continue
-                    tmp = generalize_check_lines(
-                        [line], is_analyze, set(), global_vars_seen
+                    new_line = generalize_global_check_line(
+                        line, is_analyze, global_vars_seen
                     )
-                    check_line = "%s %s: %s" % (comment_marker, checkprefix, tmp[0])
+                    new_line = filter_unstable_metadata(new_line)
+                    check_line = "%s %s: %s" % (comment_marker, checkprefix, new_line)
                     check_lines.append(check_line)
                 if not check_lines:
                     continue
 
                 output_lines.append(comment_marker + SEPARATOR)
                 for check_line in check_lines:
                     output_lines.append(check_line)
 
for part in fc_cmd_parts:
                         % (prefix,)
                     )
 
 
 def get_autogennote_suffix(parser, args):
     autogenerated_note_args = ""
     for action in parser._actions:
         if not hasattr(args, action.dest):
             continue  # Ignore options such as --help that aren't included in args
         # Ignore parameters such as paths to the binary or the list of tests
         if action.dest in (
             "tests",
             "update_only",
             "tool_binary",
             "opt_binary",
             "llc_binary",
             "clang",
             "opt",
             "llvm_bin",
             "verbose",
             "force_update",
         ):
             continue
         value = getattr(args, action.dest)
+        if action.dest == "check_globals":
+            default_value = "none" if args.version < 3 else "smart"
+            if value == default_value:
+                continue
+            autogenerated_note_args += action.option_strings[0] + " "
+            if args.version < 3 and value == "all":
+                continue
+            autogenerated_note_args += "%s " % value
+            continue
         if action.const is not None:  # action stores a constant (usually True/False)
             # Skip actions with different constant values (this happens with boolean
             # --foo/--no-foo options)
             if value != action.const:
                 continue
         if parser.get_default(action.dest) == value:
             continue  # Don't add default values
         if action.dest == "function_signature" and args.version >= 2:

llvm/utils/update_cc_test_checks.py

def config():
     )
     parser.add_argument(
         "--check-attributes",
         action="store_true",
         help='Check "Function Attributes" for functions',
     )
     parser.add_argument(
         "--check-globals",
-        action="store_true",
+        nargs="?",
+        const="all",
+        default="default",
+        choices=["none", "smart", "all"],
         help="Check global entries (global variables, metadata, attribute sets, ...) for functions",
     )
     parser.add_argument("tests", nargs="+")
     args = common.parse_commandline_args(parser)
     infer_dependent_args(args)
 
     if not find_executable(args.clang):
         print("Please specify --llvm-bin or --clang", file=sys.stderr)
):
                         "//",
                         prefixes,
                         func_dict,
                         func,
                         global_vars_seen_dict,
                         is_filtered=builder.is_filtered(),
                     )
 
-            if ti.args.check_globals:
+            if ti.args.check_globals != 'none':
                 generated_prefixes.extend(
                     common.add_global_checks(
                         builder.global_var_dict(),
                         "//",
                         run_list,
                         output_lines,
                         global_vars_seen_dict,
+                        False,
                         True,
-                        True,
+                        ti.args.check_globals,
                     )
                 )
             generated_prefixes.extend(
                 common.add_checks_at_end(
                     output_lines,
                     filecheck_run_list,
                     builder.func_order(),
                     "//",
):
                         ):
                             last_line = output_lines[-1].strip()
                             while last_line == "//":
                                 # Remove the comment line since we will generate a new  comment
                                 # line as part of common.add_ir_checks()
                                 output_lines.pop()
                                 last_line = output_lines[-1].strip()
                             if (
-                                ti.args.check_globals
+                                ti.args.check_globals != 'none'
                                 and not has_checked_pre_function_globals
                             ):
                                 generated_prefixes.extend(
                                     common.add_global_checks(
                                         builder.global_var_dict(),
                                         "//",
                                         run_list,
                                         output_lines,
                                         global_vars_seen_dict,
+                                        False,
                                         True,
-                                        True,
+                                        ti.args.check_globals,
                                     )
                                 )
                                 has_checked_pre_function_globals = True
                             if added:
                                 output_lines.append("//")
                             added.add(mangled)
                             generated_prefixes.extend(
                                 common.add_ir_checks(
):
                                 )
                             )
                             if line.rstrip("\n") == "//":
                                 include_line = False
 
                 if include_line:
                     output_lines.append(line.rstrip("\n"))
 
-        if ti.args.check_globals:
+        if ti.args.check_globals != 'none':
             generated_prefixes.extend(
                 common.add_global_checks(
                     builder.global_var_dict(),
                     "//",
                     run_list,
                     output_lines,
                     global_vars_seen_dict,
-                    True,
                     False,
+                    False,
+                    ti.args.check_globals,
                 )
             )
         if ti.args.gen_unused_prefix_body:
             output_lines.extend(
                 ti.get_checks_for_unused_prefixes(run_list, generated_prefixes)
             )
         common.debug("Writing %d lines to %s..." % (len(output_lines), ti.path))
         with open(ti.path, "wb") as f:
             f.writelines(["{}\n".format(l).encode("utf-8") for l in output_lines])
 
     return 0
 
 
 if __name__ == "__main__":
     sys.exit(main())

llvm/utils/update_test_checks.py

def main():
     )
     parser.add_argument(
         "--check-attributes",
         action="store_true",
         help='Check "Function Attributes" for functions',
     )
     parser.add_argument(
         "--check-globals",
-        action="store_true",
+        nargs="?",
+        const="all",
+        default="default",
+        choices=["none", "smart", "all"],
         help="Check global entries (global variables, metadata, attribute sets, ...) for functions",
     )
     parser.add_argument("tests", nargs="+")
     initial_args = common.parse_commandline_args(parser)
 
     script_name = os.path.basename(__file__)
 
     if initial_args.tool_binary:
):
             # works properly.  func_order provides that.
 
             # We can't predict where various passes might insert functions so we can't
             # be sure the input function order is maintained.  Therefore, first spit
             # out all the source lines.
             common.dump_input_lines(output_lines, ti, prefix_set, ";")
 
             args = ti.args
-            if args.check_globals:
+            if args.check_globals != 'none':
                 generated_prefixes.extend(
                     common.add_global_checks(
                         builder.global_var_dict(),
                         ";",
                         prefix_list,
                         output_lines,
                         global_vars_seen_dict,
                         args.preserve_names,
                         True,
+                        args.check_globals,
                     )
                 )
 
             # Now generate all the checks.
             generated_prefixes.extend(
                 common.add_checks_at_end(
                     output_lines,
                     prefix_list,
):
                             common.add_global_checks(
                                 builder.global_var_dict(),
                                 ";",
                                 prefix_list,
                                 output_lines,
                                 global_vars_seen_dict,
                                 args.preserve_names,
                                 True,
+                                args.check_globals,
                             )
                         )
                     has_checked_pre_function_globals = True
 
                 if common.should_add_line_to_output(
                     input_line, prefix_set, not is_in_function
                 ):
                     # This input line of the function body will go as-is into the output.
):
                 if not m:
                     continue
                 func_name = m.group(1)
                 if args.function is not None and func_name != args.function:
                     # When filtering on a specific function, skip all others.
                     continue
                 is_in_function = is_in_function_start = True
 
-        if args.check_globals:
+        if args.check_globals != 'none':
             generated_prefixes.extend(
                 common.add_global_checks(
                     builder.global_var_dict(),
                     ";",
                     prefix_list,
                     output_lines,
                     global_vars_seen_dict,
                     args.preserve_names,
                     False,
+                    args.check_globals,
                 )
             )
         if ti.args.gen_unused_prefix_body:
             output_lines.extend(
                 ti.get_checks_for_unused_prefixes(prefix_list, generated_prefixes)
             )
         common.debug("Writing %d lines to %s..." % (len(output_lines), ti.path))
 
         with open(ti.path, "wb") as f:
             f.writelines(["{}\n".format(l).encode("utf-8") for l in output_lines])
 
 
 if __name__ == "__main__":
     main()