forked from OSchip/llvm-project
[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
This commit is contained in:
Qiu Chaofan
parent
33be50daa9
commit
168be42083
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue