[Clang] Enable _Complex __ibm128 type

[qiucf]

Summary

As a follow-up to fae0dfa.

[rjmccall]

clang/include/clang/AST/ASTContext.h

1095 ↗

(On Diff #373146)

Huh. I don't know why we precompute these. I mean, it's not a huge start-up overhead for the compiler, but it's not nothing, and the use in getFloatingTypeOfSizeWithinDomain is not at all worth optimizing.

Would you mind writing up a patch that rips all of these out and makes the use-sites just build the appropriate complex type as needed? And then we can land a patch for this that just does the one-liner to allow _Complex __ibm128.

clang/lib/Sema/Sema.cpp

1898 ↗

(On Diff #373146)

Why is this change in this patch?

[qiucf]

Based on another patch to remove pre-computed complex CanQualType.

[rjmccall]

LGTM

clang/lib/AST/ASTContext.cpp

 QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
                                                        QualType Domain) const {
   FloatingRank EltRank = getFloatingRank(Size);
   if (Domain->isComplexType()) {
     switch (EltRank) {
     case BFloat16Rank: llvm_unreachable("Complex bfloat16 is not supported");
     case Float16Rank:
     case HalfRank: llvm_unreachable("Complex half is not supported");
-    case Ibm128Rank: llvm_unreachable("Complex __ibm128 is not supported");
+    case Ibm128Rank:     return getComplexType(Ibm128Ty);
     case FloatRank:      return getComplexType(FloatTy);
     case DoubleRank:     return getComplexType(DoubleTy);
     case LongDoubleRank: return getComplexType(LongDoubleTy);
     case Float128Rank:   return getComplexType(Float128Ty);
     }
   }
 
   assert(Domain->isRealFloatingType() && "Unknown domain!");

clang/lib/Sema/DeclSpec.cpp

if (TypeSpecType == TST_unspecified) {
                                                  " double");
       TypeSpecType = TST_double;   // _Complex -> _Complex double.
     } else if (TypeSpecType == TST_int || TypeSpecType == TST_char ||
                TypeSpecType == TST_extint) {
       // Note that this intentionally doesn't include _Complex _Bool.
       if (!S.getLangOpts().CPlusPlus)
         S.Diag(TSTLoc, diag::ext_integer_complex);
     } else if (TypeSpecType != TST_float && TypeSpecType != TST_double &&
-               TypeSpecType != TST_float128 && TypeSpecType != TST_float16) {
+               TypeSpecType != TST_float128 && TypeSpecType != TST_float16 &&
+               TypeSpecType != TST_ibm128) {
       // FIXME: __fp16?
       S.Diag(TSCLoc, diag::err_invalid_complex_spec)
         << getSpecifierName((TST)TypeSpecType, Policy);
       TypeSpecComplex = TSC_unspecified;
     }
   }
 
   // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and

clang/test/CodeGen/ppc64-complex-parms.c

 // CHECK: define{{.*}} double @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 long double foo_long_double(_Complex long double x) {
   return creall(x);
 }
 
 // CHECK: define{{.*}} ppc_fp128 @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
+__ibm128 foo_ibm128(_Complex __ibm128 x) {
+  // We don't have a suffix for explicit __ibm128 type yet. Use *l instead.
+  return creall(x);
+}
+
+// CHECK: define{{.*}} ppc_fp128 @foo_ibm128(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
+
 int foo_int(_Complex int x) {
   return __real__ x;
 }
 
 // CHECK: define{{.*}} signext i32 @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 short foo_short(_Complex short x) {
   return __real__ x;

 // CHECK: store ppc_fp128 0xM40000000000000000000000000000000, ppc_fp128* %[[VAR22]]
 // CHECK: store ppc_fp128 0xMC0040000000000008000000000000000, ppc_fp128* %[[VAR23]]
 // CHECK: %[[VAR24:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
 // CHECK: %[[VAR25:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR24]], align 16
 // CHECK: %[[VAR26:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
 // CHECK: %[[VAR27:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR26]], align 16
 // CHECK: %{{[A-Za-z0-9.]+}} = call ppc_fp128 @foo_long_double(ppc_fp128 %[[VAR25]], ppc_fp128 %[[VAR27]])
 
+void bar_ibm128(void) {
+  foo_ibm128(2.0L - 2.5Li);
+}
+
+// CHECK: define{{.*}} void @bar_ibm128() [[NUW]] {
+// CHECK: %[[VAR21:[A-Za-z0-9.]+]] = alloca { ppc_fp128, ppc_fp128 }, align 16
+// CHECK: %[[VAR22:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
+// CHECK: %[[VAR23:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
+// CHECK: store ppc_fp128 0xM40000000000000000000000000000000, ppc_fp128* %[[VAR22]]
+// CHECK: store ppc_fp128 0xMC0040000000000008000000000000000, ppc_fp128* %[[VAR23]]
+// CHECK: %[[VAR24:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
+// CHECK: %[[VAR25:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR24]], align 16
+// CHECK: %[[VAR26:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
+// CHECK: %[[VAR27:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR26]], align 16
+// CHECK: %{{[A-Za-z0-9.]+}} = call ppc_fp128 @foo_ibm128(ppc_fp128 %[[VAR25]], ppc_fp128 %[[VAR27]])
+
 void bar_int(void) {
   foo_int(2 - 3i);
 }
 
 // CHECK: define{{.*}} void @bar_int() [[NUW]] {
 // CHECK: %[[VAR31:[A-Za-z0-9.]+]] = alloca { i32, i32 }, align 4
 // CHECK: %[[VAR32:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* %[[VAR31]], i32 0, i32 0
 // CHECK: %[[VAR33:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* %[[VAR31]], i32 0, i32 1

clang/test/CodeGen/ppc64-complex-return.c

 // CHECK: define{{.*}} { double, double } @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex long double foo_long_double(_Complex long double x) {
   return x;
 }
 
 // CHECK: define{{.*}} { ppc_fp128, ppc_fp128 } @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
+_Complex __ibm128 foo_ibm128(_Complex __ibm128 x) {
+  return x;
+}
+
+// CHECK: define{{.*}} { ppc_fp128, ppc_fp128 } @foo_ibm128(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
+
 _Complex int foo_int(_Complex int x) {
   return x;
 }
 
 // CHECK: define{{.*}} { i32, i32 } @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) [[NUW]] {
 
 _Complex short foo_short(_Complex short x) {
   return x;
long double bar_long_double(void) {
   return creall(foo_long_double(2.0L - 2.5Li));
 }
 
 // CHECK: define{{.*}} ppc_fp128 @bar_long_double() [[NUW]] {
 // CHECK: [[VAR3:[%A-Za-z0-9.]+]] = call { ppc_fp128, ppc_fp128 } @foo_long_double
 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 0
 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 1
 
+__ibm128 bar_ibm128(void) {
+  return creall(foo_ibm128(2.0L - 2.5Li));
+}
+
+// CHECK: define{{.*}} ppc_fp128 @bar_ibm128() [[NUW]] {
+// CHECK: [[VAR3:[%A-Za-z0-9.]+]] = call { ppc_fp128, ppc_fp128 } @foo_ibm128
+// CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 0
+// CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 1
+
 #ifdef TEST_F128
 __float128 bar_f128(void) {
   return crealf128(foo_f128(2.0Q - 2.5Qi));
 }
 
 // CHECK-F128: define{{.*}} fp128 @bar_f128() [[NUW]] {
 // CHECK-F128: [[VAR3:[%A-Za-z0-9.]+]] = call { fp128, fp128 } @foo_f128
 // CHECK-F128: extractvalue { fp128, fp128 } [[VAR3]], 0