[llvm-branch-commits] [clang] 168be42 - [Clang] Mutate long-double math builtins into f128 under IEEE-quad

Qiu Chaofan via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Fri Jan 15 01:01:15 PST 2021


Author: Qiu Chaofan
Date: 2021-01-15T16:56:20+08:00
New Revision: 168be4208304e36d3bb156b5c413b340a391383e

URL: https://github.com/llvm/llvm-project/commit/168be4208304e36d3bb156b5c413b340a391383e
DIFF: https://github.com/llvm/llvm-project/commit/168be4208304e36d3bb156b5c413b340a391383e.diff

LOG: [Clang] Mutate long-double math builtins into f128 under IEEE-quad

Under -mabi=ieeelongdouble on PowerPC, IEEE-quad floating point semantic
is used for long double. This patch mutates call to related builtins
into f128 version on PowerPC. And in theory, this should be applied to
other targets when their backend supports IEEE 128-bit style libcalls.

GCC already has these mutations except nansl, which is not available on
PowerPC along with other variants (nans, nansf).

Reviewed By: RKSimon, nemanjai

Differential Revision: https://reviews.llvm.org/D92080

Added: 
    

Modified: 
    clang/lib/CodeGen/CGBuiltin.cpp
    clang/test/CodeGen/math-builtins-long.c

Removed: 
    


################################################################################
diff  --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index 7fa4e4d270ad..25ebb67c2ab6 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -2107,6 +2107,78 @@ RValue CodeGenFunction::emitRotate(const CallExpr *E, bool IsRotateRight) {
   return RValue::get(Builder.CreateCall(F, { Src, Src, ShiftAmt }));
 }
 
+// Map math builtins for long-double to f128 version.
+static unsigned mutateLongDoubleBuiltin(unsigned BuiltinID) {
+  switch (BuiltinID) {
+#define MUTATE_LDBL(func) \
+  case Builtin::BI__builtin_##func##l: \
+    return Builtin::BI__builtin_##func##f128;
+  MUTATE_LDBL(sqrt)
+  MUTATE_LDBL(cbrt)
+  MUTATE_LDBL(fabs)
+  MUTATE_LDBL(log)
+  MUTATE_LDBL(log2)
+  MUTATE_LDBL(log10)
+  MUTATE_LDBL(log1p)
+  MUTATE_LDBL(logb)
+  MUTATE_LDBL(exp)
+  MUTATE_LDBL(exp2)
+  MUTATE_LDBL(expm1)
+  MUTATE_LDBL(fdim)
+  MUTATE_LDBL(hypot)
+  MUTATE_LDBL(ilogb)
+  MUTATE_LDBL(pow)
+  MUTATE_LDBL(fmin)
+  MUTATE_LDBL(fmax)
+  MUTATE_LDBL(ceil)
+  MUTATE_LDBL(trunc)
+  MUTATE_LDBL(rint)
+  MUTATE_LDBL(nearbyint)
+  MUTATE_LDBL(round)
+  MUTATE_LDBL(floor)
+  MUTATE_LDBL(lround)
+  MUTATE_LDBL(llround)
+  MUTATE_LDBL(lrint)
+  MUTATE_LDBL(llrint)
+  MUTATE_LDBL(fmod)
+  MUTATE_LDBL(modf)
+  MUTATE_LDBL(nan)
+  MUTATE_LDBL(nans)
+  MUTATE_LDBL(inf)
+  MUTATE_LDBL(fma)
+  MUTATE_LDBL(sin)
+  MUTATE_LDBL(cos)
+  MUTATE_LDBL(tan)
+  MUTATE_LDBL(sinh)
+  MUTATE_LDBL(cosh)
+  MUTATE_LDBL(tanh)
+  MUTATE_LDBL(asin)
+  MUTATE_LDBL(acos)
+  MUTATE_LDBL(atan)
+  MUTATE_LDBL(asinh)
+  MUTATE_LDBL(acosh)
+  MUTATE_LDBL(atanh)
+  MUTATE_LDBL(atan2)
+  MUTATE_LDBL(erf)
+  MUTATE_LDBL(erfc)
+  MUTATE_LDBL(ldexp)
+  MUTATE_LDBL(frexp)
+  MUTATE_LDBL(huge_val)
+  MUTATE_LDBL(copysign)
+  MUTATE_LDBL(nextafter)
+  MUTATE_LDBL(nexttoward)
+  MUTATE_LDBL(remainder)
+  MUTATE_LDBL(remquo)
+  MUTATE_LDBL(scalbln)
+  MUTATE_LDBL(scalbn)
+  MUTATE_LDBL(tgamma)
+  MUTATE_LDBL(lgamma)
+#undef MUTATE_LDBL
+  default:
+    return BuiltinID;
+  }
+}
+
 RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
                                         const CallExpr *E,
                                         ReturnValueSlot ReturnValue) {
@@ -2123,6 +2195,14 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
                                                Result.Val.getFloat()));
   }
 
