[NFC] [PPC] Add PowerPC expected IR tests for C99 complex

[cebowleratibm]

Summary

Adding this test so that I can extend it in a follow on patch with expected IR for AIX when I implement complex handling in AIXABIInfo.

[ZarkoCA]

clang/test/CodeGen/powerpc-c99complex.c

1

Can you add ppc64le as well?

[cebowleratibm]

Added ppc64le target.

[daltenty]

LGTM, thanks.

[ZarkoCA]

clang/test/CodeGen/powerpc-c99complex.c

7

Nit: I don't think you need the #0 here and anywhere below.

19–20

Nit: please line up these lines with the ones below.

34–39

Nit: Can the formatting be fixed so the lines line up?

[cebowleratibm]

Reworked the prefixes and indentation.

[ZarkoCA]

Thanks for doing the formatting changes.

[nemanjai]

This clearly changes behaviour and should thereby not have the [NFC] tag.

[ZarkoCA]

In D88105#2292266, @nemanjai wrote:

This clearly changes behaviour and should thereby not have the [NFC] tag.

Looks like it accidentally includes https://reviews.llvm.org/D88130.

[hubert.reinterpretcast]

Looks to me that this (since it is approved) completely replaces D88130. The patch description needs to be changed of course.
Not sure if the committer wants to try splitting out the non-AIX test as an NFC patch.

[hubert.reinterpretcast]

Off-list discussion seems to indicate that only the NFC portion of the patch was intended to be approved.
That is, the scope of this patch is supposed to be https://reviews.llvm.org/D88105?id=293625 plus formatting changes.

clang/lib/CodeGen/TargetInfo.cpp

