[clang] 168be42 - [Clang] Mutate long-double math builtins into f128 under IEEE-quad
Qiu Chaofan via cfe-commits
cfe-commits at lists.llvm.org
Fri Jan 15 00:56:33 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 cfe-commits
mailing list