[ArgPromo][Tests] Run update_test_checks on all ArgumentPromotion tests

Summary:
In preparation of D65531 as well as the reuse of these tests for the
Attributor, we modernize them and use the update_test_checks to simplify
updates.

This was done with the update_test_checks after D68819 and D68850.

Reviewers: hfinkel, vsk, dblaikie, davidxl, tejohnson, tstellar, echristo, chandlerc, efriedma, lebedev.ri

Subscribers: bollu, arphaman, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D68766

1 files changed, 46 insertions, 4 deletions

diff --git a/llvm/test/Transforms/ArgumentPromotion/fp80.ll b/llvm/test/Transforms/ArgumentPromotion/fp80.ll
index bd780fa21ae..dd7cebf5a1c 100644
--- a/llvm/test/Transforms/ArgumentPromotion/fp80.ll
+++ b/llvm/test/Transforms/ArgumentPromotion/fp80.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -argpromotion -S | FileCheck %s
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
@@ -13,6 +14,16 @@ target triple = "x86_64-unknown-linux-gnu"
 @a = internal global %struct.Foo { i32 1, i64 2 }, align 8
 
 define void @run() {
+; CHECK-LABEL: define {{[^@]+}}@run()
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = tail call i8 @UseLongDoubleUnsafely(%union.u* byval align 16 bitcast (%struct.s* @b to %union.u*))
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[UNION_U:%.*]], %union.u* bitcast (%struct.s* @b to %union.u*), i32 0, i32 0
+; CHECK-NEXT:    [[DOT0_VAL:%.*]] = load x86_fp80, x86_fp80* [[DOT0]]
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call x86_fp80 @UseLongDoubleSafely(x86_fp80 [[DOT0_VAL]])
+; CHECK-NEXT:    [[TMP2:%.*]] = call i64 @AccessPaddingOfStruct(%struct.Foo* @a)
+; CHECK-NEXT:    [[TMP3:%.*]] = call i64 @CaptureAStruct(%struct.Foo* @a)
+; CHECK-NEXT:    ret void
+;
 entry:
   tail call i8 @UseLongDoubleUnsafely(%union.u* byval align 16 bitcast (%struct.s* @b to %union.u*))
   tail call x86_fp80 @UseLongDoubleSafely(%union.u* byval align 16 bitcast (%struct.s* @b to %union.u*))
@@ -21,8 +32,15 @@ entry:
   ret void
 }
 
-; CHECK: internal i8 @UseLongDoubleUnsafely(%union.u* byval align 16 %arg) {
 define internal i8 @UseLongDoubleUnsafely(%union.u* byval align 16 %arg) {
+; CHECK-LABEL: define {{[^@]+}}@UseLongDoubleUnsafely
+; CHECK-SAME: (%union.u* byval align 16 [[ARG:%.*]])
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[BITCAST:%.*]] = bitcast %union.u* [[ARG]] to %struct.s*
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [[STRUCT_S:%.*]], %struct.s* [[BITCAST]], i64 0, i32 2
+; CHECK-NEXT:    [[RESULT:%.*]] = load i8, i8* [[GEP]]
+; CHECK-NEXT:    ret i8 [[RESULT]]
+;
 entry:
   %bitcast = bitcast %union.u* %arg to %struct.s*
   %gep = getelementptr inbounds %struct.s, %struct.s* %bitcast, i64 0, i32 2
@@ -30,22 +48,46 @@ entry:
   ret i8 %result
 }
 
-; CHECK: internal x86_fp80 @UseLongDoubleSafely(x86_fp80 {{%.*}}) {
 define internal x86_fp80 @UseLongDoubleSafely(%union.u* byval align 16 %arg) {
+; CHECK-LABEL: define {{[^@]+}}@UseLongDoubleSafely
+; CHECK-SAME: (x86_fp80 [[ARG_0:%.*]])
+; CHECK-NEXT:    [[ARG:%.*]] = alloca [[UNION_U:%.*]], align 16
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[UNION_U]], %union.u* [[ARG]], i32 0, i32 0
+; CHECK-NEXT:    store x86_fp80 [[ARG_0]], x86_fp80* [[DOT0]]
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [[UNION_U]], %union.u* [[ARG]], i64 0, i32 0
+; CHECK-NEXT:    [[FP80:%.*]] = load x86_fp80, x86_fp80* [[GEP]]
+; CHECK-NEXT:    ret x86_fp80 [[FP80]]
+;
   %gep = getelementptr inbounds %union.u, %union.u* %arg, i64 0, i32 0
   %fp80 = load x86_fp80, x86_fp80* %gep
   ret x86_fp80 %fp80
 }
 
-; CHECK: define internal i64 @AccessPaddingOfStruct(%struct.Foo* byval %a) {
 define internal i64 @AccessPaddingOfStruct(%struct.Foo* byval %a) {
+; CHECK-LABEL: define {{[^@]+}}@AccessPaddingOfStruct
+; CHECK-SAME: (%struct.Foo* byval [[A:%.*]])
+; CHECK-NEXT:    [[P:%.*]] = bitcast %struct.Foo* [[A]] to i64*
+; CHECK-NEXT:    [[V:%.*]] = load i64, i64* [[P]]
+; CHECK-NEXT:    ret i64 [[V]]
+;
   %p = bitcast %struct.Foo* %a to i64*
   %v = load i64, i64* %p
   ret i64 %v
 }
 
-; CHECK: define internal i64 @CaptureAStruct(%struct.Foo* byval %a) {
 define internal i64 @CaptureAStruct(%struct.Foo* byval %a) {
+; CHECK-LABEL: define {{[^@]+}}@CaptureAStruct
+; CHECK-SAME: (%struct.Foo* byval [[A:%.*]])
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A_PTR:%.*]] = alloca %struct.Foo*
+; CHECK-NEXT:    br label [[LOOP:%.*]]
+; CHECK:       loop:
+; CHECK-NEXT:    [[PHI:%.*]] = phi %struct.Foo* [ null, [[ENTRY:%.*]] ], [ [[GEP:%.*]], [[LOOP]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = phi %struct.Foo* [ [[A]], [[ENTRY]] ], [ [[TMP0]], [[LOOP]] ]
+; CHECK-NEXT:    store %struct.Foo* [[PHI]], %struct.Foo** [[A_PTR]]
+; CHECK-NEXT:    [[GEP]] = getelementptr [[STRUCT_FOO:%.*]], %struct.Foo* [[A]], i64 0
+; CHECK-NEXT:    br label [[LOOP]]
+;
 entry:
   %a_ptr = alloca %struct.Foo*
   br label %loop