[Power9][NFC] add back-end test case for passing homogeneous fp128 aggregates by value

[lei]

Summary

These are the related back-end tests related to the clang patch: https://reviews.llvm.org/D48044
Test verifies that we are passing fp128 via VSX registers as per ABI.

[nemanjai]

Other than a request for comment, LGTM.

test/CodeGen/PowerPC/f128-aggregates.ll

75

I don't actually understand this test. Why are all the GPR's being spilled to the stack. Please add a comment explaining it on the commit.

test/CodeGen/PowerPC/f128-aggregates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \
 ; RUN:   -enable-ppc-quad-precision -verify-machineinstrs < %s | FileCheck %s
 ; RUN: llc -mcpu=pwr9 -mtriple=powerpc64-unknown-unknown \
 ; RUN:   -enable-ppc-quad-precision -verify-machineinstrs < %s | FileCheck -check-prefix=CHECK-BE %s
 
+; Testing homogeneous aggregates.
+
+%struct.With9fp128params = type { fp128, fp128, fp128, fp128, fp128, fp128, fp128, fp128, fp128 }
+
+@a1 = common local_unnamed_addr global [3 x fp128] zeroinitializer, align 16
+
+; Function Attrs: norecurse nounwind readonly
+define fp128 @testArray_01(fp128* nocapture readonly %sa) {
+; CHECK-LABEL: testArray_01:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    lxv 34, 32(3)
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testArray_01:
+; CHECK-BE:       lxv 34, 32(3)
+; CHECK-BE-NEXT:  blr
+entry:
+  %arrayidx = getelementptr inbounds fp128, fp128* %sa, i64 2
+  %0 = load fp128, fp128* %arrayidx, align 16
+  ret fp128 %0
+}
+
+; Function Attrs: norecurse nounwind readonly
+define fp128 @testArray_02() {
+; CHECK-LABEL: testArray_02:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    addis 3, 2, .LC0@toc@ha
+; CHECK-NEXT:    ld 3, .LC0@toc@l(3)
+; CHECK-NEXT:    lxv 34, 32(3)
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testArray_02:
+; CHECK-BE:       lxv 34, 32(3)
+; CHECK-BE-NEXT:  blr
+entry:
+  %0 = load fp128, fp128* getelementptr inbounds ([3 x fp128], [3 x fp128]* @a1, i64 0, i64 2), align 16
+  ret fp128 %0
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testStruct_01(fp128 inreg returned %a.coerce) {
+; CHECK-LABEL: testStruct_01:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testStruct_01:
+; CHECK-BE:       # %bb.0: # %entry
+; CHECK-BE-NEXT:  blr
+entry:
+  ret fp128 %a.coerce
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testStruct_02([8 x fp128] %a.coerce) {
+; CHECK-LABEL: testStruct_02:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    vmr 2, 9
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testStruct_02:
+; CHECK-BE:       vmr 2, 9
+; CHECK-BE-NEXT:  blr
+entry:
+  %a.coerce.fca.7.extract = extractvalue [8 x fp128] %a.coerce, 7
+  ret fp128 %a.coerce.fca.7.extract
+}
+
+; Function Attrs: norecurse nounwind readonly
+define fp128 @testStruct_03(%struct.With9fp128params* byval nocapture readonly align 16 %a) {
+; CHECK-LABEL: testStruct_03:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    lxv 34, 128(1)
+; CHECK-NEXT:    std 10, 88(1)
+; CHECK-NEXT:    std 9, 80(1)
+; CHECK-NEXT:    std 8, 72(1)
+; CHECK-NEXT:    std 7, 64(1)
+; CHECK-NEXT:    std 6, 56(1)
+; CHECK-NEXT:    std 5, 48(1)
+; CHECK-NEXT:    std 4, 40(1)
+; CHECK-NEXT:    std 3, 32(1)
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testStruct_03:
+; CHECK-BE:       # %bb.0: # %entry
+; CHECK-BE-NEXT:    lxv 34, 144(1)
+; CHECK-BE-NEXT:    std 10, 104(1)
+; CHECK-BE-NEXT:    std 9, 96(1)
+; CHECK-BE-NEXT:    std 8, 88(1)
+; CHECK-BE-NEXT:    std 7, 80(1)
+; CHECK-BE-NEXT:    std 6, 72(1)
+; CHECK-BE-NEXT:    std 5, 64(1)
+; CHECK-BE-NEXT:    std 4, 56(1)
+; CHECK-BE-NEXT:    std 3, 48(1)
+; CHECK-BE-NEXT:    blr
+entry:
+  %a7 = getelementptr inbounds %struct.With9fp128params, %struct.With9fp128params* %a, i64 0, i32 6
+  %0 = load fp128, fp128* %a7, align 16
+  ret fp128 %0
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testStruct_04([8 x fp128] %a.coerce) {
+; CHECK-LABEL: testStruct_04:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    vmr 2, 5
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testStruct_04:
+; CHECK-BE:       vmr 2, 5
+; CHECK-BE-NEXT:  blr
+entry:
+  %a.coerce.fca.3.extract = extractvalue [8 x fp128] %a.coerce, 3
+  ret fp128 %a.coerce.fca.3.extract
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testUnion_01([1 x fp128] %a.coerce) {
+; CHECK-LABEL: testUnion_01:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testUnion_01:
+; CHECK-BE:       # %bb.0: # %entry
+; CHECK-BE-NEXT:  blr
+entry:
+  %a.coerce.fca.0.extract = extractvalue [1 x fp128] %a.coerce, 0
+  ret fp128 %a.coerce.fca.0.extract
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testUnion_02([3 x fp128] %a.coerce) {
+; CHECK-LABEL: testUnion_02:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testUnion_02:
+; CHECK-BE:       # %bb.0: # %entry
+; CHECK-BE-NEXT:  blr
+entry:
+  %a.coerce.fca.0.extract = extractvalue [3 x fp128] %a.coerce, 0
+  ret fp128 %a.coerce.fca.0.extract
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testUnion_03([3 x fp128] %a.coerce) {
+; CHECK-LABEL: testUnion_03:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    vmr 2, 3
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testUnion_03:
+; CHECK-BE:       # %bb.0: # %entry
+; CHECK-BE-NEXT:  vmr 2, 3
+; CHECK-BE-NEXT:  blr
+entry:
+  %a.coerce.fca.1.extract = extractvalue [3 x fp128] %a.coerce, 1
+  ret fp128 %a.coerce.fca.1.extract
+}
+
+; Function Attrs: norecurse nounwind readnone
+define fp128 @testUnion_04([3 x fp128] %a.coerce) {
+; CHECK-LABEL: testUnion_04:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    vmr 2, 4
+; CHECK-NEXT:    blr
+
+; CHECK-BE-LABEL: testUnion_04:
+; CHECK-BE:       # %bb.0: # %entry
+; CHECK-BE-NEXT:  vmr 2, 4
+; CHECK-BE-NEXT:  blr
+entry:
+  %a.coerce.fca.2.extract = extractvalue [3 x fp128] %a.coerce, 2
+  ret fp128 %a.coerce.fca.2.extract
+}
+
+; Testing mixed member aggregates.
+
 %struct.MixedC = type { i32, %struct.SA, float, [12 x i8] }
 %struct.SA = type { double, fp128, <4 x float> }
 
 ; Function Attrs: norecurse nounwind readnone
 define fp128 @testMixedAggregate([3 x i128] %a.coerce) {
 ; CHECK-LABEL: testMixedAggregate:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    mtvsrdd 34, 8, 7