[UpdateTestChecks] Match unnamed values like "@[0-9]+" and "![0-9]+"

[jdoerfert]

Summary

With this patch we will match most *uses* of "temporary" named things in
the IR via regular expressions, not their name at creation time. The new
"values" we match are:

• "unnamed" globals: @[0-9]+
• debug metadata: !dbg ![0-9]+
• loop metadata: !loop ![0-9]+
• tbaa metadata: !tbaa ![0-9]+
• range metadata: !range ![0-9]+
• generic metadata: metadata ![0-9]+
• attributes groups: #[0-9]

We still don't match the declarations but that can be done later. This
patch can introduce churn when existing check lines contain the old
hardcoded versions of the above "values". We can add a flag to opt-out,
or opt-in, if necessary.

[jdoerfert]

Will update the clang tests shortly.

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

118

Maybe I add matchers for these next.

[sstefan1]

lgtm, apart from clang tests. Someone else should take a look as well, though.

llvm/utils/UpdateTestChecks/common.py

302

typo: unnamed.

304

typo: group

[MaskRay]

llvm/utils/UpdateTestChecks/common.py

319

Is this a capturing group? If not, use `(?:\s+)

The 3 in the range(3, match.lastindex): below looks strange. I hope we can get rid if it.

327

Use non-capturing group

420

Do you have an example that not substituting repeatedly can fail?

[jdoerfert]

llvm/utils/UpdateTestChecks/common.py

319

It is, we use in 386 for example. I did not change that part.

The 3 is a bit magic, I agree. It basically is to skip this group, the outer group of all "IR values", which I could avoid and the entire match. We have to have some hardcoded values there though, like before. Though I can make it a variable to explain better.

327

We use this in 386 and other places.

420

Line 8 in llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/various_ir_values.ll.funcsig.expected :)

[MaskRay]

llvm/utils/UpdateTestChecks/common.py

307

[[ATTRIBUTES0:#.*]] is very long. I wonder whether we should abbreviate it to ATTR0 or the like.

307

Instead of Structure of arrays, would it be better organizing these constants as Array of structures?

For example, you can write ['TMP', '%', r'[\w.-]+?'], ['GLOBAL', '@', ...], ...

307

Tuples should be better: [('TMP', '%', r'[\w.-]+?'), ('GLOBAL', '@', ...), ...]

[jdoerfert]

llvm/utils/UpdateTestChecks/common.py

307

I thought about it afterwards as well. Will make it a class so it's easier to see what is what.

[arichardson]

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

20

Since we are capturing the attribute number instead of using a #{{[0-9]+}} regex, should we be using a non-capturing [[ATTRIBUTES0]] after the first time?

I guess this would require something like global_vars_seen in addition to vars_seen

[jdoerfert]

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

20

Argh, good catch. Will fix this for sure.

[jdoerfert]

global_seen_vars, better grouping of inormation, addressed comments

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

20

I think here it actually made sense to capture the name again, it is a different prefix after all. However, I did introduce the global_vars_seen now changed the test to include two functions. All but %{{.*}} values are considered global and we will reuse the existing mapping from the same prefix. You can see tbaa is reused in the test.

[jdoerfert]

Update clang tests

[MaskRay]

Mostly looks good.

llvm/utils/UpdateTestChecks/common.py

309

nameless_values = [
    NamelessValue(r'TMP',  r'%',            r'[\w.-]+?'),
    NamelessValue(r'TMP',  r'%',            r'[\w.-]+?'),
    ...
]

330

Can the suffix use (?:...)?

420

This is indeed strange. If we don't have a good explanation, probably worth adding count=1

[jdoerfert]

added @MaskRays's tweaks

[jdoerfert]

(I'm going to sneak in !range ! as well)

llvm/utils/UpdateTestChecks/common.py

330

We use the captured value later, and I guess people want to keep the exact same "spaces". TBH, it won't make much difference to the logic anywhere (we'd still use match.lastindex). All it would do is it would make us "unify" the output, unsure if that is what we want.

[MaskRay]

LGTM. I don't have further comments. Worth waiting for other opinions.

[arichardson]

LGTM.

[thakis]

llvm/utils/UpdateTestChecks/common.py

390

This is Py3.4+. Per https://llvm.org/docs/GettingStarted.html#id7 we still support 2.7, which is why all my bots run that, which is why this breaks my bots :) (...and everyone still using Python 2.7 locally). Can you do this some other way? Maybe just surround the re with "^..$'?

[jdoerfert]

llvm/utils/UpdateTestChecks/common.py

390

Addressed and restored actual functionality in 07448c550457d2afb1e7d69254a58ad44dece3d2

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

 // CHECK-NEXT:    ret void
 //
 Foo::Foo(int x) : x(x) {}
 // CHECK-LABEL: @_ZN3FooD1Ev(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %class.Foo*, align 8
 // CHECK-NEXT:    store %class.Foo* [[THIS:%.*]], %class.Foo** [[THIS_ADDR]], align 8
 // CHECK-NEXT:    [[THIS1:%.*]] = load %class.Foo*, %class.Foo** [[THIS_ADDR]], align 8
-// CHECK-NEXT:    call void @_ZN3FooD2Ev(%class.Foo* [[THIS1]]) #2
+// CHECK-NEXT:    call void @_ZN3FooD2Ev(%class.Foo* [[THIS1]]) [[ATTR2:#.*]]
 // CHECK-NEXT:    ret void
 //
 Foo::~Foo() {}
 // CHECK-LABEL: @_ZNK3Foo28function_defined_out_of_lineEi(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[THIS_ADDR:%.*]] = alloca %class.Foo*, align 8
 // CHECK-NEXT:    [[ARG_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    store %class.Foo* [[THIS:%.*]], %class.Foo** [[THIS_ADDR]], align 8

 
 // Call the inline methods to ensure the LLVM IR is generated:
 // CHECK-LABEL: @main(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[F:%.*]] = alloca [[CLASS_FOO:%.*]], align 4
 // CHECK-NEXT:    call void @_ZN3FooC1Ei(%class.Foo* [[F]], i32 1)
 // CHECK-NEXT:    [[CALL:%.*]] = call i32 @_ZNK3Foo23function_defined_inlineEi(%class.Foo* [[F]], i32 2)
 // CHECK-NEXT:    [[CALL1:%.*]] = call i32 @_ZNK3Foo28function_defined_out_of_lineEi(%class.Foo* [[F]], i32 3)
-// CHECK-NEXT:    call void @_ZN3FooD1Ev(%class.Foo* [[F]]) #2
+// CHECK-NEXT:    call void @_ZN3FooD1Ev(%class.Foo* [[F]]) [[ATTR2]]
 // CHECK-NEXT:    ret i32 0
 //
 int main() {
   Foo f(1);
   f.function_defined_inline(2);
   f.function_defined_out_of_line(3);
 }

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

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

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; RUN: opt -attributor -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
 
 %struct.RT = type { i8, [10 x [20 x i32]], i8 }
 %struct.ST = type { i32, double, %struct.RT }
 
 define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
 ; IS__TUNIT____: Function Attrs: nofree nosync nounwind optsize readnone ssp uwtable willreturn
 ; IS__TUNIT____-LABEL: define {{[^@]+}}@foo
-; IS__TUNIT____-SAME: (%struct.ST* nofree readnone [[S:%.*]]) #0
+; IS__TUNIT____-SAME: (%struct.ST* nofree readnone [[S:%.*]]) [[ATTR0:#.*]]
 ; IS__TUNIT____-NEXT:  entry:
 ; IS__TUNIT____-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; IS__TUNIT____-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 ; IS__CGSCC____: Function Attrs: nofree norecurse nosync nounwind optsize readnone ssp uwtable willreturn
 ; IS__CGSCC____-LABEL: define {{[^@]+}}@foo
-; IS__CGSCC____-SAME: (%struct.ST* nofree readnone [[S:%.*]]) #0
+; IS__CGSCC____-SAME: (%struct.ST* nofree readnone [[S:%.*]]) [[ATTR0:#.*]]
 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; IS__CGSCC____-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 entry:
   %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
   ret i32* %arrayidx
 }

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
 ; RUN: opt -attributor -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_NPM,NOT_CGSCC_OPM,NOT_TUNIT_NPM,IS__TUNIT____,IS________OPM,IS__TUNIT_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_CGSCC_OPM,NOT_CGSCC_NPM,NOT_TUNIT_OPM,IS__TUNIT____,IS________NPM,IS__TUNIT_NPM
 ; RUN: opt -attributor-cgscc -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_NPM,IS__CGSCC____,IS________OPM,IS__CGSCC_OPM
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -S < %s | FileCheck %s --check-prefixes=CHECK,NOT_TUNIT_NPM,NOT_TUNIT_OPM,NOT_CGSCC_OPM,IS__CGSCC____,IS________NPM,IS__CGSCC_NPM
 
 %struct.RT = type { i8, [10 x [20 x i32]], i8 }
 %struct.ST = type { i32, double, %struct.RT }
 
 define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
 ; CHECK-LABEL: define {{[^@]+}}@foo
-; CHECK-SAME: (%struct.ST* nofree readnone [[S:%.*]]) #0
+; CHECK-SAME: (%struct.ST* nofree readnone [[S:%.*]]) [[ATTR0:#.*]]
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; CHECK-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 entry:
   %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
   ret i32* %arrayidx
 }

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

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

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

+; Just run it through opt, no passes needed.
+; RUN: opt < %s -S | FileCheck %s
+
+; ModuleID = 'various_ir_values.c'
+source_filename = "various_ir_values.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo(i32* %A) #0 !dbg !7 {
+entry:
+  %A.addr = alloca i32*, align 8
+  %i = alloca i32, align 4
+  store i32* %A, i32** %A.addr, align 8, !tbaa !16
+  call void @llvm.dbg.declare(metadata i32** %A.addr, metadata !13, metadata !DIExpression()), !dbg !20
+  %0 = bitcast i32* %i to i8*, !dbg !21
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3, !dbg !21
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !14, metadata !DIExpression()), !dbg !22
+  store i32 0, i32* %i, align 4, !dbg !22, !tbaa !23
+  br label %for.cond, !dbg !21
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %1 = load i32, i32* %i, align 4, !dbg !25, !tbaa !23
+  %2 = load i32*, i32** %A.addr, align 8, !dbg !27, !tbaa !16
+  %3 = load i32, i32* %2, align 4, !dbg !28, !tbaa !23
+  %cmp = icmp slt i32 %1, %3, !dbg !29
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !30
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %4 = bitcast i32* %i to i8*, !dbg !31
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* %4) #3, !dbg !31
+  br label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %5 = load i32*, i32** %A.addr, align 8, !dbg !32, !tbaa !16
+  %6 = load i32, i32* %i, align 4, !dbg !33, !tbaa !23
+  %idxprom = sext i32 %6 to i64, !dbg !32
+  %arrayidx = getelementptr inbounds i32, i32* %5, i64 %idxprom, !dbg !32
+  store i32 0, i32* %arrayidx, align 4, !dbg !34, !tbaa !23
+  br label %for.inc, !dbg !32
+
+for.inc:                                          ; preds = %for.body
+  %7 = load i32, i32* %i, align 4, !dbg !35, !tbaa !23
+  %inc = add nsw i32 %7, 1, !dbg !35
+  store i32 %inc, i32* %i, align 4, !dbg !35, !tbaa !23
+  br label %for.cond, !dbg !31, !llvm.loop !36
+
+for.end:                                          ; preds = %for.cond.cleanup
+  ret void, !dbg !38
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #2
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #2
+
+; Function Attrs: nounwind uwtable
+define dso_local void @bar(i32* %A) #0 !dbg !39 {
+entry:
+  %A.addr = alloca i32*, align 8
+  %i = alloca i32, align 4
+  store i32* %A, i32** %A.addr, align 8, !tbaa !16
+  call void @llvm.dbg.declare(metadata i32** %A.addr, metadata !41, metadata !DIExpression()), !dbg !44
+  %0 = bitcast i32* %i to i8*, !dbg !45
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3, !dbg !45
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !42, metadata !DIExpression()), !dbg !46
+  store i32 0, i32* %i, align 4, !dbg !46, !tbaa !23
+  br label %for.cond, !dbg !45
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %1 = load i32, i32* %i, align 4, !dbg !47, !tbaa !23
+  %2 = load i32*, i32** %A.addr, align 8, !dbg !49, !tbaa !16
+  %3 = load i32, i32* %2, align 4, !dbg !50, !tbaa !23
+  %cmp = icmp slt i32 %1, %3, !dbg !51
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !52
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %4 = bitcast i32* %i to i8*, !dbg !53
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* %4) #3, !dbg !53
+  br label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %5 = load i32*, i32** %A.addr, align 8, !dbg !54, !tbaa !16
+  %6 = load i32, i32* %i, align 4, !dbg !55, !tbaa !23
+  %idxprom = sext i32 %6 to i64, !dbg !54
+  %arrayidx = getelementptr inbounds i32, i32* %5, i64 %idxprom, !dbg !54
+  store i32 0, i32* %arrayidx, align 4, !dbg !56, !tbaa !23
+  br label %for.inc, !dbg !54
+
+for.inc:                                          ; preds = %for.body
+  %7 = load i32, i32* %i, align 4, !dbg !57, !tbaa !23
+  %inc = add nsw i32 %7, 1, !dbg !57
+  store i32 %inc, i32* %i, align 4, !dbg !57, !tbaa !23
+  br label %for.cond, !dbg !53, !llvm.loop !58
+
+for.end:                                          ; preds = %for.cond.cleanup
+  ret void, !dbg !60
+}
+
+attributes #0 = { 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" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+attributes #2 = { argmemonly nounwind willreturn }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = 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)
+!1 = !DIFile(filename: "various_ir_values.c", directory: "/data/build/llvm-project")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !{!13, !14}
+!13 = !DILocalVariable(name: "A", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!14 = !DILocalVariable(name: "i", scope: !15, file: !1, line: 3, type: !11)
+!15 = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
+!16 = !{!17, !17, i64 0}
+!17 = !{!"any pointer", !18, i64 0}
+!18 = !{!"omnipotent char", !19, i64 0}
+!19 = !{!"Simple C/C++ TBAA"}
+!20 = !DILocation(line: 1, column: 15, scope: !7)
+!21 = !DILocation(line: 3, column: 8, scope: !15)
+!22 = !DILocation(line: 3, column: 12, scope: !15)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"int", !18, i64 0}
+!25 = !DILocation(line: 3, column: 19, scope: !26)
+!26 = distinct !DILexicalBlock(scope: !15, file: !1, line: 3, column: 3)
+!27 = !DILocation(line: 3, column: 24, scope: !26)
+!28 = !DILocation(line: 3, column: 23, scope: !26)
+!29 = !DILocation(line: 3, column: 21, scope: !26)
+!30 = !DILocation(line: 3, column: 3, scope: !15)
+!31 = !DILocation(line: 3, column: 3, scope: !26)
+!32 = !DILocation(line: 4, column: 5, scope: !26)
+!33 = !DILocation(line: 4, column: 7, scope: !26)
+!34 = !DILocation(line: 4, column: 10, scope: !26)
+!35 = !DILocation(line: 3, column: 27, scope: !26)
+!36 = distinct !{!36, !30, !37}
+!37 = !DILocation(line: 4, column: 12, scope: !15)
+!38 = !DILocation(line: 5, column: 1, scope: !7)
+!39 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 7, type: !8, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !40)
+!40 = !{!41, !42}
+!41 = !DILocalVariable(name: "A", arg: 1, scope: !39, file: !1, line: 7, type: !10)
+!42 = !DILocalVariable(name: "i", scope: !43, file: !1, line: 9, type: !11)
+!43 = distinct !DILexicalBlock(scope: !39, file: !1, line: 9, column: 3)
+!44 = !DILocation(line: 7, column: 15, scope: !39)
+!45 = !DILocation(line: 9, column: 8, scope: !43)
+!46 = !DILocation(line: 9, column: 12, scope: !43)
+!47 = !DILocation(line: 9, column: 19, scope: !48)
+!48 = distinct !DILexicalBlock(scope: !43, file: !1, line: 9, column: 3)
+!49 = !DILocation(line: 9, column: 24, scope: !48)
+!50 = !DILocation(line: 9, column: 23, scope: !48)
+!51 = !DILocation(line: 9, column: 21, scope: !48)
+!52 = !DILocation(line: 9, column: 3, scope: !43)
+!53 = !DILocation(line: 9, column: 3, scope: !48)
+!54 = !DILocation(line: 10, column: 5, scope: !48)
+!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)

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; Just run it through opt, no passes needed.
+; RUN: opt < %s -S | FileCheck %s
+
+; ModuleID = 'various_ir_values.c'
+source_filename = "various_ir_values.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo(i32* %A) #0 !dbg !7 {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32*, align 8
+; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    store i32* [[A:%.*]], i32** [[A_ADDR]], align 8, [[TBAA16:!tbaa !.*]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32** [[A_ADDR]], [[META13:metadata !.*]], metadata !DIExpression()), [[DBG20:!dbg !.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[I]] to i8*, [[DBG21:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* [[TMP0]]) [[ATTR3:#.*]], [[DBG21]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32* [[I]], [[META14:metadata !.*]], metadata !DIExpression()), [[DBG22:!dbg !.*]]
+; CHECK-NEXT:    store i32 0, i32* [[I]], align 4, [[DBG22]], [[TBAA23:!tbaa !.*]]
+; CHECK-NEXT:    br label [[FOR_COND:%.*]], [[DBG21]]
+; CHECK:       for.cond:
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4, [[DBG25:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG27:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4, [[DBG28:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[TMP3]], [[DBG29:!dbg !.*]]
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]], [[DBG30:!dbg !.*]]
+; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    [[TMP4:%.*]] = bitcast i32* [[I]] to i8*, [[DBG31:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 4, i8* [[TMP4]]) [[ATTR3]], [[DBG31]]
+; CHECK-NEXT:    br label [[FOR_END:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[TMP5:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG32:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP6:%.*]] = load i32, i32* [[I]], align 4, [[DBG33:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP6]] to i64, [[DBG32]]
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[TMP5]], i64 [[IDXPROM]], [[DBG32]]
+; CHECK-NEXT:    store i32 0, i32* [[ARRAYIDX]], align 4, [[DBG34:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_INC:%.*]], [[DBG32]]
+; CHECK:       for.inc:
+; CHECK-NEXT:    [[TMP7:%.*]] = load i32, i32* [[I]], align 4, [[DBG35:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP7]], 1, [[DBG35]]
+; CHECK-NEXT:    store i32 [[INC]], i32* [[I]], align 4, [[DBG35]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_COND]], [[DBG31]], [[LOOP36:!llvm.loop !.*]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void, [[DBG38:!dbg !.*]]
+;
+entry:
+  %A.addr = alloca i32*, align 8
+  %i = alloca i32, align 4
+  store i32* %A, i32** %A.addr, align 8, !tbaa !16
+  call void @llvm.dbg.declare(metadata i32** %A.addr, metadata !13, metadata !DIExpression()), !dbg !20
+  %0 = bitcast i32* %i to i8*, !dbg !21
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3, !dbg !21
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !14, metadata !DIExpression()), !dbg !22
+  store i32 0, i32* %i, align 4, !dbg !22, !tbaa !23
+  br label %for.cond, !dbg !21
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %1 = load i32, i32* %i, align 4, !dbg !25, !tbaa !23
+  %2 = load i32*, i32** %A.addr, align 8, !dbg !27, !tbaa !16
+  %3 = load i32, i32* %2, align 4, !dbg !28, !tbaa !23
+  %cmp = icmp slt i32 %1, %3, !dbg !29
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !30
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %4 = bitcast i32* %i to i8*, !dbg !31
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* %4) #3, !dbg !31
+  br label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %5 = load i32*, i32** %A.addr, align 8, !dbg !32, !tbaa !16
+  %6 = load i32, i32* %i, align 4, !dbg !33, !tbaa !23
+  %idxprom = sext i32 %6 to i64, !dbg !32
+  %arrayidx = getelementptr inbounds i32, i32* %5, i64 %idxprom, !dbg !32
+  store i32 0, i32* %arrayidx, align 4, !dbg !34, !tbaa !23
+  br label %for.inc, !dbg !32
+
+for.inc:                                          ; preds = %for.body
+  %7 = load i32, i32* %i, align 4, !dbg !35, !tbaa !23
+  %inc = add nsw i32 %7, 1, !dbg !35
+  store i32 %inc, i32* %i, align 4, !dbg !35, !tbaa !23
+  br label %for.cond, !dbg !31, !llvm.loop !36
+
+for.end:                                          ; preds = %for.cond.cleanup
+  ret void, !dbg !38
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #2
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #2
+
+; Function Attrs: nounwind uwtable
+define dso_local void @bar(i32* %A) #0 !dbg !39 {
+; CHECK-LABEL: @bar(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32*, align 8
+; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    store i32* [[A:%.*]], i32** [[A_ADDR]], align 8, [[TBAA16]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32** [[A_ADDR]], [[META41:metadata !.*]], metadata !DIExpression()), [[DBG44:!dbg !.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[I]] to i8*, [[DBG45:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* [[TMP0]]) [[ATTR3]], [[DBG45]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32* [[I]], [[META42:metadata !.*]], metadata !DIExpression()), [[DBG46:!dbg !.*]]
+; CHECK-NEXT:    store i32 0, i32* [[I]], align 4, [[DBG46]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_COND:%.*]], [[DBG45]]
+; CHECK:       for.cond:
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4, [[DBG47:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG49:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4, [[DBG50:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[TMP3]], [[DBG51:!dbg !.*]]
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]], [[DBG52:!dbg !.*]]
+; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    [[TMP4:%.*]] = bitcast i32* [[I]] to i8*, [[DBG53:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 4, i8* [[TMP4]]) [[ATTR3]], [[DBG53]]
+; CHECK-NEXT:    br label [[FOR_END:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[TMP5:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG54:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP6:%.*]] = load i32, i32* [[I]], align 4, [[DBG55:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP6]] to i64, [[DBG54]]
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[TMP5]], i64 [[IDXPROM]], [[DBG54]]
+; CHECK-NEXT:    store i32 0, i32* [[ARRAYIDX]], align 4, [[DBG56:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_INC:%.*]], [[DBG54]]
+; CHECK:       for.inc:
+; CHECK-NEXT:    [[TMP7:%.*]] = load i32, i32* [[I]], align 4, [[DBG57:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP7]], 1, [[DBG57]]
+; CHECK-NEXT:    store i32 [[INC]], i32* [[I]], align 4, [[DBG57]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_COND]], [[DBG53]], [[LOOP58:!llvm.loop !.*]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void, [[DBG60:!dbg !.*]]
+;
+entry:
+  %A.addr = alloca i32*, align 8
+  %i = alloca i32, align 4
+  store i32* %A, i32** %A.addr, align 8, !tbaa !16
+  call void @llvm.dbg.declare(metadata i32** %A.addr, metadata !41, metadata !DIExpression()), !dbg !44
+  %0 = bitcast i32* %i to i8*, !dbg !45
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3, !dbg !45
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !42, metadata !DIExpression()), !dbg !46
+  store i32 0, i32* %i, align 4, !dbg !46, !tbaa !23
+  br label %for.cond, !dbg !45
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %1 = load i32, i32* %i, align 4, !dbg !47, !tbaa !23
+  %2 = load i32*, i32** %A.addr, align 8, !dbg !49, !tbaa !16
+  %3 = load i32, i32* %2, align 4, !dbg !50, !tbaa !23
+  %cmp = icmp slt i32 %1, %3, !dbg !51
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !52
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %4 = bitcast i32* %i to i8*, !dbg !53
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* %4) #3, !dbg !53
+  br label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %5 = load i32*, i32** %A.addr, align 8, !dbg !54, !tbaa !16
+  %6 = load i32, i32* %i, align 4, !dbg !55, !tbaa !23
+  %idxprom = sext i32 %6 to i64, !dbg !54
+  %arrayidx = getelementptr inbounds i32, i32* %5, i64 %idxprom, !dbg !54
+  store i32 0, i32* %arrayidx, align 4, !dbg !56, !tbaa !23
+  br label %for.inc, !dbg !54
+
+for.inc:                                          ; preds = %for.body
+  %7 = load i32, i32* %i, align 4, !dbg !57, !tbaa !23
+  %inc = add nsw i32 %7, 1, !dbg !57
+  store i32 %inc, i32* %i, align 4, !dbg !57, !tbaa !23
+  br label %for.cond, !dbg !53, !llvm.loop !58
+
+for.end:                                          ; preds = %for.cond.cleanup
+  ret void, !dbg !60
+}
+
+attributes #0 = { 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" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+attributes #2 = { argmemonly nounwind willreturn }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = 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)
+!1 = !DIFile(filename: "various_ir_values.c", directory: "/data/build/llvm-project")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !{!13, !14}
+!13 = !DILocalVariable(name: "A", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!14 = !DILocalVariable(name: "i", scope: !15, file: !1, line: 3, type: !11)
+!15 = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
+!16 = !{!17, !17, i64 0}
+!17 = !{!"any pointer", !18, i64 0}
+!18 = !{!"omnipotent char", !19, i64 0}
+!19 = !{!"Simple C/C++ TBAA"}
+!20 = !DILocation(line: 1, column: 15, scope: !7)
+!21 = !DILocation(line: 3, column: 8, scope: !15)
+!22 = !DILocation(line: 3, column: 12, scope: !15)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"int", !18, i64 0}
+!25 = !DILocation(line: 3, column: 19, scope: !26)
+!26 = distinct !DILexicalBlock(scope: !15, file: !1, line: 3, column: 3)
+!27 = !DILocation(line: 3, column: 24, scope: !26)
+!28 = !DILocation(line: 3, column: 23, scope: !26)
+!29 = !DILocation(line: 3, column: 21, scope: !26)
+!30 = !DILocation(line: 3, column: 3, scope: !15)
+!31 = !DILocation(line: 3, column: 3, scope: !26)
+!32 = !DILocation(line: 4, column: 5, scope: !26)
+!33 = !DILocation(line: 4, column: 7, scope: !26)
+!34 = !DILocation(line: 4, column: 10, scope: !26)
+!35 = !DILocation(line: 3, column: 27, scope: !26)
+!36 = distinct !{!36, !30, !37}
+!37 = !DILocation(line: 4, column: 12, scope: !15)
+!38 = !DILocation(line: 5, column: 1, scope: !7)
+!39 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 7, type: !8, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !40)
+!40 = !{!41, !42}
+!41 = !DILocalVariable(name: "A", arg: 1, scope: !39, file: !1, line: 7, type: !10)
+!42 = !DILocalVariable(name: "i", scope: !43, file: !1, line: 9, type: !11)
+!43 = distinct !DILexicalBlock(scope: !39, file: !1, line: 9, column: 3)
+!44 = !DILocation(line: 7, column: 15, scope: !39)
+!45 = !DILocation(line: 9, column: 8, scope: !43)
+!46 = !DILocation(line: 9, column: 12, scope: !43)
+!47 = !DILocation(line: 9, column: 19, scope: !48)
+!48 = distinct !DILexicalBlock(scope: !43, file: !1, line: 9, column: 3)
+!49 = !DILocation(line: 9, column: 24, scope: !48)
+!50 = !DILocation(line: 9, column: 23, scope: !48)
+!51 = !DILocation(line: 9, column: 21, scope: !48)
+!52 = !DILocation(line: 9, column: 3, scope: !43)
+!53 = !DILocation(line: 9, column: 3, scope: !48)
+!54 = !DILocation(line: 10, column: 5, scope: !48)
+!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)

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
+; Just run it through opt, no passes needed.
+; RUN: opt < %s -S | FileCheck %s
+
+; ModuleID = 'various_ir_values.c'
+source_filename = "various_ir_values.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo(i32* %A) #0 !dbg !7 {
+; CHECK-LABEL: define {{[^@]+}}@foo
+; CHECK-SAME: (i32* [[A:%.*]]) [[ATTR0:#.*]] [[DBG7:!dbg !.*]]
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32*, align 8
+; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    store i32* [[A]], i32** [[A_ADDR]], align 8, [[TBAA16:!tbaa !.*]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32** [[A_ADDR]], [[META13:metadata !.*]], metadata !DIExpression()), [[DBG20:!dbg !.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[I]] to i8*, [[DBG21:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* [[TMP0]]) [[ATTR3:#.*]], [[DBG21]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32* [[I]], [[META14:metadata !.*]], metadata !DIExpression()), [[DBG22:!dbg !.*]]
+; CHECK-NEXT:    store i32 0, i32* [[I]], align 4, [[DBG22]], [[TBAA23:!tbaa !.*]]
+; CHECK-NEXT:    br label [[FOR_COND:%.*]], [[DBG21]]
+; CHECK:       for.cond:
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4, [[DBG25:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG27:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4, [[DBG28:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[TMP3]], [[DBG29:!dbg !.*]]
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]], [[DBG30:!dbg !.*]]
+; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    [[TMP4:%.*]] = bitcast i32* [[I]] to i8*, [[DBG31:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 4, i8* [[TMP4]]) [[ATTR3]], [[DBG31]]
+; CHECK-NEXT:    br label [[FOR_END:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[TMP5:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG32:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP6:%.*]] = load i32, i32* [[I]], align 4, [[DBG33:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP6]] to i64, [[DBG32]]
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[TMP5]], i64 [[IDXPROM]], [[DBG32]]
+; CHECK-NEXT:    store i32 0, i32* [[ARRAYIDX]], align 4, [[DBG34:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_INC:%.*]], [[DBG32]]
+; CHECK:       for.inc:
+; CHECK-NEXT:    [[TMP7:%.*]] = load i32, i32* [[I]], align 4, [[DBG35:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP7]], 1, [[DBG35]]
+; CHECK-NEXT:    store i32 [[INC]], i32* [[I]], align 4, [[DBG35]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_COND]], [[DBG31]], [[LOOP36:!llvm.loop !.*]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void, [[DBG38:!dbg !.*]]
+;
+entry:
+  %A.addr = alloca i32*, align 8
+  %i = alloca i32, align 4
+  store i32* %A, i32** %A.addr, align 8, !tbaa !16
+  call void @llvm.dbg.declare(metadata i32** %A.addr, metadata !13, metadata !DIExpression()), !dbg !20
+  %0 = bitcast i32* %i to i8*, !dbg !21
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3, !dbg !21
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !14, metadata !DIExpression()), !dbg !22
+  store i32 0, i32* %i, align 4, !dbg !22, !tbaa !23
+  br label %for.cond, !dbg !21
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %1 = load i32, i32* %i, align 4, !dbg !25, !tbaa !23
+  %2 = load i32*, i32** %A.addr, align 8, !dbg !27, !tbaa !16
+  %3 = load i32, i32* %2, align 4, !dbg !28, !tbaa !23
+  %cmp = icmp slt i32 %1, %3, !dbg !29
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !30
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %4 = bitcast i32* %i to i8*, !dbg !31
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* %4) #3, !dbg !31
+  br label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %5 = load i32*, i32** %A.addr, align 8, !dbg !32, !tbaa !16
+  %6 = load i32, i32* %i, align 4, !dbg !33, !tbaa !23
+  %idxprom = sext i32 %6 to i64, !dbg !32
+  %arrayidx = getelementptr inbounds i32, i32* %5, i64 %idxprom, !dbg !32
+  store i32 0, i32* %arrayidx, align 4, !dbg !34, !tbaa !23
+  br label %for.inc, !dbg !32
+
+for.inc:                                          ; preds = %for.body
+  %7 = load i32, i32* %i, align 4, !dbg !35, !tbaa !23
+  %inc = add nsw i32 %7, 1, !dbg !35
+  store i32 %inc, i32* %i, align 4, !dbg !35, !tbaa !23
+  br label %for.cond, !dbg !31, !llvm.loop !36
+
+for.end:                                          ; preds = %for.cond.cleanup
+  ret void, !dbg !38
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #2
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #2
+
+; Function Attrs: nounwind uwtable
+define dso_local void @bar(i32* %A) #0 !dbg !39 {
+; CHECK-LABEL: define {{[^@]+}}@bar
+; CHECK-SAME: (i32* [[A:%.*]]) [[ATTR0]] [[DBG39:!dbg !.*]]
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32*, align 8
+; CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    store i32* [[A]], i32** [[A_ADDR]], align 8, [[TBAA16]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32** [[A_ADDR]], [[META41:metadata !.*]], metadata !DIExpression()), [[DBG44:!dbg !.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[I]] to i8*, [[DBG45:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 4, i8* [[TMP0]]) [[ATTR3]], [[DBG45]]
+; CHECK-NEXT:    call void @llvm.dbg.declare(metadata i32* [[I]], [[META42:metadata !.*]], metadata !DIExpression()), [[DBG46:!dbg !.*]]
+; CHECK-NEXT:    store i32 0, i32* [[I]], align 4, [[DBG46]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_COND:%.*]], [[DBG45]]
+; CHECK:       for.cond:
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4, [[DBG47:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[TMP2:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG49:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4, [[DBG50:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[TMP3]], [[DBG51:!dbg !.*]]
+; CHECK-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]], [[DBG52:!dbg !.*]]
+; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    [[TMP4:%.*]] = bitcast i32* [[I]] to i8*, [[DBG53:!dbg !.*]]
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 4, i8* [[TMP4]]) [[ATTR3]], [[DBG53]]
+; CHECK-NEXT:    br label [[FOR_END:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[TMP5:%.*]] = load i32*, i32** [[A_ADDR]], align 8, [[DBG54:!dbg !.*]], [[TBAA16]]
+; CHECK-NEXT:    [[TMP6:%.*]] = load i32, i32* [[I]], align 4, [[DBG55:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP6]] to i64, [[DBG54]]
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[TMP5]], i64 [[IDXPROM]], [[DBG54]]
+; CHECK-NEXT:    store i32 0, i32* [[ARRAYIDX]], align 4, [[DBG56:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_INC:%.*]], [[DBG54]]
+; CHECK:       for.inc:
+; CHECK-NEXT:    [[TMP7:%.*]] = load i32, i32* [[I]], align 4, [[DBG57:!dbg !.*]], [[TBAA23]]
+; CHECK-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP7]], 1, [[DBG57]]
+; CHECK-NEXT:    store i32 [[INC]], i32* [[I]], align 4, [[DBG57]], [[TBAA23]]
+; CHECK-NEXT:    br label [[FOR_COND]], [[DBG53]], [[LOOP58:!llvm.loop !.*]]
+; CHECK:       for.end:
+; CHECK-NEXT:    ret void, [[DBG60:!dbg !.*]]
+;
+entry:
+  %A.addr = alloca i32*, align 8
+  %i = alloca i32, align 4
+  store i32* %A, i32** %A.addr, align 8, !tbaa !16
+  call void @llvm.dbg.declare(metadata i32** %A.addr, metadata !41, metadata !DIExpression()), !dbg !44
+  %0 = bitcast i32* %i to i8*, !dbg !45
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* %0) #3, !dbg !45
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !42, metadata !DIExpression()), !dbg !46
+  store i32 0, i32* %i, align 4, !dbg !46, !tbaa !23
+  br label %for.cond, !dbg !45
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %1 = load i32, i32* %i, align 4, !dbg !47, !tbaa !23
+  %2 = load i32*, i32** %A.addr, align 8, !dbg !49, !tbaa !16
+  %3 = load i32, i32* %2, align 4, !dbg !50, !tbaa !23
+  %cmp = icmp slt i32 %1, %3, !dbg !51
+  br i1 %cmp, label %for.body, label %for.cond.cleanup, !dbg !52
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %4 = bitcast i32* %i to i8*, !dbg !53
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* %4) #3, !dbg !53
+  br label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %5 = load i32*, i32** %A.addr, align 8, !dbg !54, !tbaa !16
+  %6 = load i32, i32* %i, align 4, !dbg !55, !tbaa !23
+  %idxprom = sext i32 %6 to i64, !dbg !54
+  %arrayidx = getelementptr inbounds i32, i32* %5, i64 %idxprom, !dbg !54
+  store i32 0, i32* %arrayidx, align 4, !dbg !56, !tbaa !23
+  br label %for.inc, !dbg !54
+
+for.inc:                                          ; preds = %for.body
+  %7 = load i32, i32* %i, align 4, !dbg !57, !tbaa !23
+  %inc = add nsw i32 %7, 1, !dbg !57
+  store i32 %inc, i32* %i, align 4, !dbg !57, !tbaa !23
+  br label %for.cond, !dbg !53, !llvm.loop !58
+
+for.end:                                          ; preds = %for.cond.cleanup
+  ret void, !dbg !60
+}
+
+attributes #0 = { 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" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+attributes #2 = { argmemonly nounwind willreturn }
+attributes #3 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = 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)
+!1 = !DIFile(filename: "various_ir_values.c", directory: "/data/build/llvm-project")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 1d5da8cd30fce1c0a2c2fa6ba656dbfaa36192c8)"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !{!13, !14}
+!13 = !DILocalVariable(name: "A", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!14 = !DILocalVariable(name: "i", scope: !15, file: !1, line: 3, type: !11)
+!15 = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
+!16 = !{!17, !17, i64 0}
+!17 = !{!"any pointer", !18, i64 0}
+!18 = !{!"omnipotent char", !19, i64 0}
+!19 = !{!"Simple C/C++ TBAA"}
+!20 = !DILocation(line: 1, column: 15, scope: !7)
+!21 = !DILocation(line: 3, column: 8, scope: !15)
+!22 = !DILocation(line: 3, column: 12, scope: !15)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"int", !18, i64 0}
+!25 = !DILocation(line: 3, column: 19, scope: !26)
+!26 = distinct !DILexicalBlock(scope: !15, file: !1, line: 3, column: 3)
+!27 = !DILocation(line: 3, column: 24, scope: !26)
+!28 = !DILocation(line: 3, column: 23, scope: !26)
+!29 = !DILocation(line: 3, column: 21, scope: !26)
+!30 = !DILocation(line: 3, column: 3, scope: !15)
+!31 = !DILocation(line: 3, column: 3, scope: !26)
+!32 = !DILocation(line: 4, column: 5, scope: !26)
+!33 = !DILocation(line: 4, column: 7, scope: !26)
+!34 = !DILocation(line: 4, column: 10, scope: !26)
+!35 = !DILocation(line: 3, column: 27, scope: !26)
+!36 = distinct !{!36, !30, !37}
+!37 = !DILocation(line: 4, column: 12, scope: !15)
+!38 = !DILocation(line: 5, column: 1, scope: !7)
+!39 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 7, type: !8, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !40)
+!40 = !{!41, !42}
+!41 = !DILocalVariable(name: "A", arg: 1, scope: !39, file: !1, line: 7, type: !10)
+!42 = !DILocalVariable(name: "i", scope: !43, file: !1, line: 9, type: !11)
+!43 = distinct !DILexicalBlock(scope: !39, file: !1, line: 9, column: 3)
+!44 = !DILocation(line: 7, column: 15, scope: !39)
+!45 = !DILocation(line: 9, column: 8, scope: !43)
+!46 = !DILocation(line: 9, column: 12, scope: !43)
+!47 = !DILocation(line: 9, column: 19, scope: !48)
+!48 = distinct !DILexicalBlock(scope: !43, file: !1, line: 9, column: 3)
+!49 = !DILocation(line: 9, column: 24, scope: !48)
+!50 = !DILocation(line: 9, column: 23, scope: !48)
+!51 = !DILocation(line: 9, column: 21, scope: !48)
+!52 = !DILocation(line: 9, column: 3, scope: !43)
+!53 = !DILocation(line: 9, column: 3, scope: !48)
+!54 = !DILocation(line: 10, column: 5, scope: !48)
+!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)

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

+## Basic test checking that update_test_checks.py works correctly on various "IR value" kinds
+# RUN: cp -f %S/Inputs/various_ir_values.ll %t.ll && %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.expected
+## Check that running the script again does not change the result:
+# RUN: %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.expected
+## Also try the --function-signature flag
+# RUN: %update_test_checks %t.ll --function-signature
+# RUN: diff -u %t.ll %S/Inputs/various_ir_values.ll.funcsig.expected
+## Verify that running without the --function-signature flag does not removes
+## 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
+

llvm/utils/UpdateTestChecks/asm.py

common.build_function_body_dictionary(
           function_re, scrubber, [args], raw_tool_output, prefixes,
           func_dict, args.verbose, False, False)
 
 ##### Generator of assembly CHECK lines
 
 def add_asm_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
   # Label format is based on ASM string.
   check_label_format = '{} %s-LABEL: %s%s:'.format(comment_marker)
-  common.add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, True, False)
+  global_vars_seen_dict = {}
+  common.add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, True, False, global_vars_seen_dict)

llvm/utils/UpdateTestChecks/common.py

class function_body(object):
   def __init__(self, string, extra, args_and_sig, attrs):
     self.scrub = string
     self.extrascrub = extra
     self.args_and_sig = args_and_sig
     self.attrs = attrs
   def is_same_except_arg_names(self, extrascrub, args_and_sig, attrs):
     arg_names = set()
     def drop_arg_names(match):
-        arg_names.add(match.group(2))
-        return match.group(1) + match.group(3)
+        arg_names.add(match.group(3))
+        return match.group(1) + match.group(match.lastindex)
     def repl_arg_names(match):
-        if match.group(2) in arg_names:
-            return match.group(1) + match.group(3)
-        return match.group(1) + match.group(2) + match.group(3)
+        if match.group(3) in arg_names:
+            return match.group(1) + match.group(match.lastindex)
+        return match.group(1) + match.group(2) + match.group(match.lastindex)
     if self.attrs != attrs:
       return False
     ans0 = IR_VALUE_RE.sub(drop_arg_names, self.args_and_sig)
     ans1 = IR_VALUE_RE.sub(drop_arg_names, args_and_sig)
     if ans0 != ans1:
         return False
     es0 = IR_VALUE_RE.sub(repl_arg_names, self.extrascrub)
     es1 = IR_VALUE_RE.sub(repl_arg_names, extrascrub)
for prefix in prefixes:
               continue
 
       func_dict[prefix][func] = function_body(scrubbed_body, scrubbed_extra, args_and_sig, attrs)
 
 ##### Generator of LLVM IR CHECK lines
 
 SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*')
 
-# Match things that look at identifiers, but only if they are followed by
-# spaces, commas, paren, or end of the string
-IR_VALUE_RE = re.compile(r'(\s+)%([\w.-]+?)([,\s\(\)]|\Z)')
+# TODO: We should also derive check lines for global, debug, loop declarations, etc..
 
-NAMELESS_PREFIX = "TMP"
+class NamelessValue:
+    def __init__(self, check_prefix, ir_prefix, ir_regexp):
+        self.check_prefix = check_prefix
+        self.ir_prefix = ir_prefix
+        self.ir_regexp = ir_regexp
+
+# Description of the different "unnamed" values we match in the IR, e.g.,
+# (local) ssa values, (debug) metadata, etc.
+nameless_values = [
+    NamelessValue(r'TMP',   r'%',            r'[\w.-]+?'),
+    NamelessValue(r'GLOB',  r'@',            r'[0-9]+?'),
+    NamelessValue(r'ATTR',  r'#',            r'[0-9]+?'),
+    NamelessValue(r'DBG',   r'!dbg !',       r'[0-9]+?'),
+    NamelessValue(r'TBAA',  r'!tbaa !',      r'[0-9]+?'),
+    NamelessValue(r'RNG',   r'!range !',     r'[0-9]+?'),
+    NamelessValue(r'LOOP',  r'!llvm.loop !', r'[0-9]+?'),
+    NamelessValue(r'META',  r'metadata !',   r'[0-9]+?'),
+]
+
+# Build the regexp that matches an "IR value". This can be a local variable,
+# argument, global, or metadata, anything that is "named". It is important that
+# the PREFIX and SUFFIX below only contain a single group, if that changes
+# other locations will need adjustment as well.
+IR_VALUE_REGEXP_PREFIX = r'(\s+)'
+IR_VALUE_REGEXP_STRING = r''
+for nameless_value in nameless_values:
+    if IR_VALUE_REGEXP_STRING:
+        IR_VALUE_REGEXP_STRING += '|'
+    IR_VALUE_REGEXP_STRING += nameless_value.ir_prefix + r'(' + nameless_value.ir_regexp + r')'
+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)
+
+# 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
+
+# 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;
+
+# See get_idx_from_ir_value_match
+def get_name_from_ir_value_match(match):
+    return match.group(get_idx_from_ir_value_match(match) + first_nameless_group_in_ir_value_match)
+
+# Return the nameless prefix we use for this kind or IR value, see also
+# get_idx_from_ir_value_match
+def get_nameless_check_prefix_from_ir_value_match(match):
+    return nameless_values[get_idx_from_ir_value_match(match)].check_prefix
+
+# Return the IR prefix we use for this kind or IR value, e.g., % for locals,
+# see also get_idx_from_ir_value_match
+def get_ir_prefix_from_ir_value_match(match):
+    return nameless_values[get_idx_from_ir_value_match(match)].ir_prefix
+
+# Return true if this kind or IR value is "local", basically if it matches '%{{.*}}'.
+def is_local_ir_value_match(match):
+    return nameless_values[get_idx_from_ir_value_match(match)].ir_prefix == '%'
 
 # Create a FileCheck variable name based on an IR name.
-def get_value_name(var):
+def get_value_name(var, match):
   if var.isdigit():
-    var = NAMELESS_PREFIX + var
+    var = get_nameless_check_prefix_from_ir_value_match(match) + var
   var = var.replace('.', '_')
   var = var.replace('-', '_')
   return var.upper()
 
-
 # Create a FileCheck variable from regex.
-def get_value_definition(var):
-  return '[[' + get_value_name(var) + ':%.*]]'
-
+def get_value_definition(var, match):
+  return '[[' + get_value_name(var, match) + ':' + get_ir_prefix_from_ir_value_match(match) + '.*]]'
 
 # Use a FileCheck variable.
-def get_value_use(var):
-  return '[[' + get_value_name(var) + ']]'
+def get_value_use(var, match):
+  return '[[' + get_value_name(var, match) + ']]'
 
 # Replace IR value defs and uses with FileCheck variables.
-def genericize_check_lines(lines, is_analyze, vars_seen):
+def genericize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
   # This gets called for each match that occurs in
   # a line. We transform variables we haven't seen
   # into defs, and variables we have seen into uses.
   def transform_line_vars(match):
-    var = match.group(2)
-    if NAMELESS_PREFIX.lower() in var.lower():
+    pre = get_ir_prefix_from_ir_value_match(match)
+    var = get_name_from_ir_value_match(match)
+    for nameless_value in nameless_values:
+        if re.fullmatch(nameless_value.ir_prefix + r'[0-9]+?', var, re.IGNORECASE):
             warn("Change IR value name '%s' to prevent possible conflict with scripted FileCheck name." % (var,))
-    if var in vars_seen:
-      rv = get_value_use(var)
+    if (pre, var) in vars_seen or (pre, var) in global_vars_seen:
+      rv = get_value_use(var, match)
+    else:
+      if is_local_ir_value_match(match):
+         vars_seen.add((pre, var))
       else:
-      vars_seen.add(var)
-      rv = get_value_definition(var)
+         global_vars_seen.add((pre, var))
+      rv = get_value_definition(var, match)
     # re.sub replaces the entire regex match
     # with whatever you return, so we have
     # to make sure to hand it back everything
     # including the commas and spaces.
-    return match.group(1) + rv + match.group(3)
+    return match.group(1) + rv + match.group(match.lastindex)
 
   lines_with_def = []
 
   for i, line in enumerate(lines):
     # An IR variable named '%.' matches the FileCheck regex string.
     line = line.replace('%.', '%dot')
     # Ignore any comments, since the check lines will too.
     scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r'', line)
-    if is_analyze:
-      lines[i] = scrubbed_line
-    else:
-      lines[i] = IR_VALUE_RE.sub(transform_line_vars, scrubbed_line)
+    if not is_analyze:
+      # It can happen that two matches are back-to-back and for some reason sub
+      # will not replace both of them. For now we work around this by
+      # substituting until there is no more match.
+      changed = True
+      while changed:
+          (lines[i], changed) = IR_VALUE_RE.subn(transform_line_vars, lines[i], count=1)
   return lines
 
 
-def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_asm, is_analyze):
+def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_asm, is_analyze, global_vars_seen_dict):
   # prefix_exclusions are prefixes we cannot use to print the function because it doesn't exist in run lines that use these prefixes as well.
   prefix_exclusions = set()
   printed_prefixes = []
   for p in prefix_list:
     checkprefixes = p[0]
     # If not all checkprefixes of this run line produced the function we cannot check for it as it does not
     # exist for this run line. A subset of the check prefixes might know about the function but only because
     # other run lines created it.
for checkprefix in checkprefixes:
         continue
 
       # Add some space between different check prefixes, but not after the last
       # check line (before the test code).
       if is_asm:
         if len(printed_prefixes) != 0:
           output_lines.append(comment_marker)
 
+      if checkprefix not in global_vars_seen_dict:
+          global_vars_seen_dict[checkprefix] = set()
+      global_vars_seen = global_vars_seen_dict[checkprefix]
+
       vars_seen = set()
       printed_prefixes.append(checkprefix)
       attrs = str(func_dict[checkprefix][func_name].attrs)
       attrs = '' if attrs == 'None' else attrs
       if attrs:
         output_lines.append('%s %s: Function Attrs: %s' % (comment_marker, checkprefix, attrs))
       args_and_sig = str(func_dict[checkprefix][func_name].args_and_sig)
-      args_and_sig = genericize_check_lines([args_and_sig], is_analyze, vars_seen)[0]
+      args_and_sig = genericize_check_lines([args_and_sig], is_analyze, vars_seen, global_vars_seen)[0]
       if '[[' in args_and_sig:
         output_lines.append(check_label_format % (checkprefix, func_name, ''))
         output_lines.append('%s %s-SAME: %s' % (comment_marker, checkprefix, args_and_sig))
       else:
         output_lines.append(check_label_format % (checkprefix, func_name, args_and_sig))
       func_body = str(func_dict[checkprefix][func_name]).splitlines()
 
       # For ASM output, just emit the check lines.
       if is_asm:
         output_lines.append('%s %s:       %s' % (comment_marker, checkprefix, func_body[0]))
         for func_line in func_body[1:]:
           if func_line.strip() == '':
             output_lines.append('%s %s-EMPTY:' % (comment_marker, checkprefix))
           else:
             output_lines.append('%s %s-NEXT:  %s' % (comment_marker, checkprefix, func_line))
         break
 
       # For IR output, change all defs to FileCheck variables, so we're immune
       # to variable naming fashions.
-      func_body = genericize_check_lines(func_body, is_analyze, vars_seen)
+      func_body = genericize_check_lines(func_body, is_analyze, vars_seen, global_vars_seen)
 
       # This could be selectively enabled with an optional invocation argument.
       # Disabled for now: better to check everything. Be safe rather than sorry.
 
       # Handle the first line of the function body as a special case because
       # it's often just noise (a useless asm comment or entry label).
       #if func_body[0].startswith("#") or func_body[0].startswith("entry:"):
       #  is_blank_line = True
for checkprefix in checkprefixes:
         is_blank_line = False
 
       # Add space between different check prefixes and also before the first
       # line of code in the test function.
       output_lines.append(comment_marker)
       break
 
 def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
-                  func_name, preserve_names, function_sig):
+                  func_name, preserve_names, function_sig, global_vars_seen_dict):
   # Label format is based on IR string.
   function_def_regex = 'define {{[^@]+}}' if function_sig else ''
   check_label_format = '{} %s-LABEL: {}@%s%s'.format(comment_marker, function_def_regex)
   add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
-             check_label_format, False, preserve_names)
+             check_label_format, False, preserve_names, global_vars_seen_dict)
 
 def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
   check_label_format = '{} %s-LABEL: \'%s%s\''.format(comment_marker)
-  add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, False, True)
+  global_vars_see_dict = {}
+  add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
+             check_label_format, False, True, global_vars_seen_dict)
 
 
 def check_prefix(prefix):
   if not PREFIX_RE.match(prefix):
         hint = ""
         if ',' in prefix:
           hint = " Did you mean '--check-prefixes=" + prefix + "'?"
         warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) %

llvm/utils/update_cc_test_checks.py

for prefixes, clang_args, extra_commands, triple_in_cmd in run_list:
 
       get_function_body(ti.args, ti.path, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict)
 
       # Invoke clang -Xclang -ast-dump=json to get mapping from start lines to
       # mangled names. Forward all clang args for now.
       for k, v in get_line2spell_and_mangled(ti.args, clang_args).items():
         line2spell_and_mangled_list[k].append(v)
 
+    global_vars_seen_dict = {}
     prefix_set = set([prefix for p in run_list for prefix in p[0]])
     output_lines = []
     for line_info in ti.iterlines(output_lines):
       idx = line_info.line_number
       line = line_info.line
       args = line_info.args
       include_line = True
       m = common.CHECK_RE.match(line)
for line_info in ti.iterlines(output_lines):
               # 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 added:
               output_lines.append('//')
             added.add(mangled)
             common.add_ir_checks(output_lines, '//', run_list, func_dict, mangled,
-                                 False, args.function_signature)
+                                 False, args.function_signature, global_vars_seen_dict)
             if line.rstrip('\n') == '//':
               include_line = False
 
       if include_line:
         output_lines.append(line.rstrip('\n'))
 
     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

for l in ti.run_lines:
                         for item in m.group(1).split(',')]
       if not check_prefixes:
         check_prefixes = ['CHECK']
 
       # FIXME: We should use multiple check prefixes to common check lines. For
       # now, we just ignore all but the last.
       prefix_list.append((check_prefixes, tool_cmd_args))
 
+    global_vars_seen_dict = {}
     func_dict = {}
     for prefixes, _ in prefix_list:
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
     for prefixes, opt_args in prefix_list:
       common.debug('Extracted opt cmd: ' + opt_basename + ' ' + opt_args)
       common.debug('Extracted FileCheck prefixes: ' + str(prefixes))
 
for input_line_info in ti.iterlines(output_lines):
         if input_line.lstrip().startswith(';'):
           m = common.CHECK_RE.match(input_line)
           if not m or m.group(1) not in prefix_set:
             output_lines.append(input_line)
             continue
 
         # Print out the various check lines here.
         common.add_ir_checks(output_lines, ';', prefix_list, func_dict,
-                             func_name, args.preserve_names, args.function_signature)
+                             func_name, args.preserve_names, args.function_signature,
+                             global_vars_seen_dict)
         is_in_function_start = False
 
       if is_in_function:
         if common.should_add_line_to_output(input_line, prefix_set):
           # This input line of the function body will go as-is into the output.
           # Except make leading whitespace uniform: 2 spaces.
           input_line = common.SCRUB_LEADING_WHITESPACE_RE.sub(r'  ', input_line)
           output_lines.append(input_line)