Index: clang/lib/CodeGen/CGBuiltin.cpp =================================================================== --- clang/lib/CodeGen/CGBuiltin.cpp +++ clang/lib/CodeGen/CGBuiltin.cpp @@ -2066,6 +2066,78 @@ 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) { @@ -2082,6 +2154,14 @@ 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 Index: clang/test/CodeGen/math-builtins-long.c =================================================================== --- clang/test/CodeGen/math-builtins-long.c +++ clang/test/CodeGen/math-builtins-long.c @@ -13,13 +13,13 @@ // 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 @@ // 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 @@ // 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 @@ // 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 @@ // 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); }