default:
       break;
     }
 
   return false;
 }
 
 ABIArgInfo AIXABIInfo::classifyReturnType(QualType RetTy) const {
   if (RetTy->isAnyComplexType())
-    llvm::report_fatal_error("complex type is not supported on AIX yet");
+    return ABIArgInfo::getDirect();
 
   if (RetTy->isVectorType())
     llvm::report_fatal_error("vector type is not supported on AIX yet");
 
   if (RetTy->isVoidType())
     return ABIArgInfo::getIgnore();
 
   // TODO:  Evaluate if AIX power alignment rule would have an impact on the
   // alignment here.
   if (isAggregateTypeForABI(RetTy))
     return getNaturalAlignIndirect(RetTy);
 
   return (isPromotableTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
                                         : ABIArgInfo::getDirect());
 }
 
 ABIArgInfo AIXABIInfo::classifyArgumentType(QualType Ty) const {
   Ty = useFirstFieldIfTransparentUnion(Ty);
 
   if (Ty->isAnyComplexType())
-    llvm::report_fatal_error("complex type is not supported on AIX yet");
+    return ABIArgInfo::getDirect();
 
   if (Ty->isVectorType())
     llvm::report_fatal_error("vector type is not supported on AIX yet");
 
   // TODO:  Evaluate if AIX power alignment rule would have an impact on the
   // alignment here.
   if (isAggregateTypeForABI(Ty)) {
     // Records with non-trivial destructors/copy-constructors should not be
     // passed by value.
     if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI()))
       return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory);
 
     CharUnits CCAlign = getParamTypeAlignment(Ty);
     CharUnits TyAlign = getContext().getTypeAlignInChars(Ty);
 
     return ABIArgInfo::getIndirect(CCAlign, /*ByVal*/ true,
                                    /*Realign*/ TyAlign > CCAlign);
   }
 
   return (isPromotableTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)
                                      : ABIArgInfo::getDirect());
 }
 
 CharUnits AIXABIInfo::getParamTypeAlignment(QualType Ty) const {
-  if (Ty->isAnyComplexType())
-    llvm::report_fatal_error("complex type is not supported on AIX yet");
+  // Complex types are passed just like their elements.
+  if (const ComplexType *CTy = Ty->getAs<ComplexType>())
+    Ty = CTy->getElementType();
 
   if (Ty->isVectorType())
     llvm::report_fatal_error("vector type is not supported on AIX yet");
 
   // If the structure contains a vector type, the alignment is 16.
   if (isRecordWithSIMDVectorType(getContext(), Ty))
     return CharUnits::fromQuantity(16);
 

clang/test/CodeGen/aix-complex.c

-// REQUIRES: powerpc-registered-target
-// RUN: not %clang_cc1 -triple powerpc-unknown-aix \
-// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck %s
-// RUN: not %clang_cc1 -triple powerpc64-unknown-aix \
-// RUN:   -emit-llvm -o - %s 2>&1 | FileCheck %s
-
-// CHECK: fatal error: error in backend: complex type is not supported on AIX yet
-_Complex float foo_float(_Complex float x) {
-  return x;
-}

clang/test/CodeGen/powerpc-c99complex.c

-// RUN: %clang_cc1 -triple powerpc64-unknown-linux -emit-llvm %s -o - | FileCheck %s --check-prefixes=PPC64LNX
-// RUN: %clang_cc1 -triple ppc64le-unknown-linux -emit-llvm %s -o - | FileCheck %s --check-prefixes=PPC64LNX
+// RUN: %clang_cc1 -triple powerpc64-unknown-aix -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,AIX
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,AIX
+// RUN: %clang_cc1 -triple powerpc64-unknown-linux -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,PPC64LNX
+// RUN: %clang_cc1 -triple ppc64le-unknown-linux -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,PPC64LNX
 // RUN: %clang_cc1 -triple powerpc-unknown-linux -emit-llvm %s -o - | FileCheck %s --check-prefix=PPC32LNX
 
 _Complex float foo1(_Complex float x) {
   return x;
-// PPC64LNX-LABEL:       define { float, float } @foo1(float %x.{{.*}}, float %x.{{.*}}) #0 {
-// PPC64LNX:             ret { float, float }
+// CHECK-LABEL:     define { float, float } @foo1(float %x.{{.*}}, float %x.{{.*}}) #0 {
+// CHECK:           ret { float, float }
 
 // PPC32LNX-LABEL:  define void @foo1({ float, float }* noalias sret align 4 %agg.result, { float, float }* byval({ float, float }) align 4 %x) #0 {
 // PPC32LNX:        [[RETREAL:%.*]] = getelementptr inbounds { float, float }, { float, float }* %agg.result, i32 0, i32 0
 // PPC32LNX-NEXT:   [[RETIMAG:%.*]] = getelementptr inbounds { float, float }, { float, float }* %agg.result, i32 0, i32 1
 // PPC32LNX-NEXT:   store float %{{.*}}, float* [[RETREAL]], align 4
 // PPC32LNX-NEXT:   store float %{{.*}}, float* [[RETIMAG]], align 4
 }
 
 _Complex double foo2(_Complex double x) {
   return x;
-// PPC64LNX-LABEL:       define { double, double } @foo2(double %x.{{.*}}, double %x.{{.*}}) #0 {
-// PPC64LNX:             ret { double, double }
+// CHECK-LABEL:     define { double, double } @foo2(double %x.{{.*}}, double %x.{{.*}}) #0 {
+// CHECK:           ret { double, double }
 
 // PPC32LNX-LABEL:  define void @foo2({ double, double }* noalias sret align 8 %agg.result, { double, double }* byval({ double, double }) align 8 %x) #0 {
 // PPC32LNX:        [[RETREAL:%.*]] = getelementptr inbounds { double, double }, { double, double }* %agg.result, i32 0, i32 0
 // PPC32LNX-NEXT:   [[RETIMAG:%.*]] = getelementptr inbounds { double, double }, { double, double }* %agg.result, i32 0, i32 1
 // PPC32LNX-NEXT:   store double %{{.*}}, double* [[RETREAL]], align 8
 // PPC32LNX-NEXT:   store double %{{.*}}, double* [[RETIMAG]], align 8
 }
 
 _Complex long double foo3(_Complex long double x) {
   return x;
-// PPC64LNX-LDBL128-LABEL:    define { ppc_fp128, ppc_fp128 } @foo3(ppc_fp128 %x.{{.*}}, ppc_fp128 %x.{{.*}}) #0 {
-// PPC64LNX-LDBL128:          ret { ppc_fp128, ppc_fp128 }
+// AIX-LABEL:       define { double, double } @foo3(double %x.{{.*}}, double %x.{{.*}}) #0 {
+// AIX:             ret { double, double }
+
+// PPC64LNX-LABEL:  define { ppc_fp128, ppc_fp128 } @foo3(ppc_fp128 %x.{{.*}}, ppc_fp128 %x.{{.*}}) #0 {
+// PPC64LNX:        ret { ppc_fp128, ppc_fp128 }
 
-// PPC32LNX-LABEL: define void @foo3({ ppc_fp128, ppc_fp128 }* noalias sret align 16 %agg.result, { ppc_fp128, ppc_fp128 }* byval({ ppc_fp128, ppc_fp128 }) align 16 %x) #0 {
-// PPC32LNX:       [[RETREAL:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %agg.result, i32 0, i32 0
-// PPC32LNX-NEXT:  [[RETIMAG:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %agg.result, i32 0, i32 1
-// PPC32LNX-NEXT:  store ppc_fp128 %{{.*}}, ppc_fp128* [[RETREAL]], align 16
-// PPC32LNX-NEXT:  store ppc_fp128 %{{.*}}, ppc_fp128* [[RETIMAG]], align 16
+// PPC32LNX-LABEL:  define void @foo3({ ppc_fp128, ppc_fp128 }* noalias sret align 16 %agg.result, { ppc_fp128, ppc_fp128 }* byval({ ppc_fp128, ppc_fp128 }) align 16 %x) #0 {
+// PPC32LNX:        [[RETREAL:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %agg.result, i32 0, i32 0
+// PPC32LNX-NEXT:   [[RETIMAG:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %agg.result, i32 0, i32 1
+// PPC32LNX-NEXT:   store ppc_fp128 %{{.*}}, ppc_fp128* [[RETREAL]], align 16
+// PPC32LNX-NEXT:   store ppc_fp128 %{{.*}}, ppc_fp128* [[RETIMAG]], align 16
 }