[Power9] Add six __float128 builtins found in gcc

[stefanp]

Summary

The following 6 builtins are found in GCC:

__float128 __builtin_infq (void)
__float128 __builtin_huge_valq (void)
__float128 __builtin_nanq (void)
__float128 __builtin_nansq (void)
__float128 __builtin_fabsq (__float128)
__float128 __builtin_copysignq (__float128, __float128)

This patch adds them to clang as well.
They should do the exact same thing as the f128 version of the same builtin. (So, float128 builtin_nanq (void) should behave the same way as float128 builtin_nanf128 (void)).
The reason for adding these builtins is to support code that uses the initial GCC naming for them.

[stefanp]

We have determined that we do not require these builtin names.

include/clang/Basic/Builtins.def

 BUILTIN(__builtin_atan2 , "ddd"  , "Fne")
 BUILTIN(__builtin_atan2f, "fff"  , "Fne")
 BUILTIN(__builtin_atan2l, "LdLdLd", "Fne")
 BUILTIN(__builtin_abs  , "ii"  , "ncF")
 BUILTIN(__builtin_copysign, "ddd", "ncF")
 BUILTIN(__builtin_copysignf, "fff", "ncF")
 BUILTIN(__builtin_copysignl, "LdLdLd", "ncF")
 BUILTIN(__builtin_copysignf128, "LLdLLdLLd", "ncF")
+BUILTIN(__builtin_copysignq, "LLdLLdLLd", "ncF")
 BUILTIN(__builtin_fabs , "dd"  , "ncF")
 BUILTIN(__builtin_fabsf, "ff"  , "ncF")
 BUILTIN(__builtin_fabsl, "LdLd", "ncF")
 BUILTIN(__builtin_fabsf128, "LLdLLd", "ncF")
+BUILTIN(__builtin_fabsq, "LLdLLd", "ncF")
 BUILTIN(__builtin_fmod , "ddd"  , "Fne")
 BUILTIN(__builtin_fmodf, "fff"  , "Fne")
 BUILTIN(__builtin_fmodl, "LdLdLd", "Fne")
 BUILTIN(__builtin_frexp , "ddi*"  , "Fn")
 BUILTIN(__builtin_frexpf, "ffi*"  , "Fn")
 BUILTIN(__builtin_frexpl, "LdLdi*", "Fn")
 BUILTIN(__builtin_huge_val, "d", "nc")
 BUILTIN(__builtin_huge_valf, "f", "nc")
 BUILTIN(__builtin_huge_vall, "Ld", "nc")
 BUILTIN(__builtin_huge_valf128, "LLd", "nc")
+BUILTIN(__builtin_huge_valq, "LLd", "nc")
 BUILTIN(__builtin_inf  , "d"   , "nc")
 BUILTIN(__builtin_inff , "f"   , "nc")
 BUILTIN(__builtin_infl , "Ld"  , "nc")
 BUILTIN(__builtin_inff128 , "LLd"  , "nc")
+BUILTIN(__builtin_infq , "LLd"  , "nc")
 BUILTIN(__builtin_labs , "LiLi"  , "Fnc")
 BUILTIN(__builtin_llabs, "LLiLLi", "Fnc")
 BUILTIN(__builtin_ldexp , "ddi"  , "Fne")
 BUILTIN(__builtin_ldexpf, "ffi"  , "Fne")
 BUILTIN(__builtin_ldexpl, "LdLdi", "Fne")
 BUILTIN(__builtin_modf , "ddd*"  , "Fn")
 BUILTIN(__builtin_modff, "fff*"  , "Fn")
 BUILTIN(__builtin_modfl, "LdLdLd*", "Fn")
 BUILTIN(__builtin_nan,  "dcC*" , "ncF")
 BUILTIN(__builtin_nanf, "fcC*" , "ncF")
 BUILTIN(__builtin_nanl, "LdcC*", "ncF")
 BUILTIN(__builtin_nanf128, "LLdcC*", "ncF")
+BUILTIN(__builtin_nanq, "LLdcC*", "ncF")
 BUILTIN(__builtin_nans,  "dcC*" , "ncF")
 BUILTIN(__builtin_nansf, "fcC*" , "ncF")
 BUILTIN(__builtin_nansl, "LdcC*", "ncF")
 BUILTIN(__builtin_nansf128, "LLdcC*", "ncF")
