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

[qiucf]

Summary

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.

[craig.topper]

gcc calls the *l version with -mlong-double-128 on x86. Should we match gcc here?

[qiucf]

In D92080#2416625, @craig.topper wrote:

gcc calls the *l version with -mlong-double-128 on x86. Should we match gcc here?

Ah, yes, so this should be PPC-only change.

But I see under x86 -mlong-double-128, std functions (printf/sqrtl/...) can't provide correct results (seems they're just for fp80). Is this expected?

[qiucf]

Any comments...? I don't have knowledge if there's any plan about implementing *f128 math functions on X86 libcs. But as I see so far, *l doesn't work well on fp128. Keeping this target independent currently seems reasonable to me.

[RKSimon]

Please can you pre-commit math-builtins-adjust.c with current IR checks and then rebase to show the diffs? Maybe rename it math-builtins-long.c as well?

[craig.topper]

I don't think I understand the whole picture here. Why would only builtins get mutated? Does a call to "modf" still call "modf"? But builtin_modf will call modf128? Is there a corresponding patch to the runtime libcalls table in the backend? With -ffast-math builtin_sinl becomes llvm.sin.f128 and the backend will emit a call to sinl if ISD::SIN isn't legal.

[qiucf]

In D92080#2443333, @craig.topper wrote:

I don't think I understand the whole picture here. Why would only builtins get mutated? Does a call to "modf" still call "modf"? But builtin_modf will call modf128? Is there a corresponding patch to the runtime libcalls table in the backend? With -ffast-math builtin_sinl becomes llvm.sin.f128 and the backend will emit a call to sinl if ISD::SIN isn't legal.

We're going to make IEEE f128 available in Clang on ppc64le. Newest glibc already supports 'redirection' from fmodl to fmodf128 (or, __fmodieee128) by checking some macros determined by current long-double semantics. For these LLVM intrinsics, Steven has a patch to fix the correct signature of libcall (D91675). Builtin in Clang will generate intrinsics under ffast-math but function call without the option. That may lead to an awkward situation: program is correct under fast-math, but wrong under no optimization. So such mutation is needed.

This patch looks reasonable to me for targets with more than one long-double format. Or if that's not a right way for the mutation, are there other places to implement that?

[craig.topper]

In D92080#2448094, @qiucf wrote:

In D92080#2443333, @craig.topper wrote:

I don't think I understand the whole picture here. Why would only builtins get mutated? Does a call to "modf" still call "modf"? But builtin_modf will call modf128? Is there a corresponding patch to the runtime libcalls table in the backend? With -ffast-math builtin_sinl becomes llvm.sin.f128 and the backend will emit a call to sinl if ISD::SIN isn't legal.

We're going to make IEEE f128 available in Clang on ppc64le. Newest glibc already supports 'redirection' from fmodl to fmodf128 (or, __fmodieee128) by checking some macros determined by current long-double semantics. For these LLVM intrinsics, Steven has a patch to fix the correct signature of libcall (D91675). Builtin in Clang will generate intrinsics under ffast-math but function call without the option. That may lead to an awkward situation: program is correct under fast-math, but wrong under no optimization. So such mutation is needed.

This patch looks reasonable to me for targets with more than one long-double format. Or if that's not a right way for the mutation, are there other places to implement that?

D91675 has PowerPC only changes to make the f128 calls get emitted. If you change the frontend in a target independent way as proposed here, won't that make the frontend and backend not match for targets like X86?

[qiucf]

• Diff based on pre-commit
• Restrict to PPC64

[qiucf]

In D92080#2449236, @craig.topper wrote:

D91675 has PowerPC only changes to make the f128 calls get emitted. If you change the frontend in a target independent way as proposed here, won't that make the frontend and backend not match for targets like X86?

Ah, yes. I should keep it as PPC64-only here, with TODO comments for it.

[qiucf]

Ping..

[RKSimon]

LGTM but a PPC-guru needs to signoff

[nemanjai]

LGTM.
I think it would be useful to run a functional test with a toolchain that has these library functions. That shouldn't gate this change though.

clang/lib/CodeGen/CGBuiltin.cpp

