[clang] [llvm] [llvm] Change `fp128` lowering to use `f128` functions by default (PR #76558)
Trevor Gross via cfe-commits
cfe-commits at lists.llvm.org
Thu Jul 2 05:42:56 PDT 2026
https://github.com/tgross35 updated https://github.com/llvm/llvm-project/pull/76558
>From dae1b696e9dc0f2de0226222a0fa6176a3e6fdcb Mon Sep 17 00:00:00 2001
From: Trevor Gross <tg at trevorgross.com>
Date: Thu, 2 Jul 2026 08:28:14 +0000
Subject: [PATCH] [IR] Change `fp128` lowering to use `f128` functions by
default
LLVM currently emits calls to `*l` (`long double`) libm symbols for
`fp128` intrinsics. This works on platforms where `long double` and
`_Float128` are the same type, but is incorrect on many platforms.
Change RuntimeLibcalls such that `*f128` libcalls are used by default,
which is always safe and correct but may not be available. On platforms
where it is likely that `sqrtf128` and similar are not available, keep
the current behavior of lowering to `*l` symbols if `long double` is
`binary128`.
The logic for whether f128 is `long double` is based on the platforms in
Clang that set `LongDoubleFormat` to `llvm::APFloat::IEEEquad`.
Fixes https://github.com/llvm/llvm-project/issues/44744
---
clang/lib/CodeGen/CodeGenModule.cpp | 11 +
llvm/include/llvm/ADT/APFloat.h | 1 +
llvm/include/llvm/CodeGen/TargetLowering.h | 3 +-
llvm/include/llvm/IR/RuntimeLibcalls.td | 187 ++++++++++-------
llvm/include/llvm/TargetParser/Triple.h | 20 +-
llvm/lib/Support/APFloat.cpp | 47 +++++
llvm/lib/TargetParser/Triple.cpp | 49 +++++
llvm/test/CodeGen/ARM/ldexp-fp128.ll | 8 +-
llvm/test/CodeGen/ARM/ldexp.ll | 2 +-
.../CodeGen/Generic/fp128-math-libcalls.ll | 14 +-
llvm/test/CodeGen/Hexagon/llvm.exp10.ll | 6 +-
llvm/test/CodeGen/Hexagon/llvm.sincos.ll | 30 +--
llvm/test/CodeGen/PowerPC/f128-arith.ll | 56 ++---
llvm/test/CodeGen/WebAssembly/llvm.sincos.ll | 120 +++++------
.../test/CodeGen/X86/fp128-libcalls-strict.ll | 192 +++++++++---------
llvm/test/CodeGen/X86/fp128-libcalls.ll | 126 ++++++------
16 files changed, 509 insertions(+), 363 deletions(-)
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 813cd67e4dd51..a7c6bc5836945 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -51,6 +51,7 @@
#include "clang/Lex/Preprocessor.h"
#include "llvm/ABI/IRTypeMapper.h"
#include "llvm/ABI/TargetInfo.h"
+#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
@@ -421,6 +422,16 @@ static void checkDataLayoutConsistency(const TargetInfo &Target,
Check("void*", llvm::PointerType::getUnqual(Context), Target.PointerAlign);
+ if (Triple.lowerF128LibmAsLongDouble() &&
+ &Target.getLongDoubleFormat() != &llvm::APFloat::IEEEquad()) {
+ const char *SemName =
+ llvm::APFloatBase::SemanticsName(Target.getLongDoubleFormat());
+ llvm::reportFatalInternalError(Twine("For target ") + Triple.str() +
+ "LLVM wants to use `long double` symbols for"
+ "_Float128 libm call lowering, but clang"
+ "specifies `long double` as " + SemName);
+ }
+
if (Target.vectorsAreElementAligned() != DL.vectorsAreElementAligned()) {
llvm::errs() << "Datalayout for target " << Triple.str()
<< " sets element-aligned vectors to '"
diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h
index 91bfc425a0ab0..c26ef52c7b933 100644
--- a/llvm/include/llvm/ADT/APFloat.h
+++ b/llvm/include/llvm/ADT/APFloat.h
@@ -263,6 +263,7 @@ class APFloatBase {
LLVM_ABI static const llvm::fltSemantics &EnumToSemantics(Semantics S);
LLVM_ABI static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem);
+ LLVM_ABI static const char *SemanticsName(const llvm::fltSemantics &Sem);
private:
LLVM_ABI static const fltSemantics semIEEEhalf;
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index 09f522742da4e..d63b2958143d2 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -3689,7 +3689,8 @@ class LLVM_ABI TargetLoweringBase {
return Libcalls.getLibcallImpl(Call);
}
- /// Get the libcall routine name for the specified libcall.
+ /// Get the libcall routine name for the specified libcall if implemented,
+ /// otherwise NULL.
// FIXME: This should be removed. Only LibcallImpl should have a name.
const char *getLibcallName(RTLIB::Libcall Call) const {
return Libcalls.getLibcallName(Call);
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index d5f38b9674cd7..0855488c5f2a0 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -63,6 +63,14 @@ def hasSinCos : RuntimeLibcallPredicate<"hasSinCos(TT)">;
// FIXME: Way to combine predicates
def hasSinCos_f32_f64 : RuntimeLibcallPredicate<"hasSinCos_f32_f64(TT)">;
+def lowerF128LibmAsLongDouble : RuntimeLibcallPredicate<
+ "TT.lowerF128LibmAsLongDouble()"
+>;
+
+def lowerF128LibmAsDefault : RuntimeLibcallPredicate<
+ "!TT.lowerF128LibmAsLongDouble()"
+>;
+
def ExceptionModelIsNotNone : RuntimeLibcallPredicate<
[{ExceptionModel != ExceptionHandling::None}]
>;
@@ -525,9 +533,9 @@ multiclass LibmLibcallImpls<string libcall_basename = !toupper(NAME),
def NAME#""
: RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_F64"),
!subst("<typesuffix>", "", rtbasename)>;
- def NAME#"l_f128"
+ def NAME#"f128"
: RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_F128"),
- !subst("<typesuffix>", "l", rtbasename)>;
+ !subst("<typesuffix>", "f128", rtbasename)>;
def NAME#"l_ppcf128"
: RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_PPCF128"),
!subst("<typesuffix>", "l", rtbasename)>;
@@ -536,6 +544,14 @@ multiclass LibmLibcallImpls<string libcall_basename = !toupper(NAME),
!subst("<typesuffix>", "l", rtbasename)>;
}
+// Replace `_F128` libcalls with `long double` versions.
+multiclass LibmF128AsLongDoubleImpls<string libcall_basename = !toupper(NAME),
+ string rtbasename = !strconcat(NAME, "X")> {
+ def NAME#"_ld128"
+ : RuntimeLibcallImpl<!cast<RuntimeLibcall>(libcall_basename#"_F128"),
+ !subst("X", "l", rtbasename)>;
+}
+
// AArch64 calls
def SC_MEMCPY : RuntimeLibcall;
def SC_MEMMOVE : RuntimeLibcall;
@@ -1708,60 +1724,68 @@ def __safestack_unsafe_stack_ptr : RuntimeLibcallImpl<SAFESTACK_UNSAFE_STACK_PTR
// F128 libm Runtime Libcalls
//===----------------------------------------------------------------------===//
-defset list<RuntimeLibcallImpl> LibmF128Libcalls = {
- def logf128 : RuntimeLibcallImpl<LOG_F128>;
- def log2f128 : RuntimeLibcallImpl<LOG2_F128>;
- def log10f128 : RuntimeLibcallImpl<LOG10_F128>;
- def expf128 : RuntimeLibcallImpl<EXP_F128>;
- def exp2f128 : RuntimeLibcallImpl<EXP2_F128>;
- def exp10f128 : RuntimeLibcallImpl<EXP10_F128>;
- def sinf128 : RuntimeLibcallImpl<SIN_F128>;
- def cosf128 : RuntimeLibcallImpl<COS_F128>;
- def tanf128 : RuntimeLibcallImpl<TAN_F128>;
- def tanhf128 : RuntimeLibcallImpl<TANH_F128>;
- def sincosf128 : RuntimeLibcallImpl<SINCOS_F128>;
- def powf128 : RuntimeLibcallImpl<POW_F128>;
- def fminf128 : RuntimeLibcallImpl<FMIN_F128>;
- def fmaxf128 : RuntimeLibcallImpl<FMAX_F128>;
- def fmodf128 : RuntimeLibcallImpl<REM_F128>;
- def sqrtf128 : RuntimeLibcallImpl<SQRT_F128>;
- def ceilf128 : RuntimeLibcallImpl<CEIL_F128>;
- def floorf128 : RuntimeLibcallImpl<FLOOR_F128>;
- def truncf128 : RuntimeLibcallImpl<TRUNC_F128>;
- def roundf128 : RuntimeLibcallImpl<ROUND_F128>;
- def lroundf128 : RuntimeLibcallImpl<LROUND_F128>;
- def llroundf128 : RuntimeLibcallImpl<LLROUND_F128>;
- def rintf128 : RuntimeLibcallImpl<RINT_F128>;
- def lrintf128 : RuntimeLibcallImpl<LRINT_F128>;
- def llrintf128 : RuntimeLibcallImpl<LLRINT_F128>;
- def nearbyintf128 : RuntimeLibcallImpl<NEARBYINT_F128>;
- def fmaf128 : RuntimeLibcallImpl<FMA_F128>;
- def frexpf128 : RuntimeLibcallImpl<FREXP_F128>;
- def cbrtf128 : RuntimeLibcallImpl<CBRT_F128>;
- def fminimumf128 : RuntimeLibcallImpl<FMINIMUM_F128>;
- def fmaximumf128 : RuntimeLibcallImpl<FMAXIMUM_F128>;
- def fminimum_numf128 : RuntimeLibcallImpl<FMINIMUM_NUM_F128>;
- def fmaximum_numf128 : RuntimeLibcallImpl<FMAXIMUM_NUM_F128>;
- def asinf128 : RuntimeLibcallImpl<ASIN_F128>;
- def acosf128 : RuntimeLibcallImpl<ACOS_F128>;
- def atanf128 : RuntimeLibcallImpl<ATAN_F128>;
- def atan2f128 : RuntimeLibcallImpl<ATAN2_F128>;
- def ldexpf128 : RuntimeLibcallImpl<LDEXP_F128>;
- def roundevenf128 : RuntimeLibcallImpl<ROUNDEVEN_F128>;
- def modff128 : RuntimeLibcallImpl<MODF_F128>;
- def sinhf128 : RuntimeLibcallImpl<SINH_F128>;
- def coshf128 : RuntimeLibcallImpl<COSH_F128>;
- def copysignf128 : RuntimeLibcallImpl<COPYSIGN_F128>;
+// f128 libcalls such as sqrt.f128 default to sqrtf128. Use this override list
+// to get sqrtl instead on platfroms where (1) long double is actually f128, and
+// (2) *f128 symbols don't exist, or there is a legacy reason to keep using
+// them.
+defset list<RuntimeLibcallImpl> LibmF128AsLongDoubleLibcalls = {
+ defm log : LibmF128AsLongDoubleImpls;
+ defm log2 : LibmF128AsLongDoubleImpls;
+ defm log10 : LibmF128AsLongDoubleImpls;
+ defm exp : LibmF128AsLongDoubleImpls;
+ defm exp2 : LibmF128AsLongDoubleImpls;
+ defm exp10 : LibmF128AsLongDoubleImpls;
+ defm sin : LibmF128AsLongDoubleImpls;
+ defm cos : LibmF128AsLongDoubleImpls;
+ defm tan : LibmF128AsLongDoubleImpls;
+ defm tanh : LibmF128AsLongDoubleImpls;
+ defm sincos : LibmF128AsLongDoubleImpls;
+ defm pow : LibmF128AsLongDoubleImpls;
+ defm fmin : LibmF128AsLongDoubleImpls;
+ defm fmax : LibmF128AsLongDoubleImpls;
+ defm fmod : LibmF128AsLongDoubleImpls<"REM">;
+ defm sqrt : LibmF128AsLongDoubleImpls;
+ defm ceil : LibmF128AsLongDoubleImpls;
+ defm floor : LibmF128AsLongDoubleImpls;
+ defm trunc : LibmF128AsLongDoubleImpls;
+ defm round : LibmF128AsLongDoubleImpls;
+ defm lround : LibmF128AsLongDoubleImpls;
+ defm llround : LibmF128AsLongDoubleImpls;
+ defm rint : LibmF128AsLongDoubleImpls;
+ defm lrint : LibmF128AsLongDoubleImpls;
+ defm llrint : LibmF128AsLongDoubleImpls;
+ defm nearbyint : LibmF128AsLongDoubleImpls;
+ defm fma : LibmF128AsLongDoubleImpls;
+ defm frexp : LibmF128AsLongDoubleImpls;
+ defm cbrt : LibmF128AsLongDoubleImpls;
+ defm fminimum : LibmF128AsLongDoubleImpls;
+ defm fmaximum : LibmF128AsLongDoubleImpls;
+ defm fminimum_num : LibmF128AsLongDoubleImpls;
+ defm fmaximum_num : LibmF128AsLongDoubleImpls;
+ defm asin : LibmF128AsLongDoubleImpls;
+ defm acos : LibmF128AsLongDoubleImpls;
+ defm atan : LibmF128AsLongDoubleImpls;
+ defm atan2 : LibmF128AsLongDoubleImpls;
+ defm ldexp : LibmF128AsLongDoubleImpls;
+ defm roundeven : LibmF128AsLongDoubleImpls;
+ defm modf : LibmF128AsLongDoubleImpls;
+ defm sinh : LibmF128AsLongDoubleImpls;
+ defm cosh : LibmF128AsLongDoubleImpls;
+ defm copysign : LibmF128AsLongDoubleImpls;
}
-defset list<RuntimeLibcallImpl> LibmF128FiniteLibcalls = {
- def __logf128_finite : RuntimeLibcallImpl<LOG_FINITE_F128>;
- def __log2f128_finite : RuntimeLibcallImpl<LOG2_FINITE_F128>;
- def __log10f128_finite : RuntimeLibcallImpl<LOG10_FINITE_F128>;
- def __expf128_finite : RuntimeLibcallImpl<EXP_FINITE_F128>;
- def __exp2f128_finite : RuntimeLibcallImpl<EXP2_FINITE_F128>;
- def __exp10f128_finite : RuntimeLibcallImpl<EXP10_FINITE_F128>;
- def __powf128_finite : RuntimeLibcallImpl<POW_FINITE_F128>;
+defset list<RuntimeLibcallImpl> LibmF128AsLongDoubleFiniteLibcalls = {
+ defm __log_finite : LibmF128AsLongDoubleImpls<"LOG_FINITE", "__logX_finite">;
+ defm __log2_finite
+ : LibmF128AsLongDoubleImpls<"LOG2_FINITE", "__log2X_finite">;
+ defm __log10_finite
+ : LibmF128AsLongDoubleImpls<"LOG10_FINITE", "__log10X_finite">;
+ defm __exp_finite : LibmF128AsLongDoubleImpls<"EXP_FINITE", "__expX_finite">;
+ defm __exp2_finite
+ : LibmF128AsLongDoubleImpls<"EXP2_FINITE", "__exp2X_finite">;
+ defm __exp10_finite
+ : LibmF128AsLongDoubleImpls<"EXP10_FINITE", "__exp10X_finite">;
+ defm __pow_finite : LibmF128AsLongDoubleImpls<"POW_FINITE", "__powX_finite">;
}
//--------------------------------------------------------------------
@@ -1802,15 +1826,18 @@ defvar AllDefaultRuntimeLibcallImpls
defvar DefaultRuntimeLibcallImpls_f80 =
!filter(entry, AllDefaultRuntimeLibcallImpls,
- !match(!cast<string>(entry.Provides), "F80"));
+ !match(!cast<string>(entry.Provides), "_F80$"));
defvar DefaultRuntimeLibcallImpls_ppcf128 =
!filter(entry, AllDefaultRuntimeLibcallImpls,
- !match(!cast<string>(entry.Provides), "PPCF128"));
+ !match(!cast<string>(entry.Provides), "_PPCF128$"));
defvar DefaultRuntimeLibcallImpls_f128 =
!filter(entry, AllDefaultRuntimeLibcallImpls,
- !match(!cast<string>(entry.Provides), "_F128"));
+ // `!contains` does not exist, `not->empty->filter` is a slightly hacky way
+ !not(!empty(
+ !filter(override, LibmF128AsLongDoubleLibcalls,
+ !eq(!cast<string>(override.Provides), !cast<string>(entry.Provides))))));
// FIXME: Ideally we would just use dags everywhere, but for the
// arm64ec case we need iterable lists so we can add the # prefix
@@ -1822,7 +1849,15 @@ defvar DefaultRuntimeLibcallImplsBaseList =
DefaultRuntimeLibcallImpls_ppcf128);
defvar DefaultRuntimeLibcallImpls =
- (add DefaultRuntimeLibcallImplsBaseList,
+ (add
+ // Not done as part of the above listremoves since f128 defaults should
+ // remain in the base list.
+ (sub DefaultRuntimeLibcallImplsBaseList,
+ DefaultRuntimeLibcallImpls_f128),
+ LibcallImpls<(add DefaultRuntimeLibcallImpls_f128),
+ lowerF128LibmAsDefault>,
+ LibcallImpls<(add LibmF128AsLongDoubleLibcalls),
+ lowerF128LibmAsLongDouble>,
ExceptionModelCalls);
/// Default set of libcall impls for 32-bit architectures.
@@ -1854,13 +1889,13 @@ defvar SecurityCheckCookieIfWinMSVC =
defvar LibmHasSinCosF32 = LibcallImpls<(add sincosf), hasSinCos>;
defvar LibmHasSinCosF64 = LibcallImpls<(add sincos), hasSinCos>;
defvar LibmHasSinCosF80 = LibcallImpls<(add sincosl_f80), hasSinCos>;
-defvar LibmHasSinCosF128 = LibcallImpls<(add sincosl_f128), hasSinCos>;
+defvar LibmHasSinCosF128 = LibcallImpls<(add sincosf128), hasSinCos>;
defvar LibmHasSinCosPPCF128 = LibcallImpls<(add sincosl_ppcf128), hasSinCos>;
defvar LibmHasExp10F32 = LibcallImpls<(add exp10f), hasExp10>;
defvar LibmHasExp10F64 = LibcallImpls<(add exp10), hasExp10>;
+defvar LibmHasExp10F128 = LibcallImpls<(add exp10f128), hasExp10>;
defvar LibmHasExp10F80 = LibcallImpls<(add exp10l_f80), hasExp10>;
-defvar LibmHasExp10F128 = LibcallImpls<(add exp10l_f128), hasExp10>;
defvar LibmHasExp10PPCF128 = LibcallImpls<(add exp10l_ppcf128), hasExp10>;
defvar DefaultLibmExp10 = [
@@ -1869,8 +1904,8 @@ defvar DefaultLibmExp10 = [
defvar WindowsMathRemovals = [
- ldexpf, ldexpl_f80, ldexpl_f128, ldexpl_ppcf128,
- frexpf, frexpl_f80, frexpl_f128, frexpl_ppcf128
+ ldexpf, ldexpl_f80, ldexpf128, ldexpl_ppcf128,
+ frexpf, frexpl_f80, frexpf128, frexpl_ppcf128
];
defvar MostPowI = !listremove(PowiLibcallImpls, [__powitf2_f128, __powitf2_ppc128]);
@@ -1891,8 +1926,8 @@ defvar LibmHasLdexpF32 = LibcallImpls<(add ldexpf), isNotOSWindowsOrIsCygwinMinG
defvar LibmHasFrexpF80 = LibcallImpls<(add frexpl_f80), isNotOSWindowsOrIsCygwinMinGW>;
defvar LibmHasLdexpF80 = LibcallImpls<(add ldexpl_f80), isNotOSWindowsOrIsCygwinMinGW>;
-defvar LibmHasFrexpF128 = LibcallImpls<(add frexpl_f128), isNotOSWindowsOrIsCygwinMinGW>;
-defvar LibmHasLdexpF128 = LibcallImpls<(add ldexpl_f128), isNotOSWindowsOrIsCygwinMinGW>;
+defvar LibmHasFrexpF128 = LibcallImpls<(add frexpf128), isNotOSWindowsOrIsCygwinMinGW>;
+defvar LibmHasLdexpF128 = LibcallImpls<(add ldexpf128), isNotOSWindowsOrIsCygwinMinGW>;
defvar has__stack_chk_fail = LibcallImpls<(add __stack_chk_fail), hasStackChkFail>;
defvar has__stack_chk_guard =
@@ -2643,7 +2678,7 @@ def HexagonSystemLibrary
__umoddi3, __divdf3, __muldf3, __divsi3, __subdf3, sqrtf,
__divdi3, __umodsi3, __moddi3, __modsi3), HexagonLibcalls,
LibmHasSinCosF32, LibmHasSinCosF64, LibmHasSinCosF128,
- exp10f, exp10, exp10l_f128, __stack_chk_fail, __stack_chk_guard,
+ exp10f, exp10, exp10f128, __stack_chk_fail, __stack_chk_guard,
DefaultSafeStackGlobals)>;
//===----------------------------------------------------------------------===//
@@ -2860,7 +2895,7 @@ defvar MSP430DefaultOptOut = [
def MSP430SystemLibrary
: SystemRuntimeLibrary<isMSP430,
(add (sub DefaultRuntimeLibcallImpls, MSP430DefaultOptOut),
- exp10f, exp10, exp10l_f128,
+ exp10f, exp10, exp10f128,
// Floating point conversions - EABI Table 6
__mspabi_cvtdf,
@@ -3050,12 +3085,11 @@ def AIX64Calls : LibcallImpls<(add PPC64AIXCallList), isPPC64_AIX>;
def PPCSystemLibrary
: SystemRuntimeLibrary<isPPC,
(add PPCRuntimeLibcalls,
- (sub DefaultRuntimeLibcallImpls, memcpy,
- DefaultRuntimeLibcallImpls_f128),
+ (sub DefaultRuntimeLibcallImpls, memcpy),
__extendkftf2, __trunctfkf2,
DefaultRuntimeLibcallImpls_ppcf128,
exp10f, exp10, exp10l_ppcf128,
- LibmF128Libcalls, AIX32Calls, AIX64Calls,
+ AIX32Calls, AIX64Calls,
LibmHasSinCosF32, LibmHasSinCosF64, LibmHasSinCosF128,
LibmHasSinCosPPCF128,
AvailableIf<memcpy, isNotAIX>,
@@ -3080,7 +3114,7 @@ def isRISCV64 : RuntimeLibcallPredicate<"TT.isRISCV64()">;
def RISCVSystemLibrary
: SystemRuntimeLibrary<isRISCV,
(add DefaultRuntimeLibcallImpls,
- exp10f, exp10, exp10l_f128,
+ exp10f, exp10, exp10f128,
__riscv_flush_icache,
LibcallImpls<(add Int128RTLibcalls), isRISCV64>,
DefaultStackProtector,
@@ -3215,9 +3249,6 @@ def darwinHas__bzero : RuntimeLibcallPredicate<"TT.isMacOSX() && !TT.isMacOSXVer
def hasExpFrexplLdexplF128
: RuntimeLibcallPredicate<[{(!TT.isOSWindows() || TT.isOSCygMing()) && !TT.isGNUEnvironment()}]>;
-// Use the f128 variants of math functions on x86
-defvar X86_F128_Libcalls = LibcallImpls<(add LibmF128Libcalls, LibmF128FiniteLibcalls), isGNUEnvironment>;
-
defvar SinCosF32F64Libcalls = LibcallImpls<(add sincosf, sincos), hasSinCos_f32_f64>;
defvar MemChkLibcalls = [__memcpy_chk, __memset_chk, __memmove_chk];
@@ -3225,13 +3256,12 @@ defvar MemChkLibcalls = [__memcpy_chk, __memset_chk, __memmove_chk];
defvar X86CommonLibcalls =
(add (sub WinDefaultLibcallImpls, WindowsDivRemMulLibcallOverrides, MemChkLibcalls),
DarwinSinCosStret, DarwinExp10, DarwinMemsetPattern, MacOSUnlockedIO,
- X86_F128_Libcalls,
LibmHasSinCosF80, // FIXME: Depends on long double
SinCosF32F64Libcalls,
LibcallImpls<(add __bzero), darwinHas__bzero>,
LibmHasFrexpF32, LibmHasLdexpF32,
LibmHasFrexpF80, LibmHasLdexpF80,
- LibcallImpls<(add frexpl_f128, ldexpl_f128, exp10l_f128), hasExpFrexplLdexplF128>,
+ LibcallImpls<(add frexpf128, ldexpf128, exp10f128), hasExpFrexplLdexplF128>,
DefaultRuntimeLibcallImpls_f80,
LibmHasExp10F32, LibmHasExp10F64, LibmHasExp10F80,
LibcallImpls<(add MostPowI), isNotOSMSVCRT>,
@@ -3277,10 +3307,9 @@ def isXCore : RuntimeLibcallPredicate<"TT.getArch() == Triple::xcore">;
def XCoreSystemLibrary
: SystemRuntimeLibrary<isXCore,
(add DefaultRuntimeLibcallImpls,
- exp10f, exp10, exp10l_f128,
+ exp10f, exp10, exp10f128,
__memcpy_4,
- iprintf, siprintf, fiprintf,
- LibcallImpls<(add LibmF128Libcalls, LibmF128FiniteLibcalls), isGNUEnvironment>
+ iprintf, siprintf, fiprintf
)>;
//===----------------------------------------------------------------------===//
@@ -3424,7 +3453,7 @@ def LegacyDefaultSystemLibrary
: SystemRuntimeLibrary<isDefaultLibcallArch,
(add DefaultRuntimeLibcallImpls,
LibmHasSinCosF32, LibmHasSinCosF64, LibmHasSinCosF128,
- exp10f, exp10, exp10l_f128,
+ exp10f, exp10, exp10f128,
__powisf2, __powidf2, __powitf2_f128,
LibcallImpls<(add Int128RTLibcalls), isArch64Bit>,
DefaultStackProtector, DefaultSafeStackGlobals
diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h
index 4cf54022c5c32..8beaa428776a6 100644
--- a/llvm/include/llvm/TargetParser/Triple.h
+++ b/llvm/include/llvm/TargetParser/Triple.h
@@ -284,14 +284,14 @@ class Triple {
EABIHF,
Android,
Musl,
- MuslABIN32,
- MuslABI64,
- MuslEABI,
- MuslEABIHF,
- MuslF32,
- MuslSF,
- MuslX32,
- MuslWALI,
+ MuslABIN32, ///< Musl MIPS32 with the N32 ABI
+ MuslABI64, ///< Musl MIPS32 with the N64 ABI
+ MuslEABI, ///< Musl Arm32 EABI
+ MuslEABIHF, ///< Musl Arm32 EABI + HF
+ MuslF32, ///< Musl LoongArch ILP32F/LP64F
+ MuslSF, ///< Musl LoongArch ILP32S/LP64S
+ MuslX32, ///< Musl using 32-bit ABI on x86_64
+ MuslWALI, ///< Musl on wasm-wali targets
LLVM,
MSVC,
@@ -1293,6 +1293,10 @@ class Triple {
/// or an invalid version tuple if this triple doesn't have one.
LLVM_ABI VersionTuple getMinimumSupportedOSVersion() const;
+ /// Return true if `_Float128` libcalls should lower to e.g. `sqrtf` (`long
+ /// double`) rather than the default `sqrtf128`.
+ bool lowerF128LibmAsLongDouble() const;
+
/// @}
/// @name Static helpers for IDs.
/// @{
diff --git a/llvm/lib/Support/APFloat.cpp b/llvm/lib/Support/APFloat.cpp
index 0e95e2172f9bc..a673bcbd9e5f0 100644
--- a/llvm/lib/Support/APFloat.cpp
+++ b/llvm/lib/Support/APFloat.cpp
@@ -202,6 +202,53 @@ APFloatBase::SemanticsToEnum(const llvm::fltSemantics &Sem) {
llvm_unreachable("Unknown floating semantics");
}
+const char *APFloatBase::SemanticsName(const llvm::fltSemantics &Sem) {
+ switch (APFloatBase::SemanticsToEnum(Sem)) {
+ case S_IEEEhalf:
+ return "IEEEhalf";
+ case S_BFloat:
+ return "BFloat";
+ case S_IEEEsingle:
+ return "IEEEsingle";
+ case S_IEEEdouble:
+ return "IEEEdouble";
+ case S_IEEEquad:
+ return "IEEEquad";
+ case S_PPCDoubleDouble:
+ return "PPCDoubleDouble";
+ case S_PPCDoubleDoubleLegacy:
+ return "PPCDoubleDoubleLegacy";
+ case S_Float8E5M2:
+ return "Float8E5M2";
+ case S_Float8E5M2FNUZ:
+ return "Float8E5M2FNUZ";
+ case S_Float8E4M3:
+ return "Float8E4M3";
+ case S_Float8E4M3FN:
+ return "Float8E4M3FN";
+ case S_Float8E4M3FNUZ:
+ return "Float8E4M3FNUZ";
+ case S_Float8E4M3B11FNUZ:
+ return "Float8E4M3B11FNUZ";
+ case S_Float8E3M4:
+ return "Float8E3M4";
+ case S_FloatTF32:
+ return "FloatTF32";
+ case S_Float8E8M0FNU:
+ return "Float8E8M0FNU";
+ case S_Float6E3M2FN:
+ return "Float6E3M2FN";
+ case S_Float6E2M3FN:
+ return "Float6E2M3FN";
+ case S_Float4E2M1FN:
+ return "Float4E2M1FN";
+ case S_x87DoubleExtended:
+ return "x87DoubleExtended";
+ default:
+ llvm_unreachable("Unknown floating semantics");
+ }
+}
+
bool APFloatBase::isRepresentableBy(const fltSemantics &A,
const fltSemantics &B) {
return A.maxExponent <= B.maxExponent && A.minExponent >= B.minExponent &&
diff --git a/llvm/lib/TargetParser/Triple.cpp b/llvm/lib/TargetParser/Triple.cpp
index 603227e891d4b..d8e7b751dca6e 100644
--- a/llvm/lib/TargetParser/Triple.cpp
+++ b/llvm/lib/TargetParser/Triple.cpp
@@ -2753,6 +2753,55 @@ ExceptionHandling Triple::getDefaultExceptionHandling() const {
return ExceptionHandling::None;
}
+bool Triple::lowerF128LibmAsLongDouble() const {
+ bool Print = true;
+ // bool Print = getenv("PRINTME") != NULL;
+ // Note that the logic should be kept in sync with Clang's LongDoubleFormat,
+ // though defaulting to *f128 is always safe if available.
+
+ if (Print) fprintf(stderr, "CHECK 1\n");
+ // Windows and Apple always use f64 as `long double`.
+ if (isOSWindows() || isOSDarwin())
+ return false;
+
+ if (Print) fprintf(stderr, "CHECK 2\n");
+ // Android and Ohos use binary128 only on x86-64.
+ if (isAndroid() || isOHOSFamily()) {
+ if (isX86_64())
+ return true;
+ return false;
+ }
+
+ if (Print) fprintf(stderr, "CHECK 3\n");
+ // PowerPC `long double` is roughly:
+ // - f64 on musl
+ // - ibm128 most of the time, historically
+ // - f128 on Linux distros more recently if VSX is in the baseline (i.e.
+ // 64-bit LE only).
+ // Make the safe assumption that *f128 should be used.
+ if (isPPC())
+ return false;
+
+ if (Print) fprintf(stderr, "CHECK 4\n");
+ // Most 64-bit architectures use use binary128, a few are binary128 on both
+ // 64- and 32-bit.
+ if (isAArch64() || isLoongArch() || isRISCV() || isSPARC64() || isSystemZ() ||
+ isVE() || isWasm())
+ return true;
+
+ if (Print) fprintf(stderr, "CHECK 5\n");
+ // MIPS64 is usually f128, except on FreeBSD-like operating systems. MIPS32
+ // is f128 only with the N32 ABI (O32 is `f64`).
+ if ((isMIPS64() || isABIN32()) &&
+ !(isOSFreeBSD() || isOSKFreeBSD() || isOSDragonFly()))
+ return true;
+
+ if (Print) fprintf(stderr, "CHECK 6\n");
+ // By default, make the safe assumption that `long double !== f128`. This
+ // also catches x86 (`long double` is x87 `f80`)
+ return false;
+}
+
// HLSL triple environment orders are relied on in the front end
static_assert(Triple::Vertex - Triple::Pixel == 1,
"incorrect HLSL stage order");
diff --git a/llvm/test/CodeGen/ARM/ldexp-fp128.ll b/llvm/test/CodeGen/ARM/ldexp-fp128.ll
index 93fcd39e824fb..b6c58654f4e19 100644
--- a/llvm/test/CodeGen/ARM/ldexp-fp128.ll
+++ b/llvm/test/CodeGen/ARM/ldexp-fp128.ll
@@ -8,7 +8,7 @@ define fp128 @testExpl(fp128 %val, i32 %a) {
; LINUX-NEXT: sub sp, sp, #8
; LINUX-NEXT: ldr r12, [sp, #16]
; LINUX-NEXT: str r12, [sp]
-; LINUX-NEXT: bl ldexpl
+; LINUX-NEXT: bl ldexpf128
; LINUX-NEXT: add sp, sp, #8
; LINUX-NEXT: pop {r11, pc}
%call = tail call fp128 @ldexpl(fp128 %val, i32 %a)
@@ -24,7 +24,7 @@ define fp128 @test_ldexp_f128_i32(fp128 %val, i32 %a) {
; LINUX-NEXT: sub sp, sp, #8
; LINUX-NEXT: ldr r12, [sp, #16]
; LINUX-NEXT: str r12, [sp]
-; LINUX-NEXT: bl ldexpl
+; LINUX-NEXT: bl ldexpf128
; LINUX-NEXT: add sp, sp, #8
; LINUX-NEXT: pop {r11, pc}
%call = tail call fp128 @llvm.ldexp.f128.i32(fp128 %val, i32 %a)
@@ -44,7 +44,7 @@ define <2 x fp128> @test_ldexp_v2f128_v2i32(<2 x fp128> %val, <2 x i32> %a) {
; LINUX-NEXT: ldm r3, {r0, r1, r2, r3}
; LINUX-NEXT: vldr d8, [sp, #56]
; LINUX-NEXT: vst1.32 {d8[1]}, [sp:32]
-; LINUX-NEXT: bl ldexpl
+; LINUX-NEXT: bl ldexpf128
; LINUX-NEXT: ldr r12, [sp, #32]
; LINUX-NEXT: vst1.32 {d8[0]}, [sp:32]
; LINUX-NEXT: ldr lr, [sp, #36]
@@ -56,7 +56,7 @@ define <2 x fp128> @test_ldexp_v2f128_v2i32(<2 x fp128> %val, <2 x i32> %a) {
; LINUX-NEXT: mov r2, r12
; LINUX-NEXT: str r3, [r4, #28]
; LINUX-NEXT: mov r3, lr
-; LINUX-NEXT: bl ldexpl
+; LINUX-NEXT: bl ldexpf128
; LINUX-NEXT: stm r4, {r0, r1, r2, r3}
; LINUX-NEXT: add sp, sp, #8
; LINUX-NEXT: vpop {d8}
diff --git a/llvm/test/CodeGen/ARM/ldexp.ll b/llvm/test/CodeGen/ARM/ldexp.ll
index cdf91eb902e05..2661a1e270798 100644
--- a/llvm/test/CodeGen/ARM/ldexp.ll
+++ b/llvm/test/CodeGen/ARM/ldexp.ll
@@ -38,7 +38,7 @@ entry:
declare float @ldexpf(float, i32) memory(none)
define fp128 @testExpl(fp128 %val, i32 %a) {
-; LINUX: bl ldexpl
+; LINUX: bl ldexpf128
; WINDOWS: b.w ldexpl
entry:
%call = tail call fp128 @ldexpl(fp128 %val, i32 %a)
diff --git a/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll b/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
index f759c94621381..b2efeebb38dcf 100644
--- a/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
+++ b/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
@@ -11,25 +11,21 @@
; * musl (no f128 symbols available)
; * Windows and MacOS (no f128 symbols, long double == f64)
-; FIXME(#44744): arm32, x86-{32,64} musl targets, MacOS, and Windows don't have
-; f128 long double. They should be passing with CHECK-F128 rather than
-; CHECK-USELD.
-
; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=aarch64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=aarch64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=aarch64-unknown-none | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
-; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=arm64-apple-macosx | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
-; RUN: %if arm-registered-target %{ llc < %s -mtriple=arm-none-eabi | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
-; RUN: %if arm-registered-target %{ llc < %s -mtriple=arm-unknown-linux-gnueabi | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
+; RUN: %if aarch64-registered-target %{ llc < %s -mtriple=arm64-apple-macosx | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
+; RUN: %if arm-registered-target %{ llc < %s -mtriple=arm-none-eabi | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
+; RUN: %if arm-registered-target %{ llc < %s -mtriple=arm-unknown-linux-gnueabi | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if powerpc-registered-target %{ llc < %s -mtriple=powerpc-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if powerpc-registered-target %{ llc < %s -mtriple=powerpc64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if powerpc-registered-target %{ llc < %s -mtriple=powerpc64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if riscv-registered-target %{ llc < %s -mtriple=riscv32-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
; RUN: %if systemz-registered-target %{ llc < %s -mtriple=s390x-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-S390X %}
; RUN: %if x86-registered-target %{ llc < %s -mtriple=i686-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
-; RUN: %if x86-registered-target %{ llc < %s -mtriple=i686-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
+; RUN: %if x86-registered-target %{ llc < %s -mtriple=i686-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
; RUN: %if x86-registered-target %{ llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
-; RUN: %if x86-registered-target %{ llc < %s -mtriple=x86_64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-USELD %}
+; RUN: %if x86-registered-target %{ llc < %s -mtriple=x86_64-unknown-linux-musl | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
;
; FIXME(#144006): Windows-MSVC should also be run but has a ldexp selection
; failure.
diff --git a/llvm/test/CodeGen/Hexagon/llvm.exp10.ll b/llvm/test/CodeGen/Hexagon/llvm.exp10.ll
index cd94d328f1fee..4de4e3bc822c9 100644
--- a/llvm/test/CodeGen/Hexagon/llvm.exp10.ll
+++ b/llvm/test/CodeGen/Hexagon/llvm.exp10.ll
@@ -150,7 +150,7 @@ define fp128 @exp10_f128(fp128 %x) #0 {
; CHECK-NEXT: allocframe(#24)
; CHECK-NEXT: } // 8-byte Folded Spill
; CHECK-NEXT: {
-; CHECK-NEXT: call exp10l
+; CHECK-NEXT: call exp10f128
; CHECK-NEXT: r0 = add(r29,#0)
; CHECK-NEXT: }
; CHECK-NEXT: {
@@ -183,12 +183,12 @@ define <2 x fp128> @exp10_v2f128(<2 x fp128> %x) #0 {
; CHECK-NEXT: memd(r29+#32) = r21:20
; CHECK-NEXT: } // 8-byte Folded Spill
; CHECK-NEXT: {
-; CHECK-NEXT: call exp10l
+; CHECK-NEXT: call exp10f128
; CHECK-NEXT: r19:18 = memd(r29+#64)
; CHECK-NEXT: r21:20 = memd(r29+#72)
; CHECK-NEXT: }
; CHECK-NEXT: {
-; CHECK-NEXT: call exp10l
+; CHECK-NEXT: call exp10f128
; CHECK-NEXT: r0 = add(r29,#0)
; CHECK-NEXT: r3:2 = combine(r19,r18)
; CHECK-NEXT: r5:4 = combine(r21,r20)
diff --git a/llvm/test/CodeGen/Hexagon/llvm.sincos.ll b/llvm/test/CodeGen/Hexagon/llvm.sincos.ll
index f02ac2ca8480f..095c53cce003a 100644
--- a/llvm/test/CodeGen/Hexagon/llvm.sincos.ll
+++ b/llvm/test/CodeGen/Hexagon/llvm.sincos.ll
@@ -1108,11 +1108,11 @@ define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
; BASE-NEXT: memd(r29+#40) = r19:18
; BASE-NEXT: } // 8-byte Folded Spill
; BASE-NEXT: {
-; BASE-NEXT: call sinl
+; BASE-NEXT: call sinf128
; BASE-NEXT: r19:18 = combine(r3,r2)
; BASE-NEXT: }
; BASE-NEXT: {
-; BASE-NEXT: call cosl
+; BASE-NEXT: call cosf128
; BASE-NEXT: r0 = add(r29,#16)
; BASE-NEXT: r3:2 = combine(r19,r18)
; BASE-NEXT: r5:4 = combine(r17,r16)
@@ -1156,7 +1156,7 @@ define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
; GNU-NEXT: memw(r29+#4) = r7.new
; GNU-NEXT: }
; GNU-NEXT: {
-; GNU-NEXT: call sincosl
+; GNU-NEXT: call sincosf128
; GNU-NEXT: memw(r29+#0) = r6
; GNU-NEXT: }
; GNU-NEXT: {
@@ -1194,11 +1194,11 @@ define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
; MUSL-NEXT: memd(r29+#40) = r19:18
; MUSL-NEXT: } // 8-byte Folded Spill
; MUSL-NEXT: {
-; MUSL-NEXT: call sinl
+; MUSL-NEXT: call sinf128
; MUSL-NEXT: r19:18 = combine(r3,r2)
; MUSL-NEXT: }
; MUSL-NEXT: {
-; MUSL-NEXT: call cosl
+; MUSL-NEXT: call cosf128
; MUSL-NEXT: r0 = add(r29,#16)
; MUSL-NEXT: r3:2 = combine(r19,r18)
; MUSL-NEXT: r5:4 = combine(r17,r16)
@@ -1251,24 +1251,24 @@ define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
; BASE-NEXT: memd(r29+#64) = r25:24
; BASE-NEXT: } // 8-byte Folded Spill
; BASE-NEXT: {
-; BASE-NEXT: call sinl
+; BASE-NEXT: call sinf128
; BASE-NEXT: r23:22 = memd(r29+#112)
; BASE-NEXT: r25:24 = memd(r29+#120)
; BASE-NEXT: }
; BASE-NEXT: {
-; BASE-NEXT: call sinl
+; BASE-NEXT: call sinf128
; BASE-NEXT: r0 = add(r29,#0)
; BASE-NEXT: r3:2 = combine(r23,r22)
; BASE-NEXT: r5:4 = combine(r25,r24)
; BASE-NEXT: }
; BASE-NEXT: {
-; BASE-NEXT: call cosl
+; BASE-NEXT: call cosf128
; BASE-NEXT: r0 = add(r29,#48)
; BASE-NEXT: r3:2 = combine(r19,r18)
; BASE-NEXT: r5:4 = combine(r17,r16)
; BASE-NEXT: }
; BASE-NEXT: {
-; BASE-NEXT: call cosl
+; BASE-NEXT: call cosf128
; BASE-NEXT: r0 = add(r29,#16)
; BASE-NEXT: r3:2 = combine(r23,r22)
; BASE-NEXT: r5:4 = combine(r25,r24)
@@ -1338,7 +1338,7 @@ define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
; GNU-NEXT: memw(r17+#0) = r6.new
; GNU-NEXT: }
; GNU-NEXT: {
-; GNU-NEXT: call sincosl
+; GNU-NEXT: call sincosf128
; GNU-NEXT: r21:20 = memd(r29+#144)
; GNU-NEXT: memw(r17+#4) = r1
; GNU-NEXT: }
@@ -1349,7 +1349,7 @@ define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
; GNU-NEXT: memw(r17+#4) = r0.new
; GNU-NEXT: }
; GNU-NEXT: {
-; GNU-NEXT: call sincosl
+; GNU-NEXT: call sincosf128
; GNU-NEXT: r0 = add(r29,#40)
; GNU-NEXT: r1 = add(r29,#8)
; GNU-NEXT: memw(r17+#0) = r1.new
@@ -1414,24 +1414,24 @@ define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
; MUSL-NEXT: memd(r29+#64) = r25:24
; MUSL-NEXT: } // 8-byte Folded Spill
; MUSL-NEXT: {
-; MUSL-NEXT: call sinl
+; MUSL-NEXT: call sinf128
; MUSL-NEXT: r23:22 = memd(r29+#112)
; MUSL-NEXT: r25:24 = memd(r29+#120)
; MUSL-NEXT: }
; MUSL-NEXT: {
-; MUSL-NEXT: call sinl
+; MUSL-NEXT: call sinf128
; MUSL-NEXT: r0 = add(r29,#0)
; MUSL-NEXT: r3:2 = combine(r23,r22)
; MUSL-NEXT: r5:4 = combine(r25,r24)
; MUSL-NEXT: }
; MUSL-NEXT: {
-; MUSL-NEXT: call cosl
+; MUSL-NEXT: call cosf128
; MUSL-NEXT: r0 = add(r29,#48)
; MUSL-NEXT: r3:2 = combine(r19,r18)
; MUSL-NEXT: r5:4 = combine(r17,r16)
; MUSL-NEXT: }
; MUSL-NEXT: {
-; MUSL-NEXT: call cosl
+; MUSL-NEXT: call cosf128
; MUSL-NEXT: r0 = add(r29,#16)
; MUSL-NEXT: r3:2 = combine(r23,r22)
; MUSL-NEXT: r5:4 = combine(r25,r24)
diff --git a/llvm/test/CodeGen/PowerPC/f128-arith.ll b/llvm/test/CodeGen/PowerPC/f128-arith.ll
index f9c953d483ff2..4eb66fd04a945 100644
--- a/llvm/test/CodeGen/PowerPC/f128-arith.ll
+++ b/llvm/test/CodeGen/PowerPC/f128-arith.ll
@@ -425,14 +425,19 @@ define fp128 @qp_sincos(ptr nocapture readonly %a) nounwind {
; CHECK-NEXT: mflr r0
; CHECK-NEXT: stdu r1, -64(r1)
; CHECK-NEXT: std r0, 80(r1)
-; CHECK-NEXT: addi r5, r1, 48
-; CHECK-NEXT: addi r6, r1, 32
-; CHECK-NEXT: lxv v2, 0(r3)
-; CHECK-NEXT: bl sincosf128
+; CHECK-NEXT: stxv v31, 48(r1) # 16-byte Folded Spill
+; CHECK-NEXT: stxv v30, 32(r1) # 16-byte Folded Spill
+; CHECK-NEXT: lxv v31, 0(r3)
+; CHECK-NEXT: vmr v2, v31
+; CHECK-NEXT: bl cosf128
; CHECK-NEXT: nop
-; CHECK-NEXT: lxv v2, 48(r1)
-; CHECK-NEXT: lxv v3, 32(r1)
-; CHECK-NEXT: xsmulqp v2, v3, v2
+; CHECK-NEXT: vmr v30, v2
+; CHECK-NEXT: vmr v2, v31
+; CHECK-NEXT: bl sinf128
+; CHECK-NEXT: nop
+; CHECK-NEXT: xsmulqp v2, v30, v2
+; CHECK-NEXT: lxv v31, 48(r1) # 16-byte Folded Reload
+; CHECK-NEXT: lxv v30, 32(r1) # 16-byte Folded Reload
; CHECK-NEXT: addi r1, r1, 64
; CHECK-NEXT: ld r0, 16(r1)
; CHECK-NEXT: mtlr r0
@@ -441,28 +446,31 @@ define fp128 @qp_sincos(ptr nocapture readonly %a) nounwind {
; CHECK-P8-LABEL: qp_sincos:
; CHECK-P8: # %bb.0: # %entry
; CHECK-P8-NEXT: mflr r0
-; CHECK-P8-NEXT: std r29, -24(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: std r30, -16(r1) # 8-byte Folded Spill
-; CHECK-P8-NEXT: stdu r1, -96(r1)
-; CHECK-P8-NEXT: std r0, 112(r1)
-; CHECK-P8-NEXT: addi r30, r1, 48
-; CHECK-P8-NEXT: addi r29, r1, 32
+; CHECK-P8-NEXT: stdu r1, -80(r1)
+; CHECK-P8-NEXT: std r0, 96(r1)
+; CHECK-P8-NEXT: li r4, 48
; CHECK-P8-NEXT: lxvd2x vs0, 0, r3
-; CHECK-P8-NEXT: mr r5, r30
-; CHECK-P8-NEXT: mr r6, r29
-; CHECK-P8-NEXT: xxswapd v2, vs0
-; CHECK-P8-NEXT: bl sincosf128
+; CHECK-P8-NEXT: stxvd2x v30, r1, r4 # 16-byte Folded Spill
+; CHECK-P8-NEXT: li r4, 64
+; CHECK-P8-NEXT: stxvd2x v31, r1, r4 # 16-byte Folded Spill
+; CHECK-P8-NEXT: xxswapd v31, vs0
+; CHECK-P8-NEXT: vmr v2, v31
+; CHECK-P8-NEXT: bl cosf128
; CHECK-P8-NEXT: nop
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r29
-; CHECK-P8-NEXT: xxswapd v2, vs0
-; CHECK-P8-NEXT: lxvd2x vs0, 0, r30
-; CHECK-P8-NEXT: xxswapd v3, vs0
+; CHECK-P8-NEXT: vmr v30, v2
+; CHECK-P8-NEXT: vmr v2, v31
+; CHECK-P8-NEXT: bl sinf128
+; CHECK-P8-NEXT: nop
+; CHECK-P8-NEXT: vmr v3, v2
+; CHECK-P8-NEXT: vmr v2, v30
; CHECK-P8-NEXT: bl __mulkf3
; CHECK-P8-NEXT: nop
-; CHECK-P8-NEXT: addi r1, r1, 96
+; CHECK-P8-NEXT: li r3, 64
+; CHECK-P8-NEXT: lxvd2x v31, r1, r3 # 16-byte Folded Reload
+; CHECK-P8-NEXT: li r3, 48
+; CHECK-P8-NEXT: lxvd2x v30, r1, r3 # 16-byte Folded Reload
+; CHECK-P8-NEXT: addi r1, r1, 80
; CHECK-P8-NEXT: ld r0, 16(r1)
-; CHECK-P8-NEXT: ld r30, -16(r1) # 8-byte Folded Reload
-; CHECK-P8-NEXT: ld r29, -24(r1) # 8-byte Folded Reload
; CHECK-P8-NEXT: mtlr r0
; CHECK-P8-NEXT: blr
entry:
diff --git a/llvm/test/CodeGen/WebAssembly/llvm.sincos.ll b/llvm/test/CodeGen/WebAssembly/llvm.sincos.ll
index 0608a60b739f8..266f7af16e6ef 100644
--- a/llvm/test/CodeGen/WebAssembly/llvm.sincos.ll
+++ b/llvm/test/CodeGen/WebAssembly/llvm.sincos.ll
@@ -382,38 +382,38 @@ define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
; WASM32-NEXT: .local i32
; WASM32-NEXT: # %bb.0:
; WASM32-NEXT: global.get __stack_pointer
-; WASM32-NEXT: i32.const 32
+; WASM32-NEXT: i32.const 48
; WASM32-NEXT: i32.sub
; WASM32-NEXT: local.tee 3
; WASM32-NEXT: global.set __stack_pointer
; WASM32-NEXT: local.get 3
; WASM32-NEXT: local.get 1
; WASM32-NEXT: local.get 2
-; WASM32-NEXT: call cosl
+; WASM32-NEXT: local.get 3
+; WASM32-NEXT: i32.const 32
+; WASM32-NEXT: i32.add
; WASM32-NEXT: local.get 3
; WASM32-NEXT: i32.const 16
; WASM32-NEXT: i32.add
-; WASM32-NEXT: local.get 1
-; WASM32-NEXT: local.get 2
-; WASM32-NEXT: call sinl
+; WASM32-NEXT: call sincosl
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 3
-; WASM32-NEXT: i64.load 8
+; WASM32-NEXT: i64.load 24
; WASM32-NEXT: i64.store 24
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 3
-; WASM32-NEXT: i64.load 0
+; WASM32-NEXT: i64.load 16
; WASM32-NEXT: i64.store 16
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 3
-; WASM32-NEXT: i64.load 24
+; WASM32-NEXT: i64.load 40
; WASM32-NEXT: i64.store 8
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 3
-; WASM32-NEXT: i64.load 16
+; WASM32-NEXT: i64.load 32
; WASM32-NEXT: i64.store 0
; WASM32-NEXT: local.get 3
-; WASM32-NEXT: i32.const 32
+; WASM32-NEXT: i32.const 48
; WASM32-NEXT: i32.add
; WASM32-NEXT: global.set __stack_pointer
; WASM32-NEXT: # fallthrough-return
@@ -423,38 +423,38 @@ define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
; WASM64-NEXT: .local i64
; WASM64-NEXT: # %bb.0:
; WASM64-NEXT: global.get __stack_pointer
-; WASM64-NEXT: i64.const 32
+; WASM64-NEXT: i64.const 48
; WASM64-NEXT: i64.sub
; WASM64-NEXT: local.tee 3
; WASM64-NEXT: global.set __stack_pointer
; WASM64-NEXT: local.get 3
; WASM64-NEXT: local.get 1
; WASM64-NEXT: local.get 2
-; WASM64-NEXT: call cosl
+; WASM64-NEXT: local.get 3
+; WASM64-NEXT: i64.const 32
+; WASM64-NEXT: i64.add
; WASM64-NEXT: local.get 3
; WASM64-NEXT: i64.const 16
; WASM64-NEXT: i64.add
-; WASM64-NEXT: local.get 1
-; WASM64-NEXT: local.get 2
-; WASM64-NEXT: call sinl
+; WASM64-NEXT: call sincosl
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 3
-; WASM64-NEXT: i64.load 8
+; WASM64-NEXT: i64.load 24
; WASM64-NEXT: i64.store 24
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 3
-; WASM64-NEXT: i64.load 0
+; WASM64-NEXT: i64.load 16
; WASM64-NEXT: i64.store 16
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 3
-; WASM64-NEXT: i64.load 24
+; WASM64-NEXT: i64.load 40
; WASM64-NEXT: i64.store 8
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 3
-; WASM64-NEXT: i64.load 16
+; WASM64-NEXT: i64.load 32
; WASM64-NEXT: i64.store 0
; WASM64-NEXT: local.get 3
-; WASM64-NEXT: i64.const 32
+; WASM64-NEXT: i64.const 48
; WASM64-NEXT: i64.add
; WASM64-NEXT: global.set __stack_pointer
; WASM64-NEXT: # fallthrough-return
@@ -468,66 +468,66 @@ define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
; WASM32-NEXT: .local i32
; WASM32-NEXT: # %bb.0:
; WASM32-NEXT: global.get __stack_pointer
-; WASM32-NEXT: i32.const 64
+; WASM32-NEXT: i32.const 96
; WASM32-NEXT: i32.sub
; WASM32-NEXT: local.tee 5
; WASM32-NEXT: global.set __stack_pointer
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i32.const 32
+; WASM32-NEXT: i32.const 48
; WASM32-NEXT: i32.add
; WASM32-NEXT: local.get 3
; WASM32-NEXT: local.get 4
-; WASM32-NEXT: call cosl
+; WASM32-NEXT: local.get 5
+; WASM32-NEXT: i32.const 80
+; WASM32-NEXT: i32.add
+; WASM32-NEXT: local.get 5
+; WASM32-NEXT: i32.const 64
+; WASM32-NEXT: i32.add
+; WASM32-NEXT: call sincosl
; WASM32-NEXT: local.get 5
; WASM32-NEXT: local.get 1
; WASM32-NEXT: local.get 2
-; WASM32-NEXT: call cosl
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i32.const 48
+; WASM32-NEXT: i32.const 32
; WASM32-NEXT: i32.add
-; WASM32-NEXT: local.get 3
-; WASM32-NEXT: local.get 4
-; WASM32-NEXT: call sinl
; WASM32-NEXT: local.get 5
; WASM32-NEXT: i32.const 16
; WASM32-NEXT: i32.add
-; WASM32-NEXT: local.get 1
-; WASM32-NEXT: local.get 2
-; WASM32-NEXT: call sinl
+; WASM32-NEXT: call sincosl
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 40
+; WASM32-NEXT: i64.load 72
; WASM32-NEXT: i64.store 56
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 32
+; WASM32-NEXT: i64.load 64
; WASM32-NEXT: i64.store 48
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 8
+; WASM32-NEXT: i64.load 24
; WASM32-NEXT: i64.store 40
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 0
+; WASM32-NEXT: i64.load 16
; WASM32-NEXT: i64.store 32
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 56
+; WASM32-NEXT: i64.load 88
; WASM32-NEXT: i64.store 24
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 48
+; WASM32-NEXT: i64.load 80
; WASM32-NEXT: i64.store 16
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 24
+; WASM32-NEXT: i64.load 40
; WASM32-NEXT: i64.store 8
; WASM32-NEXT: local.get 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i64.load 16
+; WASM32-NEXT: i64.load 32
; WASM32-NEXT: i64.store 0
; WASM32-NEXT: local.get 5
-; WASM32-NEXT: i32.const 64
+; WASM32-NEXT: i32.const 96
; WASM32-NEXT: i32.add
; WASM32-NEXT: global.set __stack_pointer
; WASM32-NEXT: # fallthrough-return
@@ -537,66 +537,66 @@ define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
; WASM64-NEXT: .local i64
; WASM64-NEXT: # %bb.0:
; WASM64-NEXT: global.get __stack_pointer
-; WASM64-NEXT: i64.const 64
+; WASM64-NEXT: i64.const 96
; WASM64-NEXT: i64.sub
; WASM64-NEXT: local.tee 5
; WASM64-NEXT: global.set __stack_pointer
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.const 32
+; WASM64-NEXT: i64.const 48
; WASM64-NEXT: i64.add
; WASM64-NEXT: local.get 3
; WASM64-NEXT: local.get 4
-; WASM64-NEXT: call cosl
+; WASM64-NEXT: local.get 5
+; WASM64-NEXT: i64.const 80
+; WASM64-NEXT: i64.add
+; WASM64-NEXT: local.get 5
+; WASM64-NEXT: i64.const 64
+; WASM64-NEXT: i64.add
+; WASM64-NEXT: call sincosl
; WASM64-NEXT: local.get 5
; WASM64-NEXT: local.get 1
; WASM64-NEXT: local.get 2
-; WASM64-NEXT: call cosl
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.const 48
+; WASM64-NEXT: i64.const 32
; WASM64-NEXT: i64.add
-; WASM64-NEXT: local.get 3
-; WASM64-NEXT: local.get 4
-; WASM64-NEXT: call sinl
; WASM64-NEXT: local.get 5
; WASM64-NEXT: i64.const 16
; WASM64-NEXT: i64.add
-; WASM64-NEXT: local.get 1
-; WASM64-NEXT: local.get 2
-; WASM64-NEXT: call sinl
+; WASM64-NEXT: call sincosl
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 40
+; WASM64-NEXT: i64.load 72
; WASM64-NEXT: i64.store 56
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 32
+; WASM64-NEXT: i64.load 64
; WASM64-NEXT: i64.store 48
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 8
+; WASM64-NEXT: i64.load 24
; WASM64-NEXT: i64.store 40
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 0
+; WASM64-NEXT: i64.load 16
; WASM64-NEXT: i64.store 32
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 56
+; WASM64-NEXT: i64.load 88
; WASM64-NEXT: i64.store 24
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 48
+; WASM64-NEXT: i64.load 80
; WASM64-NEXT: i64.store 16
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 24
+; WASM64-NEXT: i64.load 40
; WASM64-NEXT: i64.store 8
; WASM64-NEXT: local.get 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.load 16
+; WASM64-NEXT: i64.load 32
; WASM64-NEXT: i64.store 0
; WASM64-NEXT: local.get 5
-; WASM64-NEXT: i64.const 64
+; WASM64-NEXT: i64.const 96
; WASM64-NEXT: i64.add
; WASM64-NEXT: global.set __stack_pointer
; WASM64-NEXT: # fallthrough-return
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
index dfff88d30bcd4..13323fb849ecc 100644
--- a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
+++ b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
@@ -537,7 +537,7 @@ define fp128 @fma(fp128 %x, fp128 %y, fp128 %z) nounwind strictfp {
; ANDROID-LABEL: fma:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq fmal at PLT
+; ANDROID-NEXT: callq fmaf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -609,7 +609,7 @@ define fp128 @fma(fp128 %x, fp128 %y, fp128 %z) nounwind strictfp {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r9
-; WIN-NEXT: callq fmal
+; WIN-NEXT: callq fmaf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -653,7 +653,7 @@ define fp128 @fma(fp128 %x, fp128 %y, fp128 %z) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fmal
+; WIN-X86-NEXT: calll _fmaf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -678,7 +678,7 @@ define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
; ANDROID-LABEL: frem:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq fmodl at PLT
+; ANDROID-NEXT: callq fmodf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -739,7 +739,7 @@ define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq fmodl
+; WIN-NEXT: callq fmodf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -775,7 +775,7 @@ define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fmodl
+; WIN-X86-NEXT: calll _fmodf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -800,7 +800,7 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: ceil:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq ceill at PLT
+; ANDROID-NEXT: callq ceilf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -846,7 +846,7 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq ceill
+; WIN-NEXT: callq ceilf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -873,7 +873,7 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _ceill
+; WIN-X86-NEXT: calll _ceilf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -897,7 +897,7 @@ define fp128 @acos(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: acos:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq acosl at PLT
+; ANDROID-NEXT: callq acosf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -943,7 +943,7 @@ define fp128 @acos(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq acosl
+; WIN-NEXT: callq acosf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -970,7 +970,7 @@ define fp128 @acos(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _acosl
+; WIN-X86-NEXT: calll _acosf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -994,7 +994,7 @@ define fp128 @cos(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: cos:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq cosl at PLT
+; ANDROID-NEXT: callq cosf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1040,7 +1040,7 @@ define fp128 @cos(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq cosl
+; WIN-NEXT: callq cosf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1067,7 +1067,7 @@ define fp128 @cos(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _cosl
+; WIN-X86-NEXT: calll _cosf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1091,7 +1091,7 @@ define fp128 @cosh(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: cosh:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq coshl at PLT
+; ANDROID-NEXT: callq coshf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1137,7 +1137,7 @@ define fp128 @cosh(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq coshl
+; WIN-NEXT: callq coshf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1164,7 +1164,7 @@ define fp128 @cosh(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _coshl
+; WIN-X86-NEXT: calll _coshf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1188,7 +1188,7 @@ define fp128 @exp(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: exp:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq expl at PLT
+; ANDROID-NEXT: callq expf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1234,7 +1234,7 @@ define fp128 @exp(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq expl
+; WIN-NEXT: callq expf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1261,7 +1261,7 @@ define fp128 @exp(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _expl
+; WIN-X86-NEXT: calll _expf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1285,7 +1285,7 @@ define fp128 @exp2(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: exp2:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq exp2l at PLT
+; ANDROID-NEXT: callq exp2f128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1331,7 +1331,7 @@ define fp128 @exp2(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq exp2l
+; WIN-NEXT: callq exp2f128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1358,7 +1358,7 @@ define fp128 @exp2(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _exp2l
+; WIN-X86-NEXT: calll _exp2f128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1382,7 +1382,7 @@ define fp128 @floor(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: floor:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq floorl at PLT
+; ANDROID-NEXT: callq floorf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1428,7 +1428,7 @@ define fp128 @floor(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq floorl
+; WIN-NEXT: callq floorf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1455,7 +1455,7 @@ define fp128 @floor(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _floorl
+; WIN-X86-NEXT: calll _floorf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1479,7 +1479,7 @@ define fp128 @log(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: log:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq logl at PLT
+; ANDROID-NEXT: callq logf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1525,7 +1525,7 @@ define fp128 @log(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq logl
+; WIN-NEXT: callq logf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1552,7 +1552,7 @@ define fp128 @log(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _logl
+; WIN-X86-NEXT: calll _logf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1576,7 +1576,7 @@ define fp128 @log10(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: log10:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq log10l at PLT
+; ANDROID-NEXT: callq log10f128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1622,7 +1622,7 @@ define fp128 @log10(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq log10l
+; WIN-NEXT: callq log10f128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1649,7 +1649,7 @@ define fp128 @log10(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _log10l
+; WIN-X86-NEXT: calll _log10f128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1673,7 +1673,7 @@ define fp128 @log2(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: log2:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq log2l at PLT
+; ANDROID-NEXT: callq log2f128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1719,7 +1719,7 @@ define fp128 @log2(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq log2l
+; WIN-NEXT: callq log2f128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1746,7 +1746,7 @@ define fp128 @log2(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _log2l
+; WIN-X86-NEXT: calll _log2f128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1770,7 +1770,7 @@ define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
; ANDROID-LABEL: maxnum:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq fmaxl at PLT
+; ANDROID-NEXT: callq fmaxf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1831,7 +1831,7 @@ define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq fmaxl
+; WIN-NEXT: callq fmaxf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1867,7 +1867,7 @@ define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fmaxl
+; WIN-X86-NEXT: calll _fmaxf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1892,7 +1892,7 @@ define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
; ANDROID-LABEL: minnum:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq fminl at PLT
+; ANDROID-NEXT: callq fminf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -1953,7 +1953,7 @@ define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq fminl
+; WIN-NEXT: callq fminf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -1989,7 +1989,7 @@ define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fminl
+; WIN-X86-NEXT: calll _fminf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2014,7 +2014,7 @@ define fp128 @nearbyint(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: nearbyint:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq nearbyintl at PLT
+; ANDROID-NEXT: callq nearbyintf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2060,7 +2060,7 @@ define fp128 @nearbyint(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq nearbyintl
+; WIN-NEXT: callq nearbyintf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2087,7 +2087,7 @@ define fp128 @nearbyint(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _nearbyintl
+; WIN-X86-NEXT: calll _nearbyintf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2111,7 +2111,7 @@ define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {
; ANDROID-LABEL: pow:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq powl at PLT
+; ANDROID-NEXT: callq powf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2172,7 +2172,7 @@ define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq powl
+; WIN-NEXT: callq powf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2208,7 +2208,7 @@ define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _powl
+; WIN-X86-NEXT: calll _powf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2345,7 +2345,7 @@ define fp128 @rint(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: rint:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq rintl at PLT
+; ANDROID-NEXT: callq rintf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2391,7 +2391,7 @@ define fp128 @rint(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq rintl
+; WIN-NEXT: callq rintf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2418,7 +2418,7 @@ define fp128 @rint(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _rintl
+; WIN-X86-NEXT: calll _rintf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2442,7 +2442,7 @@ define fp128 @round(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: round:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq roundl at PLT
+; ANDROID-NEXT: callq roundf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2488,7 +2488,7 @@ define fp128 @round(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq roundl
+; WIN-NEXT: callq roundf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2515,7 +2515,7 @@ define fp128 @round(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _roundl
+; WIN-X86-NEXT: calll _roundf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2539,7 +2539,7 @@ define fp128 @roundeven(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: roundeven:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq roundevenl at PLT
+; ANDROID-NEXT: callq roundevenf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2585,7 +2585,7 @@ define fp128 @roundeven(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq roundevenl
+; WIN-NEXT: callq roundevenf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2612,7 +2612,7 @@ define fp128 @roundeven(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _roundevenl
+; WIN-X86-NEXT: calll _roundevenf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2636,7 +2636,7 @@ define fp128 @asin(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: asin:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq asinl at PLT
+; ANDROID-NEXT: callq asinf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2682,7 +2682,7 @@ define fp128 @asin(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq asinl
+; WIN-NEXT: callq asinf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2709,7 +2709,7 @@ define fp128 @asin(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _asinl
+; WIN-X86-NEXT: calll _asinf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2733,7 +2733,7 @@ define fp128 @sin(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: sin:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq sinl at PLT
+; ANDROID-NEXT: callq sinf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2779,7 +2779,7 @@ define fp128 @sin(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq sinl
+; WIN-NEXT: callq sinf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2806,7 +2806,7 @@ define fp128 @sin(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _sinl
+; WIN-X86-NEXT: calll _sinf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2830,7 +2830,7 @@ define fp128 @sinh(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: sinh:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq sinhl at PLT
+; ANDROID-NEXT: callq sinhf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2876,7 +2876,7 @@ define fp128 @sinh(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq sinhl
+; WIN-NEXT: callq sinhf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2903,7 +2903,7 @@ define fp128 @sinh(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _sinhl
+; WIN-X86-NEXT: calll _sinhf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2927,7 +2927,7 @@ define fp128 @sqrt(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: sqrt:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq sqrtl at PLT
+; ANDROID-NEXT: callq sqrtf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -2973,7 +2973,7 @@ define fp128 @sqrt(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq sqrtl
+; WIN-NEXT: callq sqrtf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3000,7 +3000,7 @@ define fp128 @sqrt(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _sqrtl
+; WIN-X86-NEXT: calll _sqrtf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -3024,7 +3024,7 @@ define fp128 @atan(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: atan:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq atanl at PLT
+; ANDROID-NEXT: callq atanf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -3070,7 +3070,7 @@ define fp128 @atan(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq atanl
+; WIN-NEXT: callq atanf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3097,7 +3097,7 @@ define fp128 @atan(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _atanl
+; WIN-X86-NEXT: calll _atanf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -3121,7 +3121,7 @@ define fp128 @atan2(fp128 %x, fp128 %y) nounwind strictfp {
; ANDROID-LABEL: atan2:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq atan2l at PLT
+; ANDROID-NEXT: callq atan2f128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -3182,7 +3182,7 @@ define fp128 @atan2(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq atan2l
+; WIN-NEXT: callq atan2f128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3218,7 +3218,7 @@ define fp128 @atan2(fp128 %x, fp128 %y) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _atan2l
+; WIN-X86-NEXT: calll _atan2f128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -3243,7 +3243,7 @@ define fp128 @tan(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: tan:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq tanl at PLT
+; ANDROID-NEXT: callq tanf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -3289,7 +3289,7 @@ define fp128 @tan(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq tanl
+; WIN-NEXT: callq tanf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3316,7 +3316,7 @@ define fp128 @tan(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _tanl
+; WIN-X86-NEXT: calll _tanf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -3340,7 +3340,7 @@ define fp128 @tanh(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: tanh:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq tanhl at PLT
+; ANDROID-NEXT: callq tanhf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -3386,7 +3386,7 @@ define fp128 @tanh(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq tanhl
+; WIN-NEXT: callq tanhf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3413,7 +3413,7 @@ define fp128 @tanh(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _tanhl
+; WIN-X86-NEXT: calll _tanhf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -3437,7 +3437,7 @@ define fp128 @trunc(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: trunc:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq truncl at PLT
+; ANDROID-NEXT: callq truncf128 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
@@ -3483,7 +3483,7 @@ define fp128 @trunc(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq truncl
+; WIN-NEXT: callq truncf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3510,7 +3510,7 @@ define fp128 @trunc(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _truncl
+; WIN-X86-NEXT: calll _truncf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -3534,7 +3534,7 @@ define i32 @lrint(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: lrint:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq lrintl at PLT
+; ANDROID-NEXT: callq lrintf128 at PLT
; ANDROID-NEXT: popq %rcx
; ANDROID-NEXT: retq
;
@@ -3562,7 +3562,7 @@ define i32 @lrint(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps (%rcx), %xmm0
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; WIN-NEXT: callq lrintl
+; WIN-NEXT: callq lrintf128
; WIN-NEXT: addq $56, %rsp
; WIN-NEXT: retq
;
@@ -3576,7 +3576,7 @@ define i32 @lrint(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: pushl 16(%ebp)
; WIN-X86-NEXT: pushl 12(%ebp)
; WIN-X86-NEXT: pushl 8(%ebp)
-; WIN-X86-NEXT: calll _lrintl
+; WIN-X86-NEXT: calll _lrintf128
; WIN-X86-NEXT: addl $16, %esp
; WIN-X86-NEXT: movl %ebp, %esp
; WIN-X86-NEXT: popl %ebp
@@ -3590,7 +3590,7 @@ define i64 @llrint(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: llrint:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq llrintl at PLT
+; ANDROID-NEXT: callq llrintf128 at PLT
; ANDROID-NEXT: popq %rcx
; ANDROID-NEXT: retq
;
@@ -3618,7 +3618,7 @@ define i64 @llrint(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps (%rcx), %xmm0
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; WIN-NEXT: callq llrintl
+; WIN-NEXT: callq llrintf128
; WIN-NEXT: addq $56, %rsp
; WIN-NEXT: retq
;
@@ -3632,7 +3632,7 @@ define i64 @llrint(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: pushl 16(%ebp)
; WIN-X86-NEXT: pushl 12(%ebp)
; WIN-X86-NEXT: pushl 8(%ebp)
-; WIN-X86-NEXT: calll _llrintl
+; WIN-X86-NEXT: calll _llrintf128
; WIN-X86-NEXT: addl $16, %esp
; WIN-X86-NEXT: movl %ebp, %esp
; WIN-X86-NEXT: popl %ebp
@@ -3646,7 +3646,7 @@ define i32 @lround(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: lround:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq lroundl at PLT
+; ANDROID-NEXT: callq lroundf128 at PLT
; ANDROID-NEXT: popq %rcx
; ANDROID-NEXT: retq
;
@@ -3674,7 +3674,7 @@ define i32 @lround(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps (%rcx), %xmm0
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; WIN-NEXT: callq lroundl
+; WIN-NEXT: callq lroundf128
; WIN-NEXT: addq $56, %rsp
; WIN-NEXT: retq
;
@@ -3688,7 +3688,7 @@ define i32 @lround(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: pushl 16(%ebp)
; WIN-X86-NEXT: pushl 12(%ebp)
; WIN-X86-NEXT: pushl 8(%ebp)
-; WIN-X86-NEXT: calll _lroundl
+; WIN-X86-NEXT: calll _lroundf128
; WIN-X86-NEXT: addl $16, %esp
; WIN-X86-NEXT: movl %ebp, %esp
; WIN-X86-NEXT: popl %ebp
@@ -3702,7 +3702,7 @@ define i64 @llround(fp128 %x) nounwind strictfp {
; ANDROID-LABEL: llround:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq llroundl at PLT
+; ANDROID-NEXT: callq llroundf128 at PLT
; ANDROID-NEXT: popq %rcx
; ANDROID-NEXT: retq
;
@@ -3730,7 +3730,7 @@ define i64 @llround(fp128 %x) nounwind strictfp {
; WIN-NEXT: movaps (%rcx), %xmm0
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; WIN-NEXT: callq llroundl
+; WIN-NEXT: callq llroundf128
; WIN-NEXT: addq $56, %rsp
; WIN-NEXT: retq
;
@@ -3744,7 +3744,7 @@ define i64 @llround(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: pushl 16(%ebp)
; WIN-X86-NEXT: pushl 12(%ebp)
; WIN-X86-NEXT: pushl 8(%ebp)
-; WIN-X86-NEXT: calll _llroundl
+; WIN-X86-NEXT: calll _llroundf128
; WIN-X86-NEXT: addl $16, %esp
; WIN-X86-NEXT: movl %ebp, %esp
; WIN-X86-NEXT: popl %ebp
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls.ll b/llvm/test/CodeGen/X86/fp128-libcalls.ll
index c594b15ef1cbe..8b52e99e62906 100644
--- a/llvm/test/CodeGen/X86/fp128-libcalls.ll
+++ b/llvm/test/CodeGen/X86/fp128-libcalls.ll
@@ -1047,7 +1047,7 @@ define dso_local void @Test128Rem(fp128 %d1, fp128 %d2) nounwind {
; ANDROID-LABEL: Test128Rem:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq fmodl at PLT
+; ANDROID-NEXT: callq fmodf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1106,7 +1106,7 @@ define dso_local void @Test128Rem(fp128 %d1, fp128 %d2) nounwind {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq fmodl
+; WIN-NEXT: callq fmodf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $88, %rsp
@@ -1139,7 +1139,7 @@ define dso_local void @Test128Rem(fp128 %d1, fp128 %d2) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fmodl
+; WIN-X86-NEXT: calll _fmodf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1166,7 +1166,7 @@ define dso_local void @Test128_1Rem(fp128 %d1) nounwind {
; ANDROID-NEXT: pushq %rax
; ANDROID-NEXT: movaps %xmm0, %xmm1
; ANDROID-NEXT: movaps vf128(%rip), %xmm0
-; ANDROID-NEXT: callq fmodl at PLT
+; ANDROID-NEXT: callq fmodf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1227,7 +1227,7 @@ define dso_local void @Test128_1Rem(fp128 %d1) nounwind {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq fmodl
+; WIN-NEXT: callq fmodf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $88, %rsp
@@ -1260,7 +1260,7 @@ define dso_local void @Test128_1Rem(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fmodl
+; WIN-X86-NEXT: calll _fmodf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1286,7 +1286,7 @@ define dso_local void @Test128Sqrt(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Sqrt:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq sqrtl at PLT
+; ANDROID-NEXT: callq sqrtf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1328,7 +1328,7 @@ define dso_local void @Test128Sqrt(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq sqrtl
+; WIN-NEXT: callq sqrtf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1351,7 +1351,7 @@ define dso_local void @Test128Sqrt(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _sqrtl
+; WIN-X86-NEXT: calll _sqrtf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1375,7 +1375,7 @@ define dso_local void @Test128Sin(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Sin:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq sinl at PLT
+; ANDROID-NEXT: callq sinf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1417,7 +1417,7 @@ define dso_local void @Test128Sin(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq sinl
+; WIN-NEXT: callq sinf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1440,7 +1440,7 @@ define dso_local void @Test128Sin(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _sinl
+; WIN-X86-NEXT: calll _sinf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1464,7 +1464,7 @@ define dso_local void @Test128Cos(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Cos:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq cosl at PLT
+; ANDROID-NEXT: callq cosf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1506,7 +1506,7 @@ define dso_local void @Test128Cos(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq cosl
+; WIN-NEXT: callq cosf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1529,7 +1529,7 @@ define dso_local void @Test128Cos(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _cosl
+; WIN-X86-NEXT: calll _cosf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1553,7 +1553,7 @@ define dso_local void @Test128Ceil(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Ceil:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq ceill at PLT
+; ANDROID-NEXT: callq ceilf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1595,7 +1595,7 @@ define dso_local void @Test128Ceil(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq ceill
+; WIN-NEXT: callq ceilf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1618,7 +1618,7 @@ define dso_local void @Test128Ceil(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _ceill
+; WIN-X86-NEXT: calll _ceilf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1642,7 +1642,7 @@ define dso_local void @Test128Floor(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Floor:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq floorl at PLT
+; ANDROID-NEXT: callq floorf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1684,7 +1684,7 @@ define dso_local void @Test128Floor(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq floorl
+; WIN-NEXT: callq floorf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1707,7 +1707,7 @@ define dso_local void @Test128Floor(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _floorl
+; WIN-X86-NEXT: calll _floorf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1731,7 +1731,7 @@ define dso_local void @Test128Trunc(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Trunc:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq truncl at PLT
+; ANDROID-NEXT: callq truncf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1773,7 +1773,7 @@ define dso_local void @Test128Trunc(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq truncl
+; WIN-NEXT: callq truncf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1796,7 +1796,7 @@ define dso_local void @Test128Trunc(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _truncl
+; WIN-X86-NEXT: calll _truncf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1820,7 +1820,7 @@ define dso_local void @Test128Nearbyint(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Nearbyint:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq nearbyintl at PLT
+; ANDROID-NEXT: callq nearbyintf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1862,7 +1862,7 @@ define dso_local void @Test128Nearbyint(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq nearbyintl
+; WIN-NEXT: callq nearbyintf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1885,7 +1885,7 @@ define dso_local void @Test128Nearbyint(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _nearbyintl
+; WIN-X86-NEXT: calll _nearbyintf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1909,7 +1909,7 @@ define dso_local void @Test128Rint(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Rint:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq rintl at PLT
+; ANDROID-NEXT: callq rintf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -1951,7 +1951,7 @@ define dso_local void @Test128Rint(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq rintl
+; WIN-NEXT: callq rintf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -1974,7 +1974,7 @@ define dso_local void @Test128Rint(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _rintl
+; WIN-X86-NEXT: calll _rintf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -1998,7 +1998,7 @@ define dso_local void @Test128Round(fp128 %d1) nounwind {
; ANDROID-LABEL: Test128Round:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq roundl at PLT
+; ANDROID-NEXT: callq roundf128 at PLT
; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
@@ -2040,7 +2040,7 @@ define dso_local void @Test128Round(fp128 %d1) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq roundl
+; WIN-NEXT: callq roundf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, vf128(%rip)
; WIN-NEXT: addq $72, %rsp
@@ -2063,7 +2063,7 @@ define dso_local void @Test128Round(fp128 %d1) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _roundl
+; WIN-X86-NEXT: calll _roundf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2086,7 +2086,7 @@ declare fp128 @llvm.round.f128(fp128)
define fp128 @Test128FMA(fp128 %a, fp128 %b, fp128 %c) nounwind {
; ANDROID-LABEL: Test128FMA:
; ANDROID: # %bb.0: # %entry
-; ANDROID-NEXT: jmp fmal at PLT # TAILCALL
+; ANDROID-NEXT: jmp fmaf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128FMA:
; GNU: # %bb.0: # %entry
@@ -2153,7 +2153,7 @@ define fp128 @Test128FMA(fp128 %a, fp128 %b, fp128 %c) nounwind {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r9
-; WIN-NEXT: callq fmal
+; WIN-NEXT: callq fmaf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2197,7 +2197,7 @@ define fp128 @Test128FMA(fp128 %a, fp128 %b, fp128 %c) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _fmal
+; WIN-X86-NEXT: calll _fmaf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2222,7 +2222,7 @@ declare fp128 @llvm.fma.f128(fp128, fp128, fp128)
define fp128 @Test128Acos(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Acos:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp acosl at PLT # TAILCALL
+; ANDROID-NEXT: jmp acosf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Acos:
; GNU: # %bb.0:
@@ -2263,7 +2263,7 @@ define fp128 @Test128Acos(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq acosl
+; WIN-NEXT: callq acosf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2290,7 +2290,7 @@ define fp128 @Test128Acos(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _acosl
+; WIN-X86-NEXT: calll _acosf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2312,7 +2312,7 @@ define fp128 @Test128Acos(fp128 %a) nounwind {
define fp128 @Test128Asin(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Asin:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp asinl at PLT # TAILCALL
+; ANDROID-NEXT: jmp asinf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Asin:
; GNU: # %bb.0:
@@ -2353,7 +2353,7 @@ define fp128 @Test128Asin(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq asinl
+; WIN-NEXT: callq asinf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2380,7 +2380,7 @@ define fp128 @Test128Asin(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _asinl
+; WIN-X86-NEXT: calll _asinf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2402,7 +2402,7 @@ define fp128 @Test128Asin(fp128 %a) nounwind {
define fp128 @Test128Atan(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Atan:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp atanl at PLT # TAILCALL
+; ANDROID-NEXT: jmp atanf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Atan:
; GNU: # %bb.0:
@@ -2443,7 +2443,7 @@ define fp128 @Test128Atan(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq atanl
+; WIN-NEXT: callq atanf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2470,7 +2470,7 @@ define fp128 @Test128Atan(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _atanl
+; WIN-X86-NEXT: calll _atanf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2492,7 +2492,7 @@ define fp128 @Test128Atan(fp128 %a) nounwind {
define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind {
; ANDROID-LABEL: Test128Atan2:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp atan2l at PLT # TAILCALL
+; ANDROID-NEXT: jmp atan2f128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Atan2:
; GNU: # %bb.0:
@@ -2548,7 +2548,7 @@ define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind {
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %r8
-; WIN-NEXT: callq atan2l
+; WIN-NEXT: callq atan2f128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2584,7 +2584,7 @@ define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _atan2l
+; WIN-X86-NEXT: calll _atan2f128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2607,7 +2607,7 @@ define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind {
define fp128 @Test128Cosh(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Cosh:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp coshl at PLT # TAILCALL
+; ANDROID-NEXT: jmp coshf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Cosh:
; GNU: # %bb.0:
@@ -2648,7 +2648,7 @@ define fp128 @Test128Cosh(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq coshl
+; WIN-NEXT: callq coshf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2675,7 +2675,7 @@ define fp128 @Test128Cosh(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _coshl
+; WIN-X86-NEXT: calll _coshf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2697,7 +2697,7 @@ define fp128 @Test128Cosh(fp128 %a) nounwind {
define fp128 @Test128Sinh(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Sinh:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp sinhl at PLT # TAILCALL
+; ANDROID-NEXT: jmp sinhf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Sinh:
; GNU: # %bb.0:
@@ -2738,7 +2738,7 @@ define fp128 @Test128Sinh(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq sinhl
+; WIN-NEXT: callq sinhf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2765,7 +2765,7 @@ define fp128 @Test128Sinh(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _sinhl
+; WIN-X86-NEXT: calll _sinhf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2787,7 +2787,7 @@ define fp128 @Test128Sinh(fp128 %a) nounwind {
define fp128 @Test128Tan(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Tan:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp tanl at PLT # TAILCALL
+; ANDROID-NEXT: jmp tanf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Tan:
; GNU: # %bb.0:
@@ -2828,7 +2828,7 @@ define fp128 @Test128Tan(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq tanl
+; WIN-NEXT: callq tanf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2855,7 +2855,7 @@ define fp128 @Test128Tan(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _tanl
+; WIN-X86-NEXT: calll _tanf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2877,7 +2877,7 @@ define fp128 @Test128Tan(fp128 %a) nounwind {
define fp128 @Test128Tanh(fp128 %a) nounwind {
; ANDROID-LABEL: Test128Tanh:
; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp tanhl at PLT # TAILCALL
+; ANDROID-NEXT: jmp tanhf128 at PLT # TAILCALL
;
; GNU-LABEL: Test128Tanh:
; GNU: # %bb.0:
@@ -2918,7 +2918,7 @@ define fp128 @Test128Tanh(fp128 %a) nounwind {
; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq tanhl
+; WIN-NEXT: callq tanhf128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -2945,7 +2945,7 @@ define fp128 @Test128Tanh(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _tanhl
+; WIN-X86-NEXT: calll _tanhf128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -2969,7 +2969,7 @@ define { fp128, fp128 } @Test128Modf(fp128 %a) nounwind {
; ANDROID: # %bb.0:
; ANDROID-NEXT: subq $24, %rsp
; ANDROID-NEXT: movq %rsp, %rdi
-; ANDROID-NEXT: callq modfl at PLT
+; ANDROID-NEXT: callq modff128 at PLT
; ANDROID-NEXT: movaps (%rsp), %xmm1
; ANDROID-NEXT: addq $24, %rsp
; ANDROID-NEXT: retq
@@ -3025,7 +3025,7 @@ define { fp128, fp128 } @Test128Modf(fp128 %a) nounwind {
; WIN-NEXT: leaq 16(%rcx), %r8
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq modfl
+; WIN-NEXT: callq modff128
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -3055,7 +3055,7 @@ define { fp128, fp128 } @Test128Modf(fp128 %a) nounwind {
; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, (%esp)
-; WIN-X86-NEXT: calll _modfl
+; WIN-X86-NEXT: calll _modff128
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
More information about the cfe-commits
mailing list