[SROA] Add new test cases to cover existing SROA behavior that structs will be scalarized.

[mingmingl]

Summary

Add an IR in unit test directory, which demonstrate the scalarization for struct allocations.
This is added to pave the way for an SROA change to skip scalarization for some cases.

[lebedev.ri]

llvm/test/Transforms/SROA/alloca-struct.ll

2

Please just use auto-update test like in the other tests here

[davidxl]

llvm/test/Transforms/SROA/alloca-struct.ll

32

remove %test.addr

33

same here

34

remove %frombool

36

Remove the above two stores

37

remove load

38

remove

39

Replace %tobool with %test

49

remove load

50

replace %1 with %p

62

Similar cleanup can be done for this test cse.

[lebedev.ri]

(disclaimer for the change itself: note that it is not sufficient to check that there are scalar loads/stores, it'd miss the point of SROA.)

[mingmingl]

Simplify IR by cleaning up alloca instructions for function parameters, and
cleaning up attributes as well as some unused metadata.

[mingmingl]

In D114128#3140590, @lebedev.ri wrote:

(disclaimer for the change itself: note that it is not sufficient to check that there are scalar loads/stores, it'd miss the point of SROA.)

It's true. This test is added with the goal to demonstrate how current sroa works, and for a planned patch, it will slightly change the scalarization, so this IR will be updated.

llvm/test/Transforms/SROA/alloca-struct.ll

2

Some unit tests run the auto-update while others doesn't (e.g., https://github.com/llvm/llvm-project/blob/main/llvm/test/Transforms/SROA/fca.ll is not updated by auto-updater)

For this IR, using auto-updater inserts quite many checker lines and somewhat hard to read. So will keep the current format.

[mingmingl]

Clean up all metadata for simplicity.

[davidxl]

lgtm (perhaps change the title of the patch to 'Add new test cases to cover existing SROA behavior'.

llvm/test/Transforms/SROA/alloca-struct.ll

+; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
+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"
+
+%struct.RetValIntChar = type { i32, i8 }
+%struct.RetValTwoInts = type { i32, i32 }
+%struct.RetValOneIntTwoChar = type { i32, i8 }
+
+; Tests that a struct of type {i32, i8} is scalarized by SROA.
+; FIXME: SROA should skip scalarization since there is no scalar access.
+; Currently scalarization happens due to the mismatch of allocated size
+; and the actual structure size.
+define i64 @test_struct_of_int_char(i1 zeroext %test, i64 ()* %p) {
+; CHECK-LABEL: @test_struct_of_int_char(
+; CHECK-NEXT:  entry:
+; COM: Check that registers are used and alloca instructions are eliminated.
+; CHECK-NOT:     alloca
+; CHECK:       if.then:
+; CHECK-NEXT:    br label [[RETURN:%.*]]
+; CHECK:       if.end:
+; CHECK-NEXT:    call i64 [[P:%.*]]()
+; CHECK:    br label [[RETURN]]
+; CHECK:       return:
+; COM: Check there are more than one PHI nodes to select scalarized values.
+; CHECK-COUNT-3: phi
+; CHECK:         ret i64
+;
+entry:
+  %retval = alloca %struct.RetValIntChar, align 4
+  br i1 %test, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  %x = getelementptr inbounds %struct.RetValIntChar, %struct.RetValIntChar* %retval, i32 0, i32 0
+  store i32 0, i32* %x, align 4
+  %y = getelementptr inbounds %struct.RetValIntChar, %struct.RetValIntChar* %retval, i32 0, i32 1
+  store i8 0, i8* %y, align 4
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %call = call i64 %p()
+  %0 = bitcast %struct.RetValIntChar* %retval to i64*
+  store i64 %call, i64* %0, align 4
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  %1 = bitcast %struct.RetValIntChar* %retval to i64*
+  %2 = load i64, i64* %1, align 4
+  ret i64 %2
+}
+
+; Test that the alloca of struct{int, int} will be scalarized by SROA.
+define i64 @test_struct_of_two_int(i1 zeroext %test, i64 ()* %p) {
+; CHECK-LABEL: @test_struct_of_two_int(
+; CHECK-NEXT:  entry:
+; CHECK-NOT:     alloca 
+; CHECK:       if.then:
+; CHECK-NEXT:    br label [[RETURN:%.*]]
+; CHECK:       if.end:
+; CHECK-NEXT:    call i64
+; CHECK:       return:
+; COM: Check that there are more than one PHI nodes to select the scalarized values.
+; CHECK-COUNT-2: phi
+; CHECK:         ret i64
+;
+entry:
+  %retval = alloca %struct.RetValTwoInts, align 4
+  br i1 %test, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  %x = getelementptr inbounds %struct.RetValTwoInts, %struct.RetValTwoInts* %retval, i32 0, i32 0
+  store i32 0, i32* %x, align 4
+  %y = getelementptr inbounds %struct.RetValTwoInts, %struct.RetValTwoInts* %retval, i32 0, i32 1
+  store i32 0, i32* %y, align 4
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %call = call i64 %p()
+  %0 = bitcast %struct.RetValTwoInts* %retval to i64*
+  store i64 %call, i64* %0, align 4
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  %1 = bitcast %struct.RetValTwoInts* %retval to i64*
+  %2 = load i64, i64* %1, align 4
+  ret i64 %2
+}
+
+; Tests that allocated struct type is scalarized when non-constant values are
+; stored into its fields.
+define i64 @test_one_field_has_runtime_value(i1 zeroext %test, i64 ()* %p) {
+; CHECK-LABEL: @test_one_field_has_runtime_value(
+; CHECK-NEXT:  entry:
+; CHECK-NOT:     alloca
+; CHECK:         call void @srand
+; CHECK:       if.then:
+; CHECK-NEXT:    call i32 @rand()
+; CHECK-NEXT:    br label
+; CHECK:       if.end:
+; CHECK-NEXT:    call i64
+; CHECK:       return:
+; CHECK-COUNT-2: phi i32
+; CHECK:         ret i64
+;
+entry:
+  %retval = alloca %struct.RetValTwoInts, align 4
+  %call = call i64 @time(i64* null)
+  %conv = trunc i64 %call to i32
+  call void @srand(i32 %conv)
+  br i1 %test, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  %x = getelementptr inbounds %struct.RetValTwoInts, %struct.RetValTwoInts* %retval, i32 0, i32 0
+  %call1 = call i32 @rand()
+  store i32 %call1, i32* %x, align 4
+  %y = getelementptr inbounds %struct.RetValTwoInts, %struct.RetValTwoInts* %retval, i32 0, i32 1
+  store i32 1, i32* %y, align 4
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %call2 = call i64 %p()
+  %0 = bitcast %struct.RetValTwoInts* %retval to i64*
+  store i64 %call2, i64* %0, align 4
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  %1 = bitcast %struct.RetValTwoInts* %retval to i64*
+  %2 = load i64, i64* %1, align 4
+  ret i64 %2
+}
+
+; Function Attrs: nounwind
+declare void @srand(i32)
+
+; Function Attrs: nounwind
+declare i64 @time(i64*)
+
+; Function Attrs: nounwind
+declare i32 @rand()