RValue CodeGenFunction::emitRotate(const CallExpr *E, bool IsRotateRight) {
   ShiftAmt = Builder.CreateIntCast(ShiftAmt, Ty, false);
 
   // Rotate is a special case of LLVM funnel shift - 1st 2 args are the same.
   unsigned IID = IsRotateRight ? Intrinsic::fshr : Intrinsic::fshl;
   Function *F = CGM.getIntrinsic(IID, Ty);
   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) {
   const FunctionDecl *FD = GD.getDecl()->getAsFunction();
   // See if we can constant fold this builtin.  If so, don't emit it at all.
   Expr::EvalResult Result;
   if (E->EvaluateAsRValue(Result, CGM.getContext()) &&
       !Result.hasSideEffects()) {
     if (Result.Val.isInt())
       return RValue::get(llvm::ConstantInt::get(getLLVMContext(),
                                                 Result.Val.getInt()));
     if (Result.Val.isFloat())
       return RValue::get(llvm::ConstantFP::get(getLLVMContext(),
                                                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
   // likely to get lowered to the renamed library functions.
   const unsigned BuiltinIDIfNoAsmLabel =
       FD->hasAttr<AsmLabelAttr>() ? 0 : BuiltinID;
 
   // There are LLVM math intrinsics/instructions corresponding to math library

clang/test/CodeGen/math-builtins-long.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -w -S -o - -emit-llvm %s \
 // RUN:   -fmath-errno | FileCheck %s -check-prefix=F80
 // RUN: %clang_cc1 -triple ppc64le-unknown-unknown -w -S -o - -emit-llvm %s \
 // RUN:   -fmath-errno | FileCheck %s -check-prefix=PPC
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -mlong-double-128 -w -S \
 // RUN:   -o - -emit-llvm %s -fmath-errno | FileCheck %s -check-prefix=X86F128
 // RUN: %clang_cc1 -triple ppc64le-unknown-unknown -mabi=ieeelongdouble -w -S \
 // RUN:   -o - -emit-llvm %s -fmath-errno | FileCheck %s -check-prefix=PPCF128
 
 void bar(long double);
 
 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 %{{.+}})
   // PPC: call ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @llvm.copysign.f128(fp128 %{{.+}}, fp128 %{{.+}})
   // PPCF128: call fp128 @llvm.copysign.f128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_copysignl(f,f);
 
   // F80: call x86_fp80 @llvm.fabs.f80(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @llvm.fabs.f128(fp128 %{{.+}})
   // PPCF128: call fp128 @llvm.fabs.f128(fp128 %{{.+}})
   __builtin_fabsl(f);
 
   // 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*
   // PPC: store ppc_fp128 0xM7FF00000000000000000000000000000, ppc_fp128*
   // X86F128: store fp128 0xL00000000000000007FFF000000000000, fp128*
   // PPCF128: store fp128 0xL00000000000000007FFF000000000000, fp128*
   *l = __builtin_huge_vall();
 
   // F80: store x86_fp80 0xK7FFF8000000000000000, x86_fp80*
   // PPC: store ppc_fp128 0xM7FF00000000000000000000000000000, ppc_fp128*
   // X86F128: store fp128 0xL00000000000000007FFF000000000000, fp128*
   // PPCF128: store fp128 0xL00000000000000007FFF000000000000, fp128*
   *l = __builtin_infl();
 
   // 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 %{{.+}})
   // PPC: call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @llvm.ceil.f128(fp128 %{{.+}})
   // PPCF128: call fp128 @llvm.ceil.f128(fp128 %{{.+}})
   __builtin_ceill(f);
 
   // 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 %{{.+}})
   // PPC: call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %{{.+}})
   // X86F128: call fp128 @llvm.floor.f128(fp128 %{{.+}})
   // PPCF128: call fp128 @llvm.floor.f128(fp128 %{{.+}})
   __builtin_floorl(f);
 
void foo(long double f, long double *l, int *i, const char *c) {
   // PPCF128: call fp128 @llvm.rint.f128(fp128 %{{.+}})
   __builtin_rintl(f);
 
   // F80: call x86_fp80 @llvm.round.f80(x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %{{.+}})
   // 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);
 }