+  // If current long-double semantics is IEEE 128-bit, replace math builtins
+  // of long-double with f128 equivalent.
+  // TODO: This mutation should also be applied to other targets other than PPC,
+  // after backend supports IEEE 128-bit style libcalls.
+  if (getTarget().getTriple().isPPC64() &&
+      &getTarget().getLongDoubleFormat() == &llvm::APFloat::IEEEquad())
+    BuiltinID = mutateLongDoubleBuiltin(BuiltinID);
+
   // If the builtin has been declared explicitly with an assembler label,
   // disable the specialized emitting below. Ideally we should communicate the
   // rename in IR, or at least avoid generating the intrinsic calls that are

diff  --git a/clang/test/CodeGen/math-builtins-long.c b/clang/test/CodeGen/math-builtins-long.c
index bf7ebd314444..f5cee75acad6 100644
--- a/clang/test/CodeGen/math-builtins-long.c
+++ b/clang/test/CodeGen/math-builtins-long.c
@@ -13,13 +13,13 @@ void foo(long double f, long double *l, int *i, const char *c) {
   // F80: call x86_fp80 @fmodl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @fmodl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @fmodl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @fmodl(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @fmodf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_fmodl(f,f);
 
   // F80: call x86_fp80 @atan2l(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @atan2l(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @atan2l(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @atan2l(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @atan2f128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_atan2l(f,f);
 
   // F80: call x86_fp80 @llvm.copysign.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
@@ -37,7 +37,7 @@ void foo(long double f, long double *l, int *i, const char *c) {
   // F80: call x86_fp80 @frexpl(x86_fp80 %{{.+}}, i32* %{{.+}})
   // PPC: call ppc_fp128 @frexpl(ppc_fp128 %{{.+}}, i32* %{{.+}})
   // X86F128: call fp128 @frexpl(fp128 %{{.+}}, i32* %{{.+}})
-  // PPCF128: call fp128 @frexpl(fp128 %{{.+}}, i32* %{{.+}})
+  // PPCF128: call fp128 @frexpf128(fp128 %{{.+}}, i32* %{{.+}})
   __builtin_frexpl(f,i);
 
   // F80: store x86_fp80 0xK7FFF8000000000000000, x86_fp80*
@@ -55,73 +55,73 @@ void foo(long double f, long double *l, int *i, const char *c) {
   // F80: call x86_fp80 @ldexpl(x86_fp80 %{{.+}}, i32 %{{.+}})
   // PPC: call ppc_fp128 @ldexpl(ppc_fp128 %{{.+}}, {{(signext)?.+}})
   // X86F128: call fp128 @ldexpl(fp128 %{{.+}}, {{(signext)?.+}})
-  // PPCF128: call fp128 @ldexpl(fp128 %{{.+}}, {{(signext)?.+}})
+  // PPCF128: call fp128 @ldexpf128(fp128 %{{.+}}, {{(signext)?.+}})
   __builtin_ldexpl(f,f);
 
   // F80: call x86_fp80 @modfl(x86_fp80 %{{.+}}, x86_fp80* %{{.+}})
   // PPC: call ppc_fp128 @modfl(ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}})
   // X86F128: call fp128 @modfl(fp128 %{{.+}}, fp128* %{{.+}})
-  // PPCF128: call fp128 @modfl(fp128 %{{.+}}, fp128* %{{.+}})
+  // PPCF128: call fp128 @modff128(fp128 %{{.+}}, fp128* %{{.+}})
   __builtin_modfl(f,l);
 
   // F80: call x86_fp80 @nanl(i8* %{{.+}})
   // PPC: call ppc_fp128 @nanl(i8* %{{.+}})
   // X86F128: call fp128 @nanl(i8* %{{.+}})
-  // PPCF128: call fp128 @nanl(i8* %{{.+}})
+  // PPCF128: call fp128 @nanf128(i8* %{{.+}})
   __builtin_nanl(c);
 
   // F80: call x86_fp80 @nansl(i8* %{{.+}})
   // PPC: call ppc_fp128 @nansl(i8* %{{.+}})
   // X86F128: call fp128 @nansl(i8* %{{.+}})
-  // PPCF128: call fp128 @nansl(i8* %{{.+}})
+  // PPCF128: call fp128 @nansf128(i8* %{{.+}})
   __builtin_nansl(c);
 
   // F80: call x86_fp80 @powl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @powl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @powl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @powl(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @powf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_powl(f,f);
 
   // F80: call x86_fp80 @acosl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @acosl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @acosl(fp128 %{{.+}})
-  // PPCF128: call fp128 @acosl(fp128 %{{.+}})
+  // PPCF128: call fp128 @acosf128(fp128 %{{.+}})
   __builtin_acosl(f);
 
   // F80: call x86_fp80 @acoshl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @acoshl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @acoshl(fp128 %{{.+}})
-  // PPCF128: call fp128 @acoshl(fp128 %{{.+}})
+  // PPCF128: call fp128 @acoshf128(fp128 %{{.+}})
   __builtin_acoshl(f);
 
   // F80: call x86_fp80 @asinl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @asinl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @asinl(fp128 %{{.+}})
-  // PPCF128: call fp128 @asinl(fp128 %{{.+}})
+  // PPCF128: call fp128 @asinf128(fp128 %{{.+}})
   __builtin_asinl(f);
 
   // F80: call x86_fp80 @asinhl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @asinhl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @asinhl(fp128 %{{.+}})
-  // PPCF128: call fp128 @asinhl(fp128 %{{.+}})
+  // PPCF128: call fp128 @asinhf128(fp128 %{{.+}})
   __builtin_asinhl(f);
 
   // F80: call x86_fp80 @atanl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @atanl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @atanl(fp128 %{{.+}})
-  // PPCF128: call fp128 @atanl(fp128 %{{.+}})
+  // PPCF128: call fp128 @atanf128(fp128 %{{.+}})
   __builtin_atanl(f);
 
   // F80: call x86_fp80 @atanhl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @atanhl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @atanhl(fp128 %{{.+}})
-  // PPCF128: call fp128 @atanhl(fp128 %{{.+}})
+  // PPCF128: call fp128 @atanhf128(fp128 %{{.+}})
   __builtin_atanhl(f);
 
   // F80: call x86_fp80 @cbrtl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @cbrtl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @cbrtl(fp128 %{{.+}})
-  // PPCF128: call fp128 @cbrtl(fp128 %{{.+}})
+  // PPCF128: call fp128 @cbrtf128(fp128 %{{.+}})
   __builtin_cbrtl(f);
 
   // F80: call x86_fp80 @llvm.ceil.f80(x86_fp80 %{{.+}})
@@ -133,13 +133,13 @@ void foo(long double f, long double *l, int *i, const char *c) {
   // F80: call x86_fp80 @cosl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @cosl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @cosl(fp128 %{{.+}})
-  // PPCF128: call fp128 @cosl(fp128 %{{.+}})
+  // PPCF128: call fp128 @cosf128(fp128 %{{.+}})
   __builtin_cosl(f);
 
   // F80: call x86_fp80 @coshl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @coshl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @coshl(fp128 %{{.+}})
-  // PPCF128: call fp128 @coshl(fp128 %{{.+}})
+  // PPCF128: call fp128 @coshf128(fp128 %{{.+}})
   __builtin_coshl(f);
 
   // F80: call x86_fp80 @llvm.floor.f80(x86_fp80 %{{.+}})
@@ -183,189 +183,190 @@ void foo(long double f, long double *l, int *i, const char *c) {
   // X86F128: call fp128 @llvm.round.f128(fp128 %{{.+}})
   // PPCF128: call fp128 @llvm.round.f128(fp128 %{{.+}})
   __builtin_roundl(f);
+
   // F80: call x86_fp80 @erfl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @erfl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @erfl(fp128 %{{.+}})
-  // PPCF128: call fp128 @erfl(fp128 %{{.+}})
+  // PPCF128: call fp128 @erff128(fp128 %{{.+}})
   __builtin_erfl(f);
 
   // F80: call x86_fp80 @erfcl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @erfcl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @erfcl(fp128 %{{.+}})
-  // PPCF128: call fp128 @erfcl(fp128 %{{.+}})
+  // PPCF128: call fp128 @erfcf128(fp128 %{{.+}})
   __builtin_erfcl(f);
 
   // F80: call x86_fp80 @expl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @expl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @expl(fp128 %{{.+}})
-  // PPCF128: call fp128 @expl(fp128 %{{.+}})
+  // PPCF128: call fp128 @expf128(fp128 %{{.+}})
   __builtin_expl(f);
 
   // F80: call x86_fp80 @exp2l(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @exp2l(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @exp2l(fp128 %{{.+}})
-  // PPCF128: call fp128 @exp2l(fp128 %{{.+}})
+  // PPCF128: call fp128 @exp2f128(fp128 %{{.+}})
   __builtin_exp2l(f);
 
   // F80: call x86_fp80 @expm1l(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @expm1l(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @expm1l(fp128 %{{.+}})
-  // PPCF128: call fp128 @expm1l(fp128 %{{.+}})
+  // PPCF128: call fp128 @expm1f128(fp128 %{{.+}})
   __builtin_expm1l(f);
 
   // F80: call x86_fp80 @fdiml(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @fdiml(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @fdiml(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @fdiml(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @fdimf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_fdiml(f,f);
 
   // F80: call x86_fp80 @fmal(x86_fp80 %{{.+}}, x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @fmal(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @fmal(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @fmal(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @fmaf128(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_fmal(f,f,f);
 
   // F80: call x86_fp80 @hypotl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @hypotl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @hypotl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @hypotl(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @hypotf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_hypotl(f,f);
 
   // F80: call i32 @ilogbl(x86_fp80 %{{.+}})
   // PPC: call {{(i32)|(signext i32)}} @ilogbl(ppc_fp128 %{{.+}})
   // X86F128: call {{(i32)|(signext i32)}} @ilogbl(fp128 %{{.+}})
-  // PPCF128: call {{(i32)|(signext i32)}} @ilogbl(fp128 %{{.+}})
+  // PPCF128: call {{(i32)|(signext i32)}} @ilogbf128(fp128 %{{.+}})
   __builtin_ilogbl(f);
 
   // F80: call x86_fp80 @lgammal(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @lgammal(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @lgammal(fp128 %{{.+}})
-  // PPCF128: call fp128 @lgammal(fp128 %{{.+}})
+  // PPCF128: call fp128 @lgammaf128(fp128 %{{.+}})
   __builtin_lgammal(f);
 
   // F80: call i64 @llrintl(x86_fp80 %{{.+}})
   // PPC: call i64 @llrintl(ppc_fp128 %{{.+}})
   // X86F128: call i64 @llrintl(fp128 %{{.+}})
-  // PPCF128: call i64 @llrintl(fp128 %{{.+}})
+  // PPCF128: call i64 @llrintf128(fp128 %{{.+}})
   __builtin_llrintl(f);
 
   // F80: call i64 @llroundl(x86_fp80 %{{.+}})
   // PPC: call i64 @llroundl(ppc_fp128 %{{.+}})
   // X86F128: call i64 @llroundl(fp128 %{{.+}})
-  // PPCF128: call i64 @llroundl(fp128 %{{.+}})
+  // PPCF128: call i64 @llroundf128(fp128 %{{.+}})
   __builtin_llroundl(f);
 
   // F80: call x86_fp80 @logl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @logl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @logl(fp128 %{{.+}})
-  // PPCF128: call fp128 @logl(fp128 %{{.+}})
+  // PPCF128: call fp128 @logf128(fp128 %{{.+}})
   __builtin_logl(f);
 
   // F80: call x86_fp80 @log10l(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @log10l(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @log10l(fp128 %{{.+}})
-  // PPCF128: call fp128 @log10l(fp128 %{{.+}})
+  // PPCF128: call fp128 @log10f128(fp128 %{{.+}})
   __builtin_log10l(f);
 
   // F80: call x86_fp80 @log1pl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @log1pl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @log1pl(fp128 %{{.+}})
-  // PPCF128: call fp128 @log1pl(fp128 %{{.+}})
+  // PPCF128: call fp128 @log1pf128(fp128 %{{.+}})
   __builtin_log1pl(f);
 
   // F80: call x86_fp80 @log2l(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @log2l(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @log2l(fp128 %{{.+}})
-  // PPCF128: call fp128 @log2l(fp128 %{{.+}})
+  // PPCF128: call fp128 @log2f128(fp128 %{{.+}})
   __builtin_log2l(f);
 
   // F80: call x86_fp80 @logbl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @logbl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @logbl(fp128 %{{.+}})
-  // PPCF128: call fp128 @logbl(fp128 %{{.+}})
+  // PPCF128: call fp128 @logbf128(fp128 %{{.+}})
   __builtin_logbl(f);
 
   // F80: call i64 @lrintl(x86_fp80 %{{.+}})
   // PPC: call i64 @lrintl(ppc_fp128 %{{.+}})
   // X86F128: call i64 @lrintl(fp128 %{{.+}})
-  // PPCF128: call i64 @lrintl(fp128 %{{.+}})
+  // PPCF128: call i64 @lrintf128(fp128 %{{.+}})
   __builtin_lrintl(f);
 
   // F80: call i64 @lroundl(x86_fp80 %{{.+}})
   // PPC: call i64 @lroundl(ppc_fp128 %{{.+}})
   // X86F128: call i64 @lroundl(fp128 %{{.+}})
-  // PPCF128: call i64 @lroundl(fp128 %{{.+}})
+  // PPCF128: call i64 @lroundf128(fp128 %{{.+}})
   __builtin_lroundl(f);
 
   // F80: call x86_fp80 @nextafterl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @nextafterl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @nextafterl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @nextafterl(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @nextafterf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_nextafterl(f,f);
 
   // F80: call x86_fp80 @nexttowardl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @nexttowardl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @nexttowardl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @nexttowardl(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @nexttowardf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_nexttowardl(f,f);
 
   // F80: call x86_fp80 @remainderl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @remainderl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @remainderl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @remainderl(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @remainderf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_remainderl(f,f);
 
   // F80: call x86_fp80 @remquol(x86_fp80 %{{.+}}, x86_fp80 %{{.+}}, i32* %{{.+}})
   // PPC: call ppc_fp128 @remquol(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}}, i32* %{{.+}})
   // X86F128: call fp128 @remquol(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
-  // PPCF128: call fp128 @remquol(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
+  // PPCF128: call fp128 @remquof128(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
   __builtin_remquol(f,f,i);
 
   // F80: call x86_fp80 @scalblnl(x86_fp80 %{{.+}}, i64 %{{.+}})
   // PPC: call ppc_fp128 @scalblnl(ppc_fp128 %{{.+}}, i64 %{{.+}})
   // X86F128: call fp128 @scalblnl(fp128 %{{.+}}, i64 %{{.+}})
-  // PPCF128: call fp128 @scalblnl(fp128 %{{.+}}, i64 %{{.+}})
+  // PPCF128: call fp128 @scalblnf128(fp128 %{{.+}}, i64 %{{.+}})
   __builtin_scalblnl(f,f);
 
   // F80: call x86_fp80 @scalbnl(x86_fp80 %{{.+}}, i32 %{{.+}})
   // PPC: call ppc_fp128 @scalbnl(ppc_fp128 %{{.+}}, {{(signext)?.+}})
   // X86F128: call fp128 @scalbnl(fp128 %{{.+}}, {{(signext)?.+}})
-  // PPCF128: call fp128 @scalbnl(fp128 %{{.+}}, {{(signext)?.+}})
+  // PPCF128: call fp128 @scalbnf128(fp128 %{{.+}}, {{(signext)?.+}})
   __builtin_scalbnl(f,f);
 
   // F80: call x86_fp80 @sinl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @sinl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @sinl(fp128 %{{.+}})
-  // PPCF128: call fp128 @sinl(fp128 %{{.+}})
+  // PPCF128: call fp128 @sinf128(fp128 %{{.+}})
   __builtin_sinl(f);
 
   // F80: call x86_fp80 @sinhl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @sinhl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @sinhl(fp128 %{{.+}})
-  // PPCF128: call fp128 @sinhl(fp128 %{{.+}})
+  // PPCF128: call fp128 @sinhf128(fp128 %{{.+}})
   __builtin_sinhl(f);
 
   // F80: call x86_fp80 @sqrtl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @sqrtl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @sqrtl(fp128 %{{.+}})
-  // PPCF128: call fp128 @sqrtl(fp128 %{{.+}})
+  // PPCF128: call fp128 @sqrtf128(fp128 %{{.+}})
   __builtin_sqrtl(f);
 
   // F80: call x86_fp80 @tanl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @tanl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @tanl(fp128 %{{.+}})
-  // PPCF128: call fp128 @tanl(fp128 %{{.+}})
+  // PPCF128: call fp128 @tanf128(fp128 %{{.+}})
   __builtin_tanl(f);
 
   // F80: call x86_fp80 @tanhl(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @tanhl(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @tanhl(fp128 %{{.+}})
-  // PPCF128: call fp128 @tanhl(fp128 %{{.+}})
+  // PPCF128: call fp128 @tanhf128(fp128 %{{.+}})
   __builtin_tanhl(f);
 
   // F80: call x86_fp80 @tgammal(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @tgammal(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @tgammal(fp128 %{{.+}})
-  // PPCF128: call fp128 @tgammal(fp128 %{{.+}})
+  // PPCF128: call fp128 @tgammaf128(fp128 %{{.+}})
   __builtin_tgammal(f);
 }


        


More information about the llvm-branch-commits mailing list