[Clang][LoongArch] Fix ABI handling of empty structs in C++ to match GCC behaviour

[SixWeining]

Summary

GCC doesn't ignore non-zero-length array of empty structures in C++
while clang does. What this patch did is to match GCC's behaviour
although this rule is not documented in psABI.

Similar to D142327 for RISCV. Depends on D142327.

[xry111]

Ooops. These corner cases are really annoying.

I think I should try make check-gcc check-g++ RUNTESTFLAGS='ALT_CC_UNDER_TEST=clang ALT_CXX_UNDER_TEST=clang++ compat.exp' in GCC test suite...

[xry111]

The change itself LGTM.

[xen0n]

So this one is different than D151298 (I'm very glad that those registers are ultimately saved btw), and solves a real problem. Thanks for the timely catch before LLVM 17 ;-)

[thakis]

This seems to not build: http://45.33.8.238/linux/113405/step_4.txt (?)

[SixWeining]

In D156116#4530365, @thakis wrote:

This seems to not build: http://45.33.8.238/linux/113405/step_4.txt (?)

Thanks, I have reverted.

[SixWeining]

add an extra check for when a candidate from detectFAREligibleStructHelper may not be valid

clang/docs/ReleaseNotes.rst

 ^^^^^^^^^^^^^^^^^^^^^^^
 
 Windows Support
 ^^^^^^^^^^^^^^^
 
 LoongArch Support
 ^^^^^^^^^^^^^^^^^
 
+- An ABI mismatch between GCC and Clang related to the handling of empty structs
+  in C++ parameter passing under ``lp64d`` ABI was fixed.
+
 RISC-V Support
 ^^^^^^^^^^^^^^
 - Unaligned memory accesses can be toggled by ``-m[no-]unaligned-access`` or the
   aliases ``-m[no-]strict-align``.
 - An ABI mismatch between GCC and Clang related to the handling of empty
   structs in C++ parameter passing under the hard floating point calling
   conventions was fixed.
 

clang/lib/CodeGen/Targets/LoongArch.cpp

if (auto CTy = Ty->getAs<ComplexType>()) {
     Field2Ty = Field1Ty;
     Field2Off = Field1Off + getContext().getTypeSizeInChars(EltTy);
     return true;
   }
 
   if (const ConstantArrayType *ATy = getContext().getAsConstantArrayType(Ty)) {
     uint64_t ArraySize = ATy->getSize().getZExtValue();
     QualType EltTy = ATy->getElementType();
+    // Non-zero-length arrays of empty records make the struct ineligible to be
+    // passed via FARs in C++.
+    if (const auto *RTy = EltTy->getAs<RecordType>()) {
+      if (ArraySize != 0 && isa<CXXRecordDecl>(RTy->getDecl()) &&
+          isEmptyRecord(getContext(), EltTy, true, true))
+        return false;
+    }
     CharUnits EltSize = getContext().getTypeSizeInChars(EltTy);
     for (uint64_t i = 0; i < ArraySize; ++i) {
       if (!detectFARsEligibleStructHelper(EltTy, CurOff, Field1Ty, Field1Off,
                                           Field2Ty, Field2Off))
         return false;
       CurOff += EltSize;
     }
     return true;
   }
 
   if (const auto *RTy = Ty->getAs<RecordType>()) {
     // Structures with either a non-trivial destructor or a non-trivial
     // copy constructor are not eligible for the FP calling convention.
     if (getRecordArgABI(Ty, CGT.getCXXABI()))
       return false;
-    if (isEmptyRecord(getContext(), Ty, true))
+    if (isEmptyRecord(getContext(), Ty, true, true))
       return true;
     const RecordDecl *RD = RTy->getDecl();
     // Unions aren't eligible unless they're empty (which is caught above).
     if (RD->isUnion())
       return false;
     const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
     // If this is a C++ record, check the bases first.
     if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
bool LoongArchABIInfo::detectFARsEligibleStruct(
     int &NeededFARs) const {
   Field1Ty = nullptr;
   Field2Ty = nullptr;
   NeededGARs = 0;
   NeededFARs = 0;
   if (!detectFARsEligibleStructHelper(Ty, CharUnits::Zero(), Field1Ty,
                                       Field1Off, Field2Ty, Field2Off))
     return false;
+  if (!Field1Ty)
+    return false;
   // Not really a candidate if we have a single int but no float.
   if (Field1Ty && !Field2Ty && !Field1Ty->isFloatingPointTy())
     return false;
   if (Field1Ty && Field1Ty->isFloatingPointTy())
     NeededFARs++;
   else if (Field1Ty)
     NeededGARs++;
   if (Field2Ty && Field2Ty->isFloatingPointTy())

clang/test/CodeGen/LoongArch/abi-lp64d-empty-structs.c

 // RUN: %clang_cc1 -triple loongarch64 -target-feature +f -target-feature +d -target-abi lp64d -emit-llvm %s -o - | \
 // RUN:   FileCheck --check-prefix=CHECK-C %s
 // RUN: %clang_cc1 -triple loongarch64 -target-feature +f -target-feature +d -target-abi lp64d -emit-llvm %s -o - -x c++ | \
 // RUN:   FileCheck --check-prefix=CHECK-CXX %s
 
-// FIXME: This isn't currently respected.
 // Fields containing empty structs or unions are ignored when flattening
 // structs to examine whether the structs can be passed via FARs, even in C++.
 // But there is an exception that non-zero-length array of empty structures are
 // not ignored in C++. These rules are not documented in psABI <https://www.github.com/loongson/la-abi-specs>
 // but they match GCC behaviours.
 
 #include <stdint.h>
 
 struct empty { struct { struct { } e; }; };
 struct s1 { struct empty e; float f; };
 
 // CHECK-C: define{{.*}} float @test_s1(float {{.*}})
-// CHECK-CXX: define{{.*}} i64 @_Z7test_s12s1(i64 {{.*}})
+// CHECK-CXX: define{{.*}} float @_Z7test_s12s1(float {{.*}})
 struct s1 test_s1(struct s1 a) {
   return a;
 }
 
 struct s2 { struct empty e; int32_t i; float f; };
 
 // CHECK-C: define{{.*}} { i32, float } @test_s2(i32 {{.*}}, float {{.*}})
-// CHECK-CXX: define{{.*}} [2 x i64] @_Z7test_s22s2([2 x i64] {{.*}})
+// CHECK-CXX: define{{.*}} { i32, float } @_Z7test_s22s2(i32 {{.*}}, float {{.*}})
 struct s2 test_s2(struct s2 a) {
   return a;
 }
 
 struct s3 { struct empty e; float f; float g; };
 
 // CHECK-C: define{{.*}} { float, float } @test_s3(float {{.*}}, float {{.*}})
-// CHECK-CXX: define{{.*}} [2 x i64] @_Z7test_s32s3([2 x i64] {{.*}})
+// CHECK-CXX: define{{.*}} { float, float } @_Z7test_s32s3(float {{.*}}, float {{.*}})
 struct s3 test_s3(struct s3 a) {
   return a;
 }
 
 struct s4 { struct empty e; float __complex__ c; };
 
 // CHECK-C: define{{.*}} { float, float } @test_s4(float {{.*}}, float {{.*}})
-// CHECK-CXX: define{{.*}} [2 x i64] @_Z7test_s42s4([2 x i64] {{.*}})
+// CHECK-CXX: define{{.*}} { float, float } @_Z7test_s42s4(float {{.*}}, float {{.*}})
 struct s4 test_s4(struct s4 a) {
   return a;
 }
 
 // An array of empty fields isn't ignored in C++ (this isn't explicit in the
 // psABI, but matches observed g++ behaviour).
 
 struct s5 { struct empty e[1]; float f; };

 struct s7 test_s7(struct s7 a) {
   return a;
 }
 
 struct empty_arr0 { struct { struct { } e[0]; }; };
 struct s8 { struct empty_arr0 e; float f; };
 
 // CHECK-C: define{{.*}} float @test_s8(float {{.*}})
-// CHECK-CXX: define{{.*}} i64 @_Z7test_s82s8(i64 {{.*}})
+// CHECK-CXX: define{{.*}} float @_Z7test_s82s8(float {{.*}})
 struct s8 test_s8(struct s8 a) {
   return a;
 }
+
+// CHECK-C: define{{.*}} void @test_s9()
+// CHECK-CXX: define{{.*}} i64 @_Z7test_s92s9(i64 {{.*}})
+struct s9 { struct empty e; };
+struct s9 test_s9(struct s9 a) {
+  return a;
+}