+BUILTIN(__builtin_nansq, "LLdcC*", "ncF")
 BUILTIN(__builtin_powi , "ddi"  , "Fnc")
 BUILTIN(__builtin_powif, "ffi"  , "Fnc")
 BUILTIN(__builtin_powil, "LdLdi", "Fnc")
 BUILTIN(__builtin_pow , "ddd"  , "Fne")
 BUILTIN(__builtin_powf, "fff"  , "Fne")
 BUILTIN(__builtin_powl, "LdLdLd", "Fne")
 
 // Standard unary libc/libm functions with double/float/long double variants:

lib/AST/ExprConstant.cpp

 bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
   switch (E->getBuiltinCallee()) {
   default:
     return ExprEvaluatorBaseTy::VisitCallExpr(E);
 
   case Builtin::BI__builtin_huge_val:
   case Builtin::BI__builtin_huge_valf:
   case Builtin::BI__builtin_huge_vall:
+  case Builtin::BI__builtin_huge_valq:
   case Builtin::BI__builtin_huge_valf128:
   case Builtin::BI__builtin_inf:
   case Builtin::BI__builtin_inff:
   case Builtin::BI__builtin_infl:
+  case Builtin::BI__builtin_infq:
   case Builtin::BI__builtin_inff128: {
     const llvm::fltSemantics &Sem =
       Info.Ctx.getFloatTypeSemantics(E->getType());
     Result = llvm::APFloat::getInf(Sem);
     return true;
   }
 
   case Builtin::BI__builtin_nans:
   case Builtin::BI__builtin_nansf:
   case Builtin::BI__builtin_nansl:
+  case Builtin::BI__builtin_nansq:
   case Builtin::BI__builtin_nansf128:
     if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
                                true, Result))
       return Error(E);
     return true;
 
   case Builtin::BI__builtin_nan:
   case Builtin::BI__builtin_nanf:
   case Builtin::BI__builtin_nanl:
+  case Builtin::BI__builtin_nanq:
   case Builtin::BI__builtin_nanf128:
     // If this is __builtin_nan() turn this into a nan, otherwise we
     // can't constant fold it.
     if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
                                false, Result))
       return Error(E);
     return true;
 
   case Builtin::BI__builtin_fabs:
   case Builtin::BI__builtin_fabsf:
   case Builtin::BI__builtin_fabsl:
+  case Builtin::BI__builtin_fabsq:
   case Builtin::BI__builtin_fabsf128:
     if (!EvaluateFloat(E->getArg(0), Result, Info))
       return false;
 
     if (Result.isNegative())
       Result.changeSign();
     return true;
 
   // FIXME: Builtin::BI__builtin_powi
   // FIXME: Builtin::BI__builtin_powif
   // FIXME: Builtin::BI__builtin_powil
 
   case Builtin::BI__builtin_copysign:
   case Builtin::BI__builtin_copysignf:
   case Builtin::BI__builtin_copysignl:
+  case Builtin::BI__builtin_copysignq:
   case Builtin::BI__builtin_copysignf128: {
     APFloat RHS(0.);
     if (!EvaluateFloat(E->getArg(0), Result, Info) ||
         !EvaluateFloat(E->getArg(1), RHS, Info))
       return false;
     Result.copySign(RHS);
     return true;
   }

lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_ceill:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::ceil));
 
     case Builtin::BIcopysign:
     case Builtin::BIcopysignf:
     case Builtin::BIcopysignl:
     case Builtin::BI__builtin_copysign:
     case Builtin::BI__builtin_copysignf:
     case Builtin::BI__builtin_copysignl:
+    case Builtin::BI__builtin_copysignq:
     case Builtin::BI__builtin_copysignf128:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
 
     case Builtin::BIcos:
     case Builtin::BIcosf:
     case Builtin::BIcosl:
     case Builtin::BI__builtin_cos:
     case Builtin::BI__builtin_cosf:
case Builtin::BI__builtin_exp2l:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp2));
 
     case Builtin::BIfabs:
     case Builtin::BIfabsf:
     case Builtin::BIfabsl:
     case Builtin::BI__builtin_fabs:
     case Builtin::BI__builtin_fabsf:
     case Builtin::BI__builtin_fabsl:
+    case Builtin::BI__builtin_fabsq:
     case Builtin::BI__builtin_fabsf128:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
 
     case Builtin::BIfloor:
     case Builtin::BIfloorf:
     case Builtin::BIfloorl:
     case Builtin::BI__builtin_floor:
     case Builtin::BI__builtin_floorf:

test/CodeGen/builtins-ppc-p9-f128.c

 }
 
 unsigned long long int extract_exp() {
     return __builtin_vsx_scalar_extract_expq(A);
 // CHECK: @llvm.ppc.scalar.extract.expq(fp128
 // CHECK-NEXT: ret i64
 }
 
+__float128 test_infq() {
+  return __builtin_infq();
+// CHECK: ret fp128 0xL00000000000000007FFF000000000000
+}
+
+__float128 test_huge_valq() {
+  return __builtin_huge_valq();
+// CHECK: ret fp128 0xL00000000000000007FFF000000000000
+}
+
+__float128 test_nanq() {
+  return __builtin_nanq("0");
+// CHECK: ret fp128 0xL00000000000000007FFF800000000000
+}
+
+__float128 test_nansq() {
+  return __builtin_nansq("0");
+// CHECK: ret fp128 0xL00000000000000007FFF400000000000
+}
+
+__float128 test_fabsq() {
+  return __builtin_fabsq(A);
+// CHECK: @llvm.fabs.f128(fp128
+// CHECK-NEXT: ret fp128
+}
+
+__float128 test_copysignq() {
+  return __builtin_copysignq(A, B);
+// CHECK: @llvm.copysign.f128(fp128 %{{.+}}, fp128
+// CHECK-NEXT: ret fp128
+}
+
 

test/Sema/constant-builtins-2.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Math stuff
 
 double       g0  = __builtin_huge_val();
 float        g1  = __builtin_huge_valf();
 long double  g2  = __builtin_huge_vall();
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+__float128   g2_1 = __builtin_huge_valq();
 __float128   g2_2 = __builtin_huge_valf128();
 #endif
 
 double       g3  = __builtin_inf();
 float        g4  = __builtin_inff();
 long double  g5  = __builtin_infl();
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+__float128   g5_1 = __builtin_infq();
 __float128   g5_2 = __builtin_inff128();
 #endif
 
 double       g6  = __builtin_nan("");
 float        g7  = __builtin_nanf("");
 long double  g8  = __builtin_nanl("");
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+__float128   g8_1 = __builtin_nanq("");
 __float128   g8_2 = __builtin_nanf128("");
 #endif
 
 // GCC constant folds these too (via native strtol):
 //double       g6_1  = __builtin_nan("1");
 //float        g7_1  = __builtin_nanf("1");
 //long double  g8_1  = __builtin_nanl("1");
 
 double       g9  = __builtin_nans("");
 float        g10 = __builtin_nansf("");
 long double  g11 = __builtin_nansl("");
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+__float128   g11_1 = __builtin_nansq("");
 __float128   g11_2 = __builtin_nansf128("");
 #endif
 
 //int          g12 = __builtin_abs(-12);
 
 double       g13 = __builtin_fabs(-12.);
 double       g13_0 = __builtin_fabs(-0.);
 double       g13_1 = __builtin_fabs(-__builtin_inf());
 float        g14 = __builtin_fabsf(-12.f);
 // GCC doesn't eat this one.
 //long double  g15 = __builtin_fabsfl(-12.0L);
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+__float128   g15_1 = __builtin_fabsq(-12.q);
 __float128   g15_2 = __builtin_fabsf128(-12.q);
 #endif
 
 float        g16 = __builtin_copysign(1.0, -1.0);
 double       g17 = __builtin_copysignf(1.0f, -1.0f);
 long double  g18 = __builtin_copysignl(1.0L, -1.0L);
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+__float128   g18_1 = __builtin_copysignq(1.0q, -1.0q);
 __float128   g18_2 = __builtin_copysignf128(1.0q, -1.0q);
 #endif
 
 char classify_nan     [__builtin_fpclassify(+1, -1, -1, -1, -1, __builtin_nan(""))];
 char classify_snan    [__builtin_fpclassify(+1, -1, -1, -1, -1, __builtin_nans(""))];
 char classify_inf     [__builtin_fpclassify(-1, +1, -1, -1, -1, __builtin_inf())];
 char classify_neg_inf [__builtin_fpclassify(-1, +1, -1, -1, -1, -__builtin_inf())];
 char classify_normal  [__builtin_fpclassify(-1, -1, +1, -1, -1, 1.539)];