[llvm] RuntimeLibcalls: Fix reporting incorrectly typed fp128 long double functions (PR #214944)
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 14 10:54:44 PDT 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/214944
>From 6e369d7ca7e9a7cc27dda0ff7b995a35f97a7a9e Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Sun, 9 Aug 2026 01:00:09 +0200
Subject: [PATCH 1/4] RuntimeLibcalls: Fix reporting incorrectly typed fp128
long double functions
l-suffixed long double math functions are fp128 only when the target's
long double is fp128. The default set provided them on every target that was
not x87 or ppc_fp128, so targets using double as long double wrongly reported
the fp128 l-suffixed functions.
Update tests that were reliant on phantom fp128 calls. These are only available
with glibc on select targets. In cases where the target supports the calls in
some triple, split the tests. In cases where the target has no fp128 library
support, delete the tests.
Related: #44744
Co-authored-by: Claude (Claude-Opus-4.8) <noreply at anthropic.com>
---
llvm/include/llvm/IR/RuntimeLibcalls.h | 6 +-
llvm/include/llvm/IR/RuntimeLibcalls.td | 29 +-
llvm/lib/IR/RuntimeLibcalls.cpp | 16 +-
.../test/CodeGen/AArch64/illegal-float-ops.ll | 1 -
llvm/test/CodeGen/ARM/llrint-conv.ll | 12 -
llvm/test/CodeGen/ARM/llround-conv.ll | 12 -
llvm/test/CodeGen/ARM/llvm.sincos.ll | 122 +-
llvm/test/CodeGen/ARM/lrint-conv.ll | 12 -
llvm/test/CodeGen/ARM/lround-conv.ll | 13 -
llvm/test/CodeGen/ARM/vector-llrint.ll | 342 --
llvm/test/CodeGen/ARM/vector-lrint.ll | 1205 ------
llvm/test/CodeGen/AVR/llrint.ll | 11 -
llvm/test/CodeGen/AVR/llvm.sincos.ll | 126 -
llvm/test/CodeGen/AVR/lrint.ll | 11 -
.../CodeGen/Generic/fp128-math-libcalls.ll | 30 +-
llvm/test/CodeGen/Hexagon/llvm.exp10.ll | 80 -
llvm/test/CodeGen/Hexagon/llvm.sincos.ll | 391 --
.../CodeGen/LoongArch/llvm.exp10.fp128.ll | 61 +
llvm/test/CodeGen/LoongArch/llvm.exp10.ll | 144 +-
.../CodeGen/LoongArch/llvm.sincos.fp128.ll | 111 +
llvm/test/CodeGen/LoongArch/llvm.sincos.ll | 255 +-
.../CodeGen/LoongArch/lrint-conv.fp128.ll | 25 +
llvm/test/CodeGen/LoongArch/lrint-conv.ll | 28 +-
llvm/test/CodeGen/MSP430/llvm.exp10.ll | 83 -
llvm/test/CodeGen/MSP430/llvm.sincos.ll | 73 -
llvm/test/CodeGen/MSP430/lrint-conv.ll | 31 +-
llvm/test/CodeGen/Mips/ldexp.ll | 15 -
llvm/test/CodeGen/Mips/llrint-conv-fp128.ll | 23 +
llvm/test/CodeGen/Mips/llrint-conv.ll | 19 +-
llvm/test/CodeGen/Mips/llvm.frexp.ll | 196 -
llvm/test/CodeGen/Mips/lrint-conv-fp128.ll | 23 +
llvm/test/CodeGen/Mips/lrint-conv.ll | 19 +-
llvm/test/CodeGen/RISCV/fp128.ll | 45 +
.../CodeGen/X86/fminimum-fmaximum-i686.ll | 172 +-
llvm/test/CodeGen/X86/fminimum-fmaximum.ll | 165 -
.../CodeGen/X86/fminimumnum-fmaximumnum.ll | 380 --
llvm/test/CodeGen/X86/fp128-libcalls-gnu.ll | 835 +++++
.../CodeGen/X86/fp128-libcalls-strict-gnu.ll | 1283 +++++++
.../test/CodeGen/X86/fp128-libcalls-strict.ll | 3238 +----------------
llvm/test/CodeGen/X86/fp128-libcalls.ll | 2051 +----------
llvm/test/CodeGen/X86/llrint-conv.ll | 143 -
llvm/test/CodeGen/X86/llround-conv.ll | 96 -
llvm/test/CodeGen/X86/lrint-conv-i32.ll | 109 -
llvm/test/CodeGen/X86/lrint-conv-i64.ll | 83 -
llvm/test/CodeGen/X86/lround-conv-i32.ll | 48 -
llvm/test/CodeGen/X86/lround-conv-i64.ll | 49 -
llvm/test/CodeGen/X86/vector-llrint.ll | 868 -----
llvm/test/CodeGen/X86/vector-lrint.ll | 1547 --------
llvm/test/CodeGen/XCore/llvm.exp10.ll | 15 -
llvm/test/CodeGen/XCore/llvm.frexp.ll | 15 -
llvm/test/CodeGen/XCore/llvm.sincos.ll | 18 -
.../RuntimeLibcallEmitter-calling-conv.td | 2 +-
llvm/test/TableGen/RuntimeLibcallEmitter.td | 2 +-
.../TableGen/Basic/RuntimeLibcallsEmitter.cpp | 2 +-
54 files changed, 2578 insertions(+), 12113 deletions(-)
create mode 100644 llvm/test/CodeGen/LoongArch/llvm.exp10.fp128.ll
create mode 100644 llvm/test/CodeGen/LoongArch/llvm.sincos.fp128.ll
create mode 100644 llvm/test/CodeGen/LoongArch/lrint-conv.fp128.ll
create mode 100644 llvm/test/CodeGen/Mips/llrint-conv-fp128.ll
create mode 100644 llvm/test/CodeGen/Mips/lrint-conv-fp128.ll
create mode 100644 llvm/test/CodeGen/X86/fp128-libcalls-gnu.ll
create mode 100644 llvm/test/CodeGen/X86/fp128-libcalls-strict-gnu.ll
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h
index affc8545ef91b..a1f03393d1b23 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -229,13 +229,15 @@ struct RuntimeLibcallsInfo {
void setTargetRuntimeLibcallSets(const Triple &TT,
ExceptionHandling ExceptionModel,
FloatABI::ABIType FloatABI, EABI ABIType,
- StringRef ABIName);
+ StringRef ABIName,
+ LongDoubleFormat LongDoubleFormat);
/// Set default libcall names. If a target wants to opt-out of a libcall it
/// should be placed here.
LLVM_ABI void initLibcalls(const Triple &TT, ExceptionHandling ExceptionModel,
FloatABI::ABIType FloatABI, EABI ABIType,
- StringRef ABIName);
+ StringRef ABIName,
+ LongDoubleFormat LongDoubleFormat);
};
} // namespace RTLIB
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 341b103e2bb90..16cd8c538a91a 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -59,6 +59,8 @@ def IsAAPCS_ABI : LibcallPredicate<[{isAAPCS_ABI(TT, ABIName)}]>;
def IsEABI4 : LibcallPredicate<[{EABIVersion == EABI::EABI4}]>;
def IsEABI5 : LibcallPredicate<[{EABIVersion == EABI::EABI5}]>;
+def IsLongDoubleF128 : LibcallPredicate<[{LongDoubleFormat == LongDoubleFormat::IEEEquad}]>;
+
def IsAMDGPU : LibcallPredicate<[{TT.isAMDGPU()}]>;
def IsARM : LibcallPredicate<[{TT.isARM()}]>;
def IsThumb : LibcallPredicate<[{TT.isThumb()}]>;
@@ -108,6 +110,10 @@ def IsArchXtensa : LibcallPredicate<[{TT.getArch() == Triple::xtensa}]>;
def isOSDarwin : RuntimeLibcallAvailability<(all_of IsOSDarwin)>;
def isOSOpenBSD : RuntimeLibcallAvailability<(all_of IsOSOpenBSD)>;
def isNotOSOpenBSD : RuntimeLibcallAvailability<(not IsOSOpenBSD)>;
+
+// True when the C `long double` type is IEEE fp128.
+def isLongDoubleF128 : RuntimeLibcallAvailability<(all_of IsLongDoubleF128)>;
+
def isOSWindows : RuntimeLibcallAvailability<(all_of IsOSWindows)>;
def isNotOSWindows : RuntimeLibcallAvailability<(not IsOSWindows)>;
def isNotOSLinux : RuntimeLibcallAvailability<(not IsOSLinux)>;
@@ -1988,17 +1994,29 @@ defvar DefaultRuntimeLibcallImpls_f128 =
!filter(entry, AllDefaultRuntimeLibcallImpls,
!match(!cast<string>(entry.Provides), "_F128"));
+// The l-suffixed libm functions are fp128 only when long double is fp128.
+defvar DefaultRuntimeLibcallImpls_longdouble_f128 =
+ !filter(entry, AllDefaultRuntimeLibcallImpls,
+ !match(!cast<string>(entry), "l_f128"));
+
// FIXME: Ideally we would just use dags everywhere, but for the
// arm64ec case we need iterable lists so we can add the # prefix
+//
+// The fp128 long double libcalls are removed here and re-added per-target
+// gated on the long double format.
defvar DefaultRuntimeLibcallImplsBaseList =
!listremove(
!listremove(
- !listremove(AllDefaultRuntimeLibcallImpls, Int128RTLibcalls),
- DefaultRuntimeLibcallImpls_f80),
- DefaultRuntimeLibcallImpls_ppcf128);
+ !listremove(
+ !listremove(AllDefaultRuntimeLibcallImpls, Int128RTLibcalls),
+ DefaultRuntimeLibcallImpls_f80),
+ DefaultRuntimeLibcallImpls_ppcf128),
+ DefaultRuntimeLibcallImpls_longdouble_f128);
defvar DefaultRuntimeLibcallImpls =
(add DefaultRuntimeLibcallImplsBaseList,
+ LibcallImpls<(add DefaultRuntimeLibcallImpls_longdouble_f128),
+ isLongDoubleF128>,
ExceptionModelCalls);
/// Default set of libcall impls for 32-bit architectures.
@@ -2179,6 +2197,10 @@ def isWindowsArm64EC : RuntimeLibcallAvailability<(all_of IsWindowsArm64EC)>;
def isAArch64_ILP64
: RuntimeLibcallAvailability<(all_of IsAArch64_ILP64)>;
+// frexpl/ldexpl/exp10l are added separately with their own OS guards.
+defvar AArch64LongDoubleF128Body =
+ !listremove(DefaultRuntimeLibcallImpls_longdouble_f128,
+ [frexpl_f128, ldexpl_f128, exp10l_f128]);
def AArch64SystemLibrary : SystemRuntimeLibrary<
isAArch64_ExceptArm64EC,
@@ -2186,6 +2208,7 @@ def AArch64SystemLibrary : SystemRuntimeLibrary<
LibcallImpls<(add __powisf2, __powidf2), isNotOSMSVCRT>,
LibmHasFrexpF32, LibmHasLdexpF32,
LibmHasFrexpF128, LibmHasLdexpF128,
+ LibcallImpls<(add AArch64LongDoubleF128Body), isLongDoubleF128>,
AArch64LibcallImpls,
LibcallImpls<(add Int128RTLibcalls), isAArch64_ILP64>,
LibcallImpls<(add bzero), isOSDarwin>,
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 4afb80d28bffe..e1148891af69a 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -41,7 +41,8 @@ RuntimeLibcallsInfo::RuntimeLibcallsInfo(const Triple &TT,
if (ExceptionModel == ExceptionHandling::None)
ExceptionModel = TT.getDefaultExceptionHandling();
- initLibcalls(TT, ExceptionModel, FloatABI, EABIVersion, ABIName);
+ initLibcalls(TT, ExceptionModel, FloatABI, EABIVersion, ABIName,
+ TT.getDefaultLongDoubleFormat());
// TODO: Tablegen should generate these sets
switch (VecLib) {
@@ -104,9 +105,11 @@ RuntimeLibcallsInfo::RuntimeLibcallsInfo(const Triple &TT,
}
}
-RuntimeLibcallsInfo::RuntimeLibcallsInfo(const Module &M)
- : RuntimeLibcallsInfo(M.getTargetTriple()) {
- // TODO: Consider module flags
+RuntimeLibcallsInfo::RuntimeLibcallsInfo(const Module &M) {
+ // TODO: Consider the remaining module flags.
+ const Triple &TT = M.getTargetTriple();
+ initLibcalls(TT, TT.getDefaultExceptionHandling(), FloatABI::Default,
+ EABI::Default, /*ABIName=*/"", M.getLongDoubleFormat());
}
/// Set default libcall names. If a target wants to opt-out of a libcall it
@@ -114,9 +117,10 @@ RuntimeLibcallsInfo::RuntimeLibcallsInfo(const Module &M)
void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
ExceptionHandling ExceptionModel,
FloatABI::ABIType FloatABI,
- EABI EABIVersion, StringRef ABIName) {
+ EABI EABIVersion, StringRef ABIName,
+ LongDoubleFormat LongDoubleFormat) {
setTargetRuntimeLibcallSets(TT, ExceptionModel, FloatABI, EABIVersion,
- ABIName);
+ ABIName, LongDoubleFormat);
}
LLVM_ATTRIBUTE_ALWAYS_INLINE
diff --git a/llvm/test/CodeGen/AArch64/illegal-float-ops.ll b/llvm/test/CodeGen/AArch64/illegal-float-ops.ll
index 5ec66b784c037..4f4c2359e7580 100644
--- a/llvm/test/CodeGen/AArch64/illegal-float-ops.ll
+++ b/llvm/test/CodeGen/AArch64/illegal-float-ops.ll
@@ -1,5 +1,4 @@
; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs -o - %s | FileCheck %s
-; RUN: llc -mtriple=aarch64-linux-android -verify-machineinstrs -o - %s | FileCheck %s
@varfloat = global float 0.0
@vardouble = global double 0.0
diff --git a/llvm/test/CodeGen/ARM/llrint-conv.ll b/llvm/test/CodeGen/ARM/llrint-conv.ll
index 7274a8b0ce34e..2f80245b3b46d 100644
--- a/llvm/test/CodeGen/ARM/llrint-conv.ll
+++ b/llvm/test/CodeGen/ARM/llrint-conv.ll
@@ -66,15 +66,3 @@ entry:
%0 = tail call i64 @llvm.llrint.i64.f64(double %x)
ret i64 %0
}
-
-define i64 @testmsxq_builtin(fp128 %x) {
-; CHECK-LABEL: testmsxq_builtin:
-; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: .save {r11, lr}
-; CHECK-NEXT: push {r11, lr}
-; CHECK-NEXT: bl llrintl
-; CHECK-NEXT: pop {r11, pc}
-entry:
- %0 = tail call i64 @llvm.llrint.i64.f128(fp128 %x)
- ret i64 %0
-}
diff --git a/llvm/test/CodeGen/ARM/llround-conv.ll b/llvm/test/CodeGen/ARM/llround-conv.ll
index 20fe2728d26d5..3c9346ef69d93 100644
--- a/llvm/test/CodeGen/ARM/llround-conv.ll
+++ b/llvm/test/CodeGen/ARM/llround-conv.ll
@@ -66,15 +66,3 @@ entry:
%0 = tail call i64 @llvm.llround.i64.f64(double %x)
ret i64 %0
}
-
-define i64 @testmsxq_builtin(fp128 %x) {
-; CHECK-LABEL: testmsxq_builtin:
-; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: .save {r11, lr}
-; CHECK-NEXT: push {r11, lr}
-; CHECK-NEXT: bl llroundl
-; CHECK-NEXT: pop {r11, pc}
-entry:
- %0 = tail call i64 @llvm.llround.i64.f128(fp128 %x)
- ret i64 %0
-}
diff --git a/llvm/test/CodeGen/ARM/llvm.sincos.ll b/llvm/test/CodeGen/ARM/llvm.sincos.ll
index 1448fac8d864f..7de5c8b0d7f36 100644
--- a/llvm/test/CodeGen/ARM/llvm.sincos.ll
+++ b/llvm/test/CodeGen/ARM/llvm.sincos.ll
@@ -882,123 +882,5 @@ define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) {
ret { <2 x double>, <2 x double> } %result
}
-define { fp128, fp128 } @test_sincos_f128(fp128 %a) {
-; GNU-LABEL: test_sincos_f128:
-; GNU: @ %bb.0:
-; GNU-NEXT: push {r4, r5, r7, lr}
-; GNU-NEXT: sub sp, #40
-; GNU-NEXT: mov r12, r3
-; GNU-NEXT: ldr r3, [sp, #56]
-; GNU-NEXT: add.w lr, sp, #8
-; GNU-NEXT: mov r4, r0
-; GNU-NEXT: add r0, sp, #24
-; GNU-NEXT: strd r0, lr, [sp]
-; GNU-NEXT: mov r0, r1
-; GNU-NEXT: mov r1, r2
-; GNU-NEXT: mov r2, r12
-; GNU-NEXT: bl sincosl
-; GNU-NEXT: ldrd r2, r3, [sp, #16]
-; GNU-NEXT: ldrd r12, r1, [sp, #8]
-; GNU-NEXT: str r3, [r4, #28]
-; GNU-NEXT: ldrd r3, r5, [sp, #32]
-; GNU-NEXT: ldrd lr, r0, [sp, #24]
-; GNU-NEXT: strd r1, r2, [r4, #20]
-; GNU-NEXT: add.w r1, r4, #8
-; GNU-NEXT: stm.w r1, {r3, r5, r12}
-; GNU-NEXT: strd lr, r0, [r4]
-; GNU-NEXT: add sp, #40
-; GNU-NEXT: pop {r4, r5, r7, pc}
-;
-; GNUEABI-LABEL: test_sincos_f128:
-; GNUEABI: @ %bb.0:
-; GNUEABI-NEXT: .save {r4, r5, r11, lr}
-; GNUEABI-NEXT: push {r4, r5, r11, lr}
-; GNUEABI-NEXT: .pad #40
-; GNUEABI-NEXT: sub sp, sp, #40
-; GNUEABI-NEXT: mov r12, r3
-; GNUEABI-NEXT: ldr r3, [sp, #56]
-; GNUEABI-NEXT: mov r4, r0
-; GNUEABI-NEXT: add r0, sp, #24
-; GNUEABI-NEXT: add r5, sp, #8
-; GNUEABI-NEXT: stm sp, {r0, r5}
-; GNUEABI-NEXT: mov r0, r1
-; GNUEABI-NEXT: mov r1, r2
-; GNUEABI-NEXT: mov r2, r12
-; GNUEABI-NEXT: bl sincosl
-; GNUEABI-NEXT: add r3, sp, #12
-; GNUEABI-NEXT: ldr r12, [sp, #8]
-; GNUEABI-NEXT: ldm r3, {r1, r2, r3}
-; GNUEABI-NEXT: str r3, [r4, #28]
-; GNUEABI-NEXT: ldr r0, [sp, #32]
-; GNUEABI-NEXT: ldr lr, [sp, #24]
-; GNUEABI-NEXT: ldr r5, [sp, #28]
-; GNUEABI-NEXT: ldr r3, [sp, #36]
-; GNUEABI-NEXT: str r2, [r4, #24]
-; GNUEABI-NEXT: str r1, [r4, #20]
-; GNUEABI-NEXT: add r1, r4, #8
-; GNUEABI-NEXT: stm r1, {r0, r3, r12}
-; GNUEABI-NEXT: str r5, [r4, #4]
-; GNUEABI-NEXT: str lr, [r4]
-; GNUEABI-NEXT: add sp, sp, #40
-; GNUEABI-NEXT: pop {r4, r5, r11, pc}
-;
-; IOS-LABEL: test_sincos_f128:
-; IOS: @ %bb.0:
-; IOS-NEXT: push {r4, r5, r6, r7, r8, lr}
-; IOS-NEXT: ldr r8, [sp, #24]
-; IOS-NEXT: mov r4, r0
-; IOS-NEXT: mov r5, r3
-; IOS-NEXT: mov r6, r2
-; IOS-NEXT: mov r7, r1
-; IOS-NEXT: mov r0, r1
-; IOS-NEXT: mov r1, r2
-; IOS-NEXT: mov r2, r3
-; IOS-NEXT: mov r3, r8
-; IOS-NEXT: bl _cosl
-; IOS-NEXT: add r9, r4, #16
-; IOS-NEXT: stm r9, {r0, r1, r2, r3}
-; IOS-NEXT: mov r0, r7
-; IOS-NEXT: mov r1, r6
-; IOS-NEXT: mov r2, r5
-; IOS-NEXT: mov r3, r8
-; IOS-NEXT: bl _sinl
-; IOS-NEXT: stm r4, {r0, r1, r2, r3}
-; IOS-NEXT: pop {r4, r5, r6, r7, r8, pc}
-;
-; WATCHABI-LABEL: test_sincos_f128:
-; WATCHABI: .cfi_startproc
-; WATCHABI-NEXT: @ %bb.0:
-; WATCHABI-NEXT: push.w {r4, r5, r6, r7, r8, lr}
-; WATCHABI-NEXT: .cfi_def_cfa_offset 24
-; WATCHABI-NEXT: .cfi_offset lr, -4
-; WATCHABI-NEXT: .cfi_offset r7, -8
-; WATCHABI-NEXT: .cfi_offset r6, -12
-; WATCHABI-NEXT: .cfi_offset r5, -16
-; WATCHABI-NEXT: .cfi_offset r4, -20
-; WATCHABI-NEXT: .cfi_offset r8, -24
-; WATCHABI-NEXT: sub sp, #8
-; WATCHABI-NEXT: .cfi_def_cfa_offset 32
-; WATCHABI-NEXT: ldr.w r8, [sp, #32]
-; WATCHABI-NEXT: mov r4, r0
-; WATCHABI-NEXT: mov r5, r3
-; WATCHABI-NEXT: mov r6, r2
-; WATCHABI-NEXT: mov r7, r1
-; WATCHABI-NEXT: mov r0, r1
-; WATCHABI-NEXT: mov r1, r2
-; WATCHABI-NEXT: mov r2, r3
-; WATCHABI-NEXT: mov r3, r8
-; WATCHABI-NEXT: bl _cosl
-; WATCHABI-NEXT: add.w r9, r4, #16
-; WATCHABI-NEXT: stm.w r9, {r0, r1, r2, r3}
-; WATCHABI-NEXT: mov r0, r7
-; WATCHABI-NEXT: mov r1, r6
-; WATCHABI-NEXT: mov r2, r5
-; WATCHABI-NEXT: mov r3, r8
-; WATCHABI-NEXT: bl _sinl
-; WATCHABI-NEXT: stm r4!, {r0, r1, r2, r3}
-; WATCHABI-NEXT: add sp, #8
-; WATCHABI-NEXT: pop.w {r4, r5, r6, r7, r8, pc}
-; WATCHABI-NEXT: .cfi_endproc
- %result = call { fp128, fp128 } @llvm.sincos.f16(fp128 %a)
- ret { fp128, fp128 } %result
-}
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; IOS: {{.*}}
diff --git a/llvm/test/CodeGen/ARM/lrint-conv.ll b/llvm/test/CodeGen/ARM/lrint-conv.ll
index 2de234919a148..f87aa9181474b 100644
--- a/llvm/test/CodeGen/ARM/lrint-conv.ll
+++ b/llvm/test/CodeGen/ARM/lrint-conv.ll
@@ -56,15 +56,3 @@ entry:
%0 = tail call i32 @llvm.lrint.i32.f64(double %x)
ret i32 %0
}
-
-define i32 @testmswq_builtin(fp128 %x) {
-; CHECK-LABEL: testmswq_builtin:
-; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: .save {r11, lr}
-; CHECK-NEXT: push {r11, lr}
-; CHECK-NEXT: bl lrintl
-; CHECK-NEXT: pop {r11, pc}
-entry:
- %0 = tail call i32 @llvm.lrint.i32.f128(fp128 %x)
- ret i32 %0
-}
diff --git a/llvm/test/CodeGen/ARM/lround-conv.ll b/llvm/test/CodeGen/ARM/lround-conv.ll
index 7466bcb982efb..6929af8b1b74b 100644
--- a/llvm/test/CodeGen/ARM/lround-conv.ll
+++ b/llvm/test/CodeGen/ARM/lround-conv.ll
@@ -55,16 +55,3 @@ entry:
%0 = tail call i32 @llvm.lround.i32.f64(double %x)
ret i32 %0
}
-
-define i32 @testmswq_builtin(fp128 %x) {
-; CHECK-LABEL: testmswq_builtin:
-; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: .save {r11, lr}
-; CHECK-NEXT: push {r11, lr}
-; CHECK-NEXT: bl lroundl
-; CHECK-NEXT: pop {r11, pc}
-entry:
- %0 = tail call i32 @llvm.lround.i32.f128(fp128 %x)
- ret i32 %0
-}
-
diff --git a/llvm/test/CodeGen/ARM/vector-llrint.ll b/llvm/test/CodeGen/ARM/vector-llrint.ll
index 7fe1145007f63..b19085aa967e8 100644
--- a/llvm/test/CodeGen/ARM/vector-llrint.ll
+++ b/llvm/test/CodeGen/ARM/vector-llrint.ll
@@ -2031,345 +2031,3 @@ define <16 x i64> @llrint_v16f64(<16 x double> %x) {
ret <16 x i64> %a
}
declare <16 x i64> @llvm.llrint.v16i64.v16f64(<16 x double>)
-
-define <1 x i64> @llrint_v1i64_v1f128(<1 x fp128> %x) {
-; LE-LABEL: llrint_v1i64_v1f128:
-; LE: @ %bb.0:
-; LE-NEXT: .save {r11, lr}
-; LE-NEXT: push {r11, lr}
-; LE-NEXT: bl llrintl
-; LE-NEXT: vmov.32 d0[0], r0
-; LE-NEXT: vmov.32 d0[1], r1
-; LE-NEXT: pop {r11, pc}
-;
-; BE-LABEL: llrint_v1i64_v1f128:
-; BE: @ %bb.0:
-; BE-NEXT: .save {r11, lr}
-; BE-NEXT: push {r11, lr}
-; BE-NEXT: bl llrintl
-; BE-NEXT: vmov.32 d16[0], r0
-; BE-NEXT: vmov.32 d16[1], r1
-; BE-NEXT: vrev64.32 d0, d16
-; BE-NEXT: pop {r11, pc}
- %a = call <1 x i64> @llvm.llrint.v1i64.v1f128(<1 x fp128> %x)
- ret <1 x i64> %a
-}
-declare <1 x i64> @llvm.llrint.v1i64.v1f128(<1 x fp128>)
-
-define <2 x i64> @llrint_v2i64_v2f128(<2 x fp128> %x) {
-; LE-LABEL: llrint_v2i64_v2f128:
-; LE: @ %bb.0:
-; LE-NEXT: .save {r4, lr}
-; LE-NEXT: push {r4, lr}
-; LE-NEXT: .vsave {d8, d9}
-; LE-NEXT: vpush {d8, d9}
-; LE-NEXT: bl llrintl
-; LE-NEXT: ldr r12, [sp, #24]
-; LE-NEXT: add r3, sp, #28
-; LE-NEXT: mov r4, r1
-; LE-NEXT: vmov.32 d8[0], r0
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: mov r0, r12
-; LE-NEXT: bl llrintl
-; LE-NEXT: vmov.32 d9[0], r0
-; LE-NEXT: vmov.32 d8[1], r4
-; LE-NEXT: vmov.32 d9[1], r1
-; LE-NEXT: vorr q0, q4, q4
-; LE-NEXT: vpop {d8, d9}
-; LE-NEXT: pop {r4, pc}
-;
-; BE-LABEL: llrint_v2i64_v2f128:
-; BE: @ %bb.0:
-; BE-NEXT: .save {r4, lr}
-; BE-NEXT: push {r4, lr}
-; BE-NEXT: .vsave {d8}
-; BE-NEXT: vpush {d8}
-; BE-NEXT: bl llrintl
-; BE-NEXT: ldr r12, [sp, #16]
-; BE-NEXT: add r3, sp, #20
-; BE-NEXT: mov r4, r1
-; BE-NEXT: vmov.32 d8[0], r0
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: mov r0, r12
-; BE-NEXT: bl llrintl
-; BE-NEXT: vmov.32 d16[0], r0
-; BE-NEXT: vmov.32 d8[1], r4
-; BE-NEXT: vmov.32 d16[1], r1
-; BE-NEXT: vrev64.32 d0, d8
-; BE-NEXT: vrev64.32 d1, d16
-; BE-NEXT: vpop {d8}
-; BE-NEXT: pop {r4, pc}
- %a = call <2 x i64> @llvm.llrint.v2i64.v2f128(<2 x fp128> %x)
- ret <2 x i64> %a
-}
-declare <2 x i64> @llvm.llrint.v2i64.v2f128(<2 x fp128>)
-
-define <4 x i64> @llrint_v4i64_v4f128(<4 x fp128> %x) {
-; LE-LABEL: llrint_v4i64_v4f128:
-; LE: @ %bb.0:
-; LE-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, lr}
-; LE-NEXT: push {r4, r5, r6, r7, r8, r9, r10, lr}
-; LE-NEXT: .vsave {d8, d9, d10, d11}
-; LE-NEXT: vpush {d8, d9, d10, d11}
-; LE-NEXT: mov r9, r3
-; LE-NEXT: add r3, sp, #80
-; LE-NEXT: mov r6, r2
-; LE-NEXT: mov r7, r1
-; LE-NEXT: mov r4, r0
-; LE-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: ldr r5, [sp, #64]
-; LE-NEXT: add r3, sp, #68
-; LE-NEXT: mov r8, r1
-; LE-NEXT: vmov.32 d8[0], r0
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: mov r0, r5
-; LE-NEXT: bl llrintl
-; LE-NEXT: mov r5, r1
-; LE-NEXT: vmov.32 d11[0], r0
-; LE-NEXT: mov r0, r4
-; LE-NEXT: mov r1, r7
-; LE-NEXT: mov r2, r6
-; LE-NEXT: mov r3, r9
-; LE-NEXT: ldr r10, [sp, #96]
-; LE-NEXT: bl llrintl
-; LE-NEXT: add r3, sp, #100
-; LE-NEXT: mov r4, r1
-; LE-NEXT: vmov.32 d10[0], r0
-; LE-NEXT: mov r0, r10
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: vmov.32 d9[0], r0
-; LE-NEXT: vmov.32 d10[1], r4
-; LE-NEXT: vmov.32 d8[1], r8
-; LE-NEXT: vmov.32 d11[1], r5
-; LE-NEXT: vmov.32 d9[1], r1
-; LE-NEXT: vorr q0, q5, q5
-; LE-NEXT: vorr q1, q4, q4
-; LE-NEXT: vpop {d8, d9, d10, d11}
-; LE-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, pc}
-;
-; BE-LABEL: llrint_v4i64_v4f128:
-; BE: @ %bb.0:
-; BE-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, lr}
-; BE-NEXT: push {r4, r5, r6, r7, r8, r9, r10, lr}
-; BE-NEXT: .vsave {d8, d9, d10}
-; BE-NEXT: vpush {d8, d9, d10}
-; BE-NEXT: mov r9, r3
-; BE-NEXT: add r3, sp, #72
-; BE-NEXT: mov r6, r2
-; BE-NEXT: mov r7, r1
-; BE-NEXT: mov r4, r0
-; BE-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: ldr r5, [sp, #56]
-; BE-NEXT: add r3, sp, #60
-; BE-NEXT: mov r8, r1
-; BE-NEXT: vmov.32 d8[0], r0
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: mov r0, r5
-; BE-NEXT: bl llrintl
-; BE-NEXT: mov r5, r1
-; BE-NEXT: vmov.32 d9[0], r0
-; BE-NEXT: mov r0, r4
-; BE-NEXT: mov r1, r7
-; BE-NEXT: mov r2, r6
-; BE-NEXT: mov r3, r9
-; BE-NEXT: ldr r10, [sp, #88]
-; BE-NEXT: bl llrintl
-; BE-NEXT: add r3, sp, #92
-; BE-NEXT: mov r4, r1
-; BE-NEXT: vmov.32 d10[0], r0
-; BE-NEXT: mov r0, r10
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: vmov.32 d16[0], r0
-; BE-NEXT: vmov.32 d10[1], r4
-; BE-NEXT: vmov.32 d8[1], r8
-; BE-NEXT: vmov.32 d9[1], r5
-; BE-NEXT: vmov.32 d16[1], r1
-; BE-NEXT: vrev64.32 d0, d10
-; BE-NEXT: vrev64.32 d2, d8
-; BE-NEXT: vrev64.32 d1, d9
-; BE-NEXT: vrev64.32 d3, d16
-; BE-NEXT: vpop {d8, d9, d10}
-; BE-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, pc}
- %a = call <4 x i64> @llvm.llrint.v4i64.v4f128(<4 x fp128> %x)
- ret <4 x i64> %a
-}
-declare <4 x i64> @llvm.llrint.v4i64.v4f128(<4 x fp128>)
-
-define <8 x i64> @llrint_v8i64_v8f128(<8 x fp128> %x) {
-; LE-LABEL: llrint_v8i64_v8f128:
-; LE: @ %bb.0:
-; LE-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-NEXT: .pad #4
-; LE-NEXT: sub sp, sp, #4
-; LE-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-NEXT: .pad #16
-; LE-NEXT: sub sp, sp, #16
-; LE-NEXT: stmib sp, {r2, r3} @ 8-byte Folded Spill
-; LE-NEXT: add r3, sp, #200
-; LE-NEXT: mov r7, r1
-; LE-NEXT: mov r5, r0
-; LE-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: ldr r4, [sp, #184]
-; LE-NEXT: add r3, sp, #188
-; LE-NEXT: str r1, [sp, #12] @ 4-byte Spill
-; LE-NEXT: vmov.32 d8[0], r0
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: mov r0, r4
-; LE-NEXT: ldr r6, [sp, #168]
-; LE-NEXT: ldr r8, [sp, #152]
-; LE-NEXT: ldr r10, [sp, #136]
-; LE-NEXT: ldr r9, [sp, #120]
-; LE-NEXT: bl llrintl
-; LE-NEXT: add r3, sp, #172
-; LE-NEXT: mov r11, r1
-; LE-NEXT: vmov.32 d11[0], r0
-; LE-NEXT: mov r0, r6
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: add r3, sp, #156
-; LE-NEXT: mov r6, r1
-; LE-NEXT: vmov.32 d10[0], r0
-; LE-NEXT: mov r0, r8
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: add r3, sp, #140
-; LE-NEXT: mov r4, r1
-; LE-NEXT: vmov.32 d13[0], r0
-; LE-NEXT: mov r0, r10
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: add r3, sp, #124
-; LE-NEXT: mov r8, r1
-; LE-NEXT: vmov.32 d12[0], r0
-; LE-NEXT: mov r0, r9
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: mov r9, r1
-; LE-NEXT: vmov.32 d15[0], r0
-; LE-NEXT: mov r0, r5
-; LE-NEXT: mov r1, r7
-; LE-NEXT: ldmib sp, {r2, r3} @ 8-byte Folded Reload
-; LE-NEXT: ldr r10, [sp, #216]
-; LE-NEXT: bl llrintl
-; LE-NEXT: add r3, sp, #220
-; LE-NEXT: mov r5, r1
-; LE-NEXT: vmov.32 d14[0], r0
-; LE-NEXT: mov r0, r10
-; LE-NEXT: ldm r3, {r1, r2, r3}
-; LE-NEXT: bl llrintl
-; LE-NEXT: vmov.32 d9[0], r0
-; LE-NEXT: ldr r0, [sp, #12] @ 4-byte Reload
-; LE-NEXT: vmov.32 d14[1], r5
-; LE-NEXT: vmov.32 d12[1], r8
-; LE-NEXT: vmov.32 d10[1], r6
-; LE-NEXT: vmov.32 d8[1], r0
-; LE-NEXT: vmov.32 d15[1], r9
-; LE-NEXT: vmov.32 d13[1], r4
-; LE-NEXT: vorr q0, q7, q7
-; LE-NEXT: vmov.32 d11[1], r11
-; LE-NEXT: vorr q1, q6, q6
-; LE-NEXT: vmov.32 d9[1], r1
-; LE-NEXT: vorr q2, q5, q5
-; LE-NEXT: vorr q3, q4, q4
-; LE-NEXT: add sp, sp, #16
-; LE-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-NEXT: add sp, sp, #4
-; LE-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
-;
-; BE-LABEL: llrint_v8i64_v8f128:
-; BE: @ %bb.0:
-; BE-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-NEXT: .pad #4
-; BE-NEXT: sub sp, sp, #4
-; BE-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14}
-; BE-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14}
-; BE-NEXT: .pad #16
-; BE-NEXT: sub sp, sp, #16
-; BE-NEXT: stmib sp, {r2, r3} @ 8-byte Folded Spill
-; BE-NEXT: add r3, sp, #192
-; BE-NEXT: mov r7, r1
-; BE-NEXT: mov r5, r0
-; BE-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: ldr r4, [sp, #176]
-; BE-NEXT: add r3, sp, #180
-; BE-NEXT: str r1, [sp, #12] @ 4-byte Spill
-; BE-NEXT: vmov.32 d8[0], r0
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: mov r0, r4
-; BE-NEXT: ldr r6, [sp, #160]
-; BE-NEXT: ldr r8, [sp, #144]
-; BE-NEXT: ldr r10, [sp, #128]
-; BE-NEXT: ldr r9, [sp, #112]
-; BE-NEXT: bl llrintl
-; BE-NEXT: add r3, sp, #164
-; BE-NEXT: mov r11, r1
-; BE-NEXT: vmov.32 d9[0], r0
-; BE-NEXT: mov r0, r6
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: add r3, sp, #148
-; BE-NEXT: mov r6, r1
-; BE-NEXT: vmov.32 d10[0], r0
-; BE-NEXT: mov r0, r8
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: add r3, sp, #132
-; BE-NEXT: mov r4, r1
-; BE-NEXT: vmov.32 d11[0], r0
-; BE-NEXT: mov r0, r10
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: add r3, sp, #116
-; BE-NEXT: mov r8, r1
-; BE-NEXT: vmov.32 d12[0], r0
-; BE-NEXT: mov r0, r9
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: mov r9, r1
-; BE-NEXT: vmov.32 d13[0], r0
-; BE-NEXT: mov r0, r5
-; BE-NEXT: mov r1, r7
-; BE-NEXT: ldmib sp, {r2, r3} @ 8-byte Folded Reload
-; BE-NEXT: ldr r10, [sp, #208]
-; BE-NEXT: bl llrintl
-; BE-NEXT: add r3, sp, #212
-; BE-NEXT: mov r5, r1
-; BE-NEXT: vmov.32 d14[0], r0
-; BE-NEXT: mov r0, r10
-; BE-NEXT: ldm r3, {r1, r2, r3}
-; BE-NEXT: bl llrintl
-; BE-NEXT: vmov.32 d16[0], r0
-; BE-NEXT: ldr r0, [sp, #12] @ 4-byte Reload
-; BE-NEXT: vmov.32 d14[1], r5
-; BE-NEXT: vmov.32 d12[1], r8
-; BE-NEXT: vmov.32 d10[1], r6
-; BE-NEXT: vmov.32 d8[1], r0
-; BE-NEXT: vmov.32 d13[1], r9
-; BE-NEXT: vmov.32 d11[1], r4
-; BE-NEXT: vmov.32 d9[1], r11
-; BE-NEXT: vmov.32 d16[1], r1
-; BE-NEXT: vrev64.32 d0, d14
-; BE-NEXT: vrev64.32 d2, d12
-; BE-NEXT: vrev64.32 d4, d10
-; BE-NEXT: vrev64.32 d6, d8
-; BE-NEXT: vrev64.32 d1, d13
-; BE-NEXT: vrev64.32 d3, d11
-; BE-NEXT: vrev64.32 d5, d9
-; BE-NEXT: vrev64.32 d7, d16
-; BE-NEXT: add sp, sp, #16
-; BE-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14}
-; BE-NEXT: add sp, sp, #4
-; BE-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
- %a = call <8 x i64> @llvm.llrint.v8i64.v8f128(<8 x fp128> %x)
- ret <8 x i64> %a
-}
-declare <8 x i64> @llvm.llrint.v8i64.v8f128(<8 x fp128>)
diff --git a/llvm/test/CodeGen/ARM/vector-lrint.ll b/llvm/test/CodeGen/ARM/vector-lrint.ll
index bb0a84067f18a..fc76aeaa03f5b 100644
--- a/llvm/test/CodeGen/ARM/vector-lrint.ll
+++ b/llvm/test/CodeGen/ARM/vector-lrint.ll
@@ -3289,1208 +3289,3 @@ define <16 x iXLen> @lrint_v16f64(<16 x double> %x) {
%a = call <16 x iXLen> @llvm.lrint.v16iXLen.v16f64(<16 x double> %x)
ret <16 x iXLen> %a
}
-
-define <1 x iXLen> @lrint_v1fp128(<1 x fp128> %x) {
-; LE-I32-LABEL: lrint_v1fp128:
-; LE-I32: @ %bb.0:
-; LE-I32-NEXT: .save {r11, lr}
-; LE-I32-NEXT: push {r11, lr}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: pop {r11, pc}
-;
-; LE-I64-LABEL: lrint_v1fp128:
-; LE-I64: @ %bb.0:
-; LE-I64-NEXT: .save {r11, lr}
-; LE-I64-NEXT: push {r11, lr}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: vmov.32 d0[0], r0
-; LE-I64-NEXT: vmov.32 d0[1], r1
-; LE-I64-NEXT: pop {r11, pc}
-;
-; BE-I32-LABEL: lrint_v1fp128:
-; BE-I32: @ %bb.0:
-; BE-I32-NEXT: .save {r11, lr}
-; BE-I32-NEXT: push {r11, lr}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: pop {r11, pc}
-;
-; BE-I64-LABEL: lrint_v1fp128:
-; BE-I64: @ %bb.0:
-; BE-I64-NEXT: .save {r11, lr}
-; BE-I64-NEXT: push {r11, lr}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: vmov.32 d16[0], r0
-; BE-I64-NEXT: vmov.32 d16[1], r1
-; BE-I64-NEXT: vrev64.32 d0, d16
-; BE-I64-NEXT: pop {r11, pc}
- %a = call <1 x iXLen> @llvm.lrint.v1iXLen.v1fp128(<1 x fp128> %x)
- ret <1 x iXLen> %a
-}
-
-define <2 x iXLen> @lrint_v2fp128(<2 x fp128> %x) {
-; LE-I32-LABEL: lrint_v2fp128:
-; LE-I32: @ %bb.0:
-; LE-I32-NEXT: .save {r4, r5, r6, r7, r8, lr}
-; LE-I32-NEXT: push {r4, r5, r6, r7, r8, lr}
-; LE-I32-NEXT: mov r8, r3
-; LE-I32-NEXT: add r3, sp, #24
-; LE-I32-NEXT: mov r5, r2
-; LE-I32-NEXT: mov r6, r1
-; LE-I32-NEXT: mov r7, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: mov r4, r0
-; LE-I32-NEXT: mov r0, r7
-; LE-I32-NEXT: mov r1, r6
-; LE-I32-NEXT: mov r2, r5
-; LE-I32-NEXT: mov r3, r8
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d0[0], r0
-; LE-I32-NEXT: vmov.32 d0[1], r4
-; LE-I32-NEXT: pop {r4, r5, r6, r7, r8, pc}
-;
-; LE-I64-LABEL: lrint_v2fp128:
-; LE-I64: @ %bb.0:
-; LE-I64-NEXT: .save {r4, lr}
-; LE-I64-NEXT: push {r4, lr}
-; LE-I64-NEXT: .vsave {d8, d9}
-; LE-I64-NEXT: vpush {d8, d9}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: ldr r12, [sp, #24]
-; LE-I64-NEXT: add r3, sp, #28
-; LE-I64-NEXT: mov r4, r1
-; LE-I64-NEXT: vmov.32 d8[0], r0
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: mov r0, r12
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: vmov.32 d9[0], r0
-; LE-I64-NEXT: vmov.32 d8[1], r4
-; LE-I64-NEXT: vmov.32 d9[1], r1
-; LE-I64-NEXT: vorr q0, q4, q4
-; LE-I64-NEXT: vpop {d8, d9}
-; LE-I64-NEXT: pop {r4, pc}
-;
-; BE-I32-LABEL: lrint_v2fp128:
-; BE-I32: @ %bb.0:
-; BE-I32-NEXT: .save {r4, r5, r6, r7, r8, lr}
-; BE-I32-NEXT: push {r4, r5, r6, r7, r8, lr}
-; BE-I32-NEXT: mov r8, r3
-; BE-I32-NEXT: add r3, sp, #24
-; BE-I32-NEXT: mov r5, r2
-; BE-I32-NEXT: mov r6, r1
-; BE-I32-NEXT: mov r7, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: mov r4, r0
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: mov r1, r6
-; BE-I32-NEXT: mov r2, r5
-; BE-I32-NEXT: mov r3, r8
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d16[0], r0
-; BE-I32-NEXT: vmov.32 d16[1], r4
-; BE-I32-NEXT: vrev64.32 d0, d16
-; BE-I32-NEXT: pop {r4, r5, r6, r7, r8, pc}
-;
-; BE-I64-LABEL: lrint_v2fp128:
-; BE-I64: @ %bb.0:
-; BE-I64-NEXT: .save {r4, lr}
-; BE-I64-NEXT: push {r4, lr}
-; BE-I64-NEXT: .vsave {d8}
-; BE-I64-NEXT: vpush {d8}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r12, [sp, #16]
-; BE-I64-NEXT: add r3, sp, #20
-; BE-I64-NEXT: mov r4, r1
-; BE-I64-NEXT: vmov.32 d8[0], r0
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: mov r0, r12
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: vmov.32 d16[0], r0
-; BE-I64-NEXT: vmov.32 d8[1], r4
-; BE-I64-NEXT: vmov.32 d16[1], r1
-; BE-I64-NEXT: vrev64.32 d0, d8
-; BE-I64-NEXT: vrev64.32 d1, d16
-; BE-I64-NEXT: vpop {d8}
-; BE-I64-NEXT: pop {r4, pc}
- %a = call <2 x iXLen> @llvm.lrint.v2iXLen.v2fp128(<2 x fp128> %x)
- ret <2 x iXLen> %a
-}
-
-define <4 x iXLen> @lrint_v4fp128(<4 x fp128> %x) {
-; LE-I32-LABEL: lrint_v4fp128:
-; LE-I32: @ %bb.0:
-; LE-I32-NEXT: .save {r4, r5, r6, r7, r8, lr}
-; LE-I32-NEXT: push {r4, r5, r6, r7, r8, lr}
-; LE-I32-NEXT: .vsave {d8, d9}
-; LE-I32-NEXT: vpush {d8, d9}
-; LE-I32-NEXT: mov r8, r3
-; LE-I32-NEXT: add r3, sp, #56
-; LE-I32-NEXT: mov r5, r2
-; LE-I32-NEXT: mov r6, r1
-; LE-I32-NEXT: mov r7, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #44
-; LE-I32-NEXT: ldr r12, [sp, #40]
-; LE-I32-NEXT: vmov.32 d9[0], r0
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: mov r0, r12
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: mov r4, r0
-; LE-I32-NEXT: mov r0, r7
-; LE-I32-NEXT: mov r1, r6
-; LE-I32-NEXT: mov r2, r5
-; LE-I32-NEXT: mov r3, r8
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #76
-; LE-I32-NEXT: ldr r7, [sp, #72]
-; LE-I32-NEXT: vmov.32 d8[0], r0
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: mov r0, r7
-; LE-I32-NEXT: vmov.32 d8[1], r4
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d9[1], r0
-; LE-I32-NEXT: vorr q0, q4, q4
-; LE-I32-NEXT: vpop {d8, d9}
-; LE-I32-NEXT: pop {r4, r5, r6, r7, r8, pc}
-;
-; LE-I64-LABEL: lrint_v4fp128:
-; LE-I64: @ %bb.0:
-; LE-I64-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, lr}
-; LE-I64-NEXT: push {r4, r5, r6, r7, r8, r9, r10, lr}
-; LE-I64-NEXT: .vsave {d8, d9, d10, d11}
-; LE-I64-NEXT: vpush {d8, d9, d10, d11}
-; LE-I64-NEXT: mov r9, r3
-; LE-I64-NEXT: add r3, sp, #80
-; LE-I64-NEXT: mov r6, r2
-; LE-I64-NEXT: mov r7, r1
-; LE-I64-NEXT: mov r4, r0
-; LE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: ldr r5, [sp, #64]
-; LE-I64-NEXT: add r3, sp, #68
-; LE-I64-NEXT: mov r8, r1
-; LE-I64-NEXT: vmov.32 d8[0], r0
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: mov r0, r5
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: mov r5, r1
-; LE-I64-NEXT: vmov.32 d11[0], r0
-; LE-I64-NEXT: mov r0, r4
-; LE-I64-NEXT: mov r1, r7
-; LE-I64-NEXT: mov r2, r6
-; LE-I64-NEXT: mov r3, r9
-; LE-I64-NEXT: ldr r10, [sp, #96]
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #100
-; LE-I64-NEXT: mov r4, r1
-; LE-I64-NEXT: vmov.32 d10[0], r0
-; LE-I64-NEXT: mov r0, r10
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: vmov.32 d9[0], r0
-; LE-I64-NEXT: vmov.32 d10[1], r4
-; LE-I64-NEXT: vmov.32 d8[1], r8
-; LE-I64-NEXT: vmov.32 d11[1], r5
-; LE-I64-NEXT: vmov.32 d9[1], r1
-; LE-I64-NEXT: vorr q0, q5, q5
-; LE-I64-NEXT: vorr q1, q4, q4
-; LE-I64-NEXT: vpop {d8, d9, d10, d11}
-; LE-I64-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, pc}
-;
-; BE-I32-LABEL: lrint_v4fp128:
-; BE-I32: @ %bb.0:
-; BE-I32-NEXT: .save {r4, r5, r6, r7, r8, lr}
-; BE-I32-NEXT: push {r4, r5, r6, r7, r8, lr}
-; BE-I32-NEXT: .vsave {d8, d9}
-; BE-I32-NEXT: vpush {d8, d9}
-; BE-I32-NEXT: mov r8, r3
-; BE-I32-NEXT: add r3, sp, #56
-; BE-I32-NEXT: mov r5, r2
-; BE-I32-NEXT: mov r6, r1
-; BE-I32-NEXT: mov r7, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #44
-; BE-I32-NEXT: ldr r12, [sp, #40]
-; BE-I32-NEXT: vmov.32 d9[0], r0
-; BE-I32-NEXT: ldm r3, {r1, r2, r3}
-; BE-I32-NEXT: mov r0, r12
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: mov r4, r0
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: mov r1, r6
-; BE-I32-NEXT: mov r2, r5
-; BE-I32-NEXT: mov r3, r8
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #76
-; BE-I32-NEXT: ldr r7, [sp, #72]
-; BE-I32-NEXT: vmov.32 d8[0], r0
-; BE-I32-NEXT: ldm r3, {r1, r2, r3}
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: vmov.32 d8[1], r4
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d9[1], r0
-; BE-I32-NEXT: vrev64.32 q0, q4
-; BE-I32-NEXT: vpop {d8, d9}
-; BE-I32-NEXT: pop {r4, r5, r6, r7, r8, pc}
-;
-; BE-I64-LABEL: lrint_v4fp128:
-; BE-I64: @ %bb.0:
-; BE-I64-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, lr}
-; BE-I64-NEXT: push {r4, r5, r6, r7, r8, r9, r10, lr}
-; BE-I64-NEXT: .vsave {d8, d9, d10}
-; BE-I64-NEXT: vpush {d8, d9, d10}
-; BE-I64-NEXT: mov r9, r3
-; BE-I64-NEXT: add r3, sp, #72
-; BE-I64-NEXT: mov r6, r2
-; BE-I64-NEXT: mov r7, r1
-; BE-I64-NEXT: mov r4, r0
-; BE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r5, [sp, #56]
-; BE-I64-NEXT: add r3, sp, #60
-; BE-I64-NEXT: mov r8, r1
-; BE-I64-NEXT: vmov.32 d8[0], r0
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: mov r0, r5
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: mov r5, r1
-; BE-I64-NEXT: vmov.32 d9[0], r0
-; BE-I64-NEXT: mov r0, r4
-; BE-I64-NEXT: mov r1, r7
-; BE-I64-NEXT: mov r2, r6
-; BE-I64-NEXT: mov r3, r9
-; BE-I64-NEXT: ldr r10, [sp, #88]
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #92
-; BE-I64-NEXT: mov r4, r1
-; BE-I64-NEXT: vmov.32 d10[0], r0
-; BE-I64-NEXT: mov r0, r10
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: vmov.32 d16[0], r0
-; BE-I64-NEXT: vmov.32 d10[1], r4
-; BE-I64-NEXT: vmov.32 d8[1], r8
-; BE-I64-NEXT: vmov.32 d9[1], r5
-; BE-I64-NEXT: vmov.32 d16[1], r1
-; BE-I64-NEXT: vrev64.32 d0, d10
-; BE-I64-NEXT: vrev64.32 d2, d8
-; BE-I64-NEXT: vrev64.32 d1, d9
-; BE-I64-NEXT: vrev64.32 d3, d16
-; BE-I64-NEXT: vpop {d8, d9, d10}
-; BE-I64-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, pc}
- %a = call <4 x iXLen> @llvm.lrint.v4iXLen.v4fp128(<4 x fp128> %x)
- ret <4 x iXLen> %a
-}
-
-define <8 x iXLen> @lrint_v8fp128(<8 x fp128> %x) {
-; LE-I32-LABEL: lrint_v8fp128:
-; LE-I32: @ %bb.0:
-; LE-I32-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, lr}
-; LE-I32-NEXT: push {r4, r5, r6, r7, r8, r9, r10, lr}
-; LE-I32-NEXT: .vsave {d8, d9, d10, d11}
-; LE-I32-NEXT: vpush {d8, d9, d10, d11}
-; LE-I32-NEXT: mov r5, r3
-; LE-I32-NEXT: add r3, sp, #144
-; LE-I32-NEXT: mov r6, r2
-; LE-I32-NEXT: mov r7, r1
-; LE-I32-NEXT: mov r4, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #84
-; LE-I32-NEXT: ldr r12, [sp, #80]
-; LE-I32-NEXT: vmov.32 d9[0], r0
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: mov r0, r12
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d11[0], r0
-; LE-I32-NEXT: mov r0, r4
-; LE-I32-NEXT: mov r1, r7
-; LE-I32-NEXT: mov r2, r6
-; LE-I32-NEXT: mov r3, r5
-; LE-I32-NEXT: ldr r8, [sp, #128]
-; LE-I32-NEXT: ldr r9, [sp, #96]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r4, [sp, #64]
-; LE-I32-NEXT: vmov.32 d10[0], r0
-; LE-I32-NEXT: ldr r1, [sp, #68]
-; LE-I32-NEXT: ldr r2, [sp, #72]
-; LE-I32-NEXT: ldr r3, [sp, #76]
-; LE-I32-NEXT: mov r0, r4
-; LE-I32-NEXT: ldr r5, [sp, #100]
-; LE-I32-NEXT: ldr r6, [sp, #104]
-; LE-I32-NEXT: ldr r10, [sp, #132]
-; LE-I32-NEXT: ldr r7, [sp, #136]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r3, [sp, #108]
-; LE-I32-NEXT: vmov.32 d10[1], r0
-; LE-I32-NEXT: mov r0, r9
-; LE-I32-NEXT: mov r1, r5
-; LE-I32-NEXT: mov r2, r6
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r3, [sp, #140]
-; LE-I32-NEXT: vmov.32 d11[1], r0
-; LE-I32-NEXT: mov r0, r8
-; LE-I32-NEXT: mov r1, r10
-; LE-I32-NEXT: mov r2, r7
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #112
-; LE-I32-NEXT: mov r4, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #164
-; LE-I32-NEXT: ldr r7, [sp, #160]
-; LE-I32-NEXT: vmov.32 d8[0], r0
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: mov r0, r7
-; LE-I32-NEXT: vmov.32 d8[1], r4
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d9[1], r0
-; LE-I32-NEXT: vorr q0, q5, q5
-; LE-I32-NEXT: vorr q1, q4, q4
-; LE-I32-NEXT: vpop {d8, d9, d10, d11}
-; LE-I32-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, pc}
-;
-; LE-I64-LABEL: lrint_v8fp128:
-; LE-I64: @ %bb.0:
-; LE-I64-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-I64-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-I64-NEXT: .pad #4
-; LE-I64-NEXT: sub sp, sp, #4
-; LE-I64-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I64-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I64-NEXT: .pad #16
-; LE-I64-NEXT: sub sp, sp, #16
-; LE-I64-NEXT: stmib sp, {r2, r3} @ 8-byte Folded Spill
-; LE-I64-NEXT: add r3, sp, #200
-; LE-I64-NEXT: mov r7, r1
-; LE-I64-NEXT: mov r5, r0
-; LE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: ldr r4, [sp, #184]
-; LE-I64-NEXT: add r3, sp, #188
-; LE-I64-NEXT: str r1, [sp, #12] @ 4-byte Spill
-; LE-I64-NEXT: vmov.32 d8[0], r0
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: mov r0, r4
-; LE-I64-NEXT: ldr r6, [sp, #168]
-; LE-I64-NEXT: ldr r8, [sp, #152]
-; LE-I64-NEXT: ldr r10, [sp, #136]
-; LE-I64-NEXT: ldr r9, [sp, #120]
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #172
-; LE-I64-NEXT: mov r11, r1
-; LE-I64-NEXT: vmov.32 d11[0], r0
-; LE-I64-NEXT: mov r0, r6
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #156
-; LE-I64-NEXT: mov r6, r1
-; LE-I64-NEXT: vmov.32 d10[0], r0
-; LE-I64-NEXT: mov r0, r8
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #140
-; LE-I64-NEXT: mov r4, r1
-; LE-I64-NEXT: vmov.32 d13[0], r0
-; LE-I64-NEXT: mov r0, r10
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #124
-; LE-I64-NEXT: mov r8, r1
-; LE-I64-NEXT: vmov.32 d12[0], r0
-; LE-I64-NEXT: mov r0, r9
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: mov r9, r1
-; LE-I64-NEXT: vmov.32 d15[0], r0
-; LE-I64-NEXT: mov r0, r5
-; LE-I64-NEXT: mov r1, r7
-; LE-I64-NEXT: ldmib sp, {r2, r3} @ 8-byte Folded Reload
-; LE-I64-NEXT: ldr r10, [sp, #216]
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #220
-; LE-I64-NEXT: mov r5, r1
-; LE-I64-NEXT: vmov.32 d14[0], r0
-; LE-I64-NEXT: mov r0, r10
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: vmov.32 d9[0], r0
-; LE-I64-NEXT: ldr r0, [sp, #12] @ 4-byte Reload
-; LE-I64-NEXT: vmov.32 d14[1], r5
-; LE-I64-NEXT: vmov.32 d12[1], r8
-; LE-I64-NEXT: vmov.32 d10[1], r6
-; LE-I64-NEXT: vmov.32 d8[1], r0
-; LE-I64-NEXT: vmov.32 d15[1], r9
-; LE-I64-NEXT: vmov.32 d13[1], r4
-; LE-I64-NEXT: vorr q0, q7, q7
-; LE-I64-NEXT: vmov.32 d11[1], r11
-; LE-I64-NEXT: vorr q1, q6, q6
-; LE-I64-NEXT: vmov.32 d9[1], r1
-; LE-I64-NEXT: vorr q2, q5, q5
-; LE-I64-NEXT: vorr q3, q4, q4
-; LE-I64-NEXT: add sp, sp, #16
-; LE-I64-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I64-NEXT: add sp, sp, #4
-; LE-I64-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
-;
-; BE-I32-LABEL: lrint_v8fp128:
-; BE-I32: @ %bb.0:
-; BE-I32-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, lr}
-; BE-I32-NEXT: push {r4, r5, r6, r7, r8, r9, r10, lr}
-; BE-I32-NEXT: .vsave {d8, d9, d10, d11}
-; BE-I32-NEXT: vpush {d8, d9, d10, d11}
-; BE-I32-NEXT: mov r6, r3
-; BE-I32-NEXT: add r3, sp, #144
-; BE-I32-NEXT: mov r7, r2
-; BE-I32-NEXT: mov r4, r1
-; BE-I32-NEXT: mov r5, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d9[0], r0
-; BE-I32-NEXT: mov r0, r5
-; BE-I32-NEXT: mov r1, r4
-; BE-I32-NEXT: mov r2, r7
-; BE-I32-NEXT: mov r3, r6
-; BE-I32-NEXT: ldr r8, [sp, #96]
-; BE-I32-NEXT: ldr r9, [sp, #64]
-; BE-I32-NEXT: ldr r10, [sp, #112]
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #116
-; BE-I32-NEXT: vmov.32 d10[0], r0
-; BE-I32-NEXT: mov r0, r10
-; BE-I32-NEXT: ldm r3, {r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r6, [sp, #128]
-; BE-I32-NEXT: vmov.32 d8[0], r0
-; BE-I32-NEXT: ldr r1, [sp, #132]
-; BE-I32-NEXT: ldr r2, [sp, #136]
-; BE-I32-NEXT: ldr r3, [sp, #140]
-; BE-I32-NEXT: mov r0, r6
-; BE-I32-NEXT: ldr r4, [sp, #68]
-; BE-I32-NEXT: ldr r5, [sp, #72]
-; BE-I32-NEXT: ldr r10, [sp, #100]
-; BE-I32-NEXT: ldr r7, [sp, #104]
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r3, [sp, #76]
-; BE-I32-NEXT: vmov.32 d8[1], r0
-; BE-I32-NEXT: mov r0, r9
-; BE-I32-NEXT: mov r1, r4
-; BE-I32-NEXT: mov r2, r5
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r3, [sp, #108]
-; BE-I32-NEXT: vmov.32 d10[1], r0
-; BE-I32-NEXT: mov r0, r8
-; BE-I32-NEXT: mov r1, r10
-; BE-I32-NEXT: mov r2, r7
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #80
-; BE-I32-NEXT: mov r4, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #164
-; BE-I32-NEXT: ldr r7, [sp, #160]
-; BE-I32-NEXT: vmov.32 d11[0], r0
-; BE-I32-NEXT: ldm r3, {r1, r2, r3}
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: vmov.32 d11[1], r4
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d9[1], r0
-; BE-I32-NEXT: vrev64.32 q0, q5
-; BE-I32-NEXT: vrev64.32 q1, q4
-; BE-I32-NEXT: vpop {d8, d9, d10, d11}
-; BE-I32-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, pc}
-;
-; BE-I64-LABEL: lrint_v8fp128:
-; BE-I64: @ %bb.0:
-; BE-I64-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-I64-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-I64-NEXT: .pad #4
-; BE-I64-NEXT: sub sp, sp, #4
-; BE-I64-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14}
-; BE-I64-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14}
-; BE-I64-NEXT: .pad #16
-; BE-I64-NEXT: sub sp, sp, #16
-; BE-I64-NEXT: stmib sp, {r2, r3} @ 8-byte Folded Spill
-; BE-I64-NEXT: add r3, sp, #192
-; BE-I64-NEXT: mov r7, r1
-; BE-I64-NEXT: mov r5, r0
-; BE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r4, [sp, #176]
-; BE-I64-NEXT: add r3, sp, #180
-; BE-I64-NEXT: str r1, [sp, #12] @ 4-byte Spill
-; BE-I64-NEXT: vmov.32 d8[0], r0
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: mov r0, r4
-; BE-I64-NEXT: ldr r6, [sp, #160]
-; BE-I64-NEXT: ldr r8, [sp, #144]
-; BE-I64-NEXT: ldr r10, [sp, #128]
-; BE-I64-NEXT: ldr r9, [sp, #112]
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #164
-; BE-I64-NEXT: mov r11, r1
-; BE-I64-NEXT: vmov.32 d9[0], r0
-; BE-I64-NEXT: mov r0, r6
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #148
-; BE-I64-NEXT: mov r6, r1
-; BE-I64-NEXT: vmov.32 d10[0], r0
-; BE-I64-NEXT: mov r0, r8
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #132
-; BE-I64-NEXT: mov r4, r1
-; BE-I64-NEXT: vmov.32 d11[0], r0
-; BE-I64-NEXT: mov r0, r10
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #116
-; BE-I64-NEXT: mov r8, r1
-; BE-I64-NEXT: vmov.32 d12[0], r0
-; BE-I64-NEXT: mov r0, r9
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: mov r9, r1
-; BE-I64-NEXT: vmov.32 d13[0], r0
-; BE-I64-NEXT: mov r0, r5
-; BE-I64-NEXT: mov r1, r7
-; BE-I64-NEXT: ldmib sp, {r2, r3} @ 8-byte Folded Reload
-; BE-I64-NEXT: ldr r10, [sp, #208]
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #212
-; BE-I64-NEXT: mov r5, r1
-; BE-I64-NEXT: vmov.32 d14[0], r0
-; BE-I64-NEXT: mov r0, r10
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: vmov.32 d16[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #12] @ 4-byte Reload
-; BE-I64-NEXT: vmov.32 d14[1], r5
-; BE-I64-NEXT: vmov.32 d12[1], r8
-; BE-I64-NEXT: vmov.32 d10[1], r6
-; BE-I64-NEXT: vmov.32 d8[1], r0
-; BE-I64-NEXT: vmov.32 d13[1], r9
-; BE-I64-NEXT: vmov.32 d11[1], r4
-; BE-I64-NEXT: vmov.32 d9[1], r11
-; BE-I64-NEXT: vmov.32 d16[1], r1
-; BE-I64-NEXT: vrev64.32 d0, d14
-; BE-I64-NEXT: vrev64.32 d2, d12
-; BE-I64-NEXT: vrev64.32 d4, d10
-; BE-I64-NEXT: vrev64.32 d6, d8
-; BE-I64-NEXT: vrev64.32 d1, d13
-; BE-I64-NEXT: vrev64.32 d3, d11
-; BE-I64-NEXT: vrev64.32 d5, d9
-; BE-I64-NEXT: vrev64.32 d7, d16
-; BE-I64-NEXT: add sp, sp, #16
-; BE-I64-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14}
-; BE-I64-NEXT: add sp, sp, #4
-; BE-I64-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
- %a = call <8 x iXLen> @llvm.lrint.v8iXLen.v8fp128(<8 x fp128> %x)
- ret <8 x iXLen> %a
-}
-
-define <16 x iXLen> @lrint_v16fp128(<16 x fp128> %x) {
-; LE-I32-LABEL: lrint_v16fp128:
-; LE-I32: @ %bb.0:
-; LE-I32-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-I32-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-I32-NEXT: .pad #4
-; LE-I32-NEXT: sub sp, sp, #4
-; LE-I32-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I32-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I32-NEXT: mov r8, r3
-; LE-I32-NEXT: add r3, sp, #312
-; LE-I32-NEXT: mov r7, r2
-; LE-I32-NEXT: mov r4, r1
-; LE-I32-NEXT: mov r5, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r6, [sp, #248]
-; LE-I32-NEXT: vmov.32 d9[0], r0
-; LE-I32-NEXT: ldr r1, [sp, #252]
-; LE-I32-NEXT: ldr r2, [sp, #256]
-; LE-I32-NEXT: ldr r3, [sp, #260]
-; LE-I32-NEXT: mov r0, r6
-; LE-I32-NEXT: ldr r11, [sp, #184]
-; LE-I32-NEXT: ldr r10, [sp, #152]
-; LE-I32-NEXT: ldr r9, [sp, #200]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #188
-; LE-I32-NEXT: vmov.32 d11[0], r0
-; LE-I32-NEXT: mov r0, r11
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #156
-; LE-I32-NEXT: vmov.32 d13[0], r0
-; LE-I32-NEXT: mov r0, r10
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d12[0], r0
-; LE-I32-NEXT: mov r0, r5
-; LE-I32-NEXT: mov r1, r4
-; LE-I32-NEXT: mov r2, r7
-; LE-I32-NEXT: mov r3, r8
-; LE-I32-NEXT: ldr r10, [sp, #136]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r7, [sp, #104]
-; LE-I32-NEXT: vmov.32 d14[0], r0
-; LE-I32-NEXT: ldr r1, [sp, #108]
-; LE-I32-NEXT: ldr r2, [sp, #112]
-; LE-I32-NEXT: ldr r3, [sp, #116]
-; LE-I32-NEXT: mov r0, r7
-; LE-I32-NEXT: ldr r4, [sp, #140]
-; LE-I32-NEXT: ldr r5, [sp, #144]
-; LE-I32-NEXT: ldr r8, [sp, #296]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r3, [sp, #148]
-; LE-I32-NEXT: vmov.32 d14[1], r0
-; LE-I32-NEXT: mov r0, r10
-; LE-I32-NEXT: mov r1, r4
-; LE-I32-NEXT: mov r2, r5
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #120
-; LE-I32-NEXT: mov r4, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r6, [sp, #168]
-; LE-I32-NEXT: vmov.32 d15[0], r0
-; LE-I32-NEXT: ldr r1, [sp, #172]
-; LE-I32-NEXT: ldr r2, [sp, #176]
-; LE-I32-NEXT: ldr r3, [sp, #180]
-; LE-I32-NEXT: mov r0, r6
-; LE-I32-NEXT: ldr r5, [sp, #204]
-; LE-I32-NEXT: vmov.32 d15[1], r4
-; LE-I32-NEXT: ldr r7, [sp, #208]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r3, [sp, #212]
-; LE-I32-NEXT: vmov.32 d12[1], r0
-; LE-I32-NEXT: mov r0, r9
-; LE-I32-NEXT: mov r1, r5
-; LE-I32-NEXT: mov r2, r7
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #216
-; LE-I32-NEXT: mov r5, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r4, [sp, #232]
-; LE-I32-NEXT: vmov.32 d10[0], r0
-; LE-I32-NEXT: ldr r1, [sp, #236]
-; LE-I32-NEXT: ldr r2, [sp, #240]
-; LE-I32-NEXT: vmov.32 d13[1], r5
-; LE-I32-NEXT: ldr r3, [sp, #244]
-; LE-I32-NEXT: mov r0, r4
-; LE-I32-NEXT: ldr r6, [sp, #268]
-; LE-I32-NEXT: ldr r7, [sp, #272]
-; LE-I32-NEXT: ldr r9, [sp, #300]
-; LE-I32-NEXT: ldr r5, [sp, #304]
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d10[1], r0
-; LE-I32-NEXT: ldr r3, [sp, #276]
-; LE-I32-NEXT: ldr r0, [sp, #264]
-; LE-I32-NEXT: mov r1, r6
-; LE-I32-NEXT: mov r2, r7
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: ldr r3, [sp, #308]
-; LE-I32-NEXT: vmov.32 d11[1], r0
-; LE-I32-NEXT: mov r0, r8
-; LE-I32-NEXT: mov r1, r9
-; LE-I32-NEXT: mov r2, r5
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #280
-; LE-I32-NEXT: mov r4, r0
-; LE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: add r3, sp, #332
-; LE-I32-NEXT: ldr r7, [sp, #328]
-; LE-I32-NEXT: vmov.32 d8[0], r0
-; LE-I32-NEXT: ldm r3, {r1, r2, r3}
-; LE-I32-NEXT: mov r0, r7
-; LE-I32-NEXT: vmov.32 d8[1], r4
-; LE-I32-NEXT: bl lrintl
-; LE-I32-NEXT: vmov.32 d9[1], r0
-; LE-I32-NEXT: vorr q0, q7, q7
-; LE-I32-NEXT: vorr q1, q6, q6
-; LE-I32-NEXT: vorr q2, q5, q5
-; LE-I32-NEXT: vorr q3, q4, q4
-; LE-I32-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I32-NEXT: add sp, sp, #4
-; LE-I32-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
-;
-; LE-I64-LABEL: lrint_v16fp128:
-; LE-I64: @ %bb.0:
-; LE-I64-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-I64-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; LE-I64-NEXT: .pad #4
-; LE-I64-NEXT: sub sp, sp, #4
-; LE-I64-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I64-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I64-NEXT: .pad #80
-; LE-I64-NEXT: sub sp, sp, #80
-; LE-I64-NEXT: mov r6, r3
-; LE-I64-NEXT: add r3, sp, #400
-; LE-I64-NEXT: mov r7, r2
-; LE-I64-NEXT: mov r4, r0
-; LE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r8, sp, #184
-; LE-I64-NEXT: mov r10, r1
-; LE-I64-NEXT: vmov.32 d8[0], r0
-; LE-I64-NEXT: mov r0, r7
-; LE-I64-NEXT: ldm r8, {r2, r3, r8}
-; LE-I64-NEXT: mov r1, r6
-; LE-I64-NEXT: ldr r5, [sp, #256]
-; LE-I64-NEXT: ldr r9, [sp, #240]
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #260
-; LE-I64-NEXT: mov r7, r1
-; LE-I64-NEXT: vmov.32 d10[0], r0
-; LE-I64-NEXT: mov r0, r5
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #244
-; LE-I64-NEXT: mov r6, r1
-; LE-I64-NEXT: vmov.32 d13[0], r0
-; LE-I64-NEXT: mov r0, r9
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #196
-; LE-I64-NEXT: mov r5, r1
-; LE-I64-NEXT: vmov.32 d12[0], r0
-; LE-I64-NEXT: mov r0, r8
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: vmov.32 d11[0], r0
-; LE-I64-NEXT: mov r9, r1
-; LE-I64-NEXT: ldr r0, [sp, #304]
-; LE-I64-NEXT: add lr, sp, #64
-; LE-I64-NEXT: ldr r1, [sp, #308]
-; LE-I64-NEXT: vmov.32 d12[1], r5
-; LE-I64-NEXT: ldr r2, [sp, #312]
-; LE-I64-NEXT: ldr r3, [sp, #316]
-; LE-I64-NEXT: vmov.32 d13[1], r6
-; LE-I64-NEXT: vstmia lr, {d12, d13} @ 16-byte Spill
-; LE-I64-NEXT: vmov.32 d10[1], r7
-; LE-I64-NEXT: vmov.32 d8[1], r10
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #288
-; LE-I64-NEXT: mov r11, r0
-; LE-I64-NEXT: str r1, [sp, #60] @ 4-byte Spill
-; LE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: ldr r7, [sp, #272]
-; LE-I64-NEXT: add r3, sp, #276
-; LE-I64-NEXT: mov r5, r1
-; LE-I64-NEXT: vmov.32 d13[0], r0
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: mov r0, r7
-; LE-I64-NEXT: ldr r6, [sp, #416]
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #420
-; LE-I64-NEXT: mov r7, r1
-; LE-I64-NEXT: vmov.32 d12[0], r0
-; LE-I64-NEXT: mov r0, r6
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add lr, sp, #40
-; LE-I64-NEXT: vmov.32 d12[1], r7
-; LE-I64-NEXT: ldr r7, [sp, #228]
-; LE-I64-NEXT: vmov.32 d9[0], r0
-; LE-I64-NEXT: ldr r0, [sp, #224]
-; LE-I64-NEXT: ldr r2, [sp, #232]
-; LE-I64-NEXT: vmov.32 d13[1], r5
-; LE-I64-NEXT: ldr r3, [sp, #236]
-; LE-I64-NEXT: ldr r8, [sp, #336]
-; LE-I64-NEXT: vstmia lr, {d12, d13} @ 16-byte Spill
-; LE-I64-NEXT: add lr, sp, #24
-; LE-I64-NEXT: vmov.32 d11[1], r9
-; LE-I64-NEXT: ldr r10, [sp, #352]
-; LE-I64-NEXT: ldr r5, [sp, #208]
-; LE-I64-NEXT: vstmia lr, {d10, d11} @ 16-byte Spill
-; LE-I64-NEXT: add lr, sp, #8
-; LE-I64-NEXT: vmov.32 d9[1], r1
-; LE-I64-NEXT: mov r1, r7
-; LE-I64-NEXT: vstmia lr, {d8, d9} @ 16-byte Spill
-; LE-I64-NEXT: vmov.32 d10[0], r11
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #212
-; LE-I64-NEXT: mov r9, r1
-; LE-I64-NEXT: vmov.32 d9[0], r0
-; LE-I64-NEXT: mov r0, r5
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #356
-; LE-I64-NEXT: mov r11, r1
-; LE-I64-NEXT: vmov.32 d8[0], r0
-; LE-I64-NEXT: mov r0, r10
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #340
-; LE-I64-NEXT: mov r10, r1
-; LE-I64-NEXT: vmov.32 d13[0], r0
-; LE-I64-NEXT: mov r0, r8
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #388
-; LE-I64-NEXT: vmov.32 d12[0], r0
-; LE-I64-NEXT: ldr r0, [sp, #384]
-; LE-I64-NEXT: mov r6, r1
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #372
-; LE-I64-NEXT: vmov.32 d15[0], r0
-; LE-I64-NEXT: ldr r0, [sp, #368]
-; LE-I64-NEXT: mov r7, r1
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: add r3, sp, #324
-; LE-I64-NEXT: vmov.32 d14[0], r0
-; LE-I64-NEXT: ldr r0, [sp, #320]
-; LE-I64-NEXT: mov r5, r1
-; LE-I64-NEXT: ldm r3, {r1, r2, r3}
-; LE-I64-NEXT: bl lrintl
-; LE-I64-NEXT: vmov.32 d11[0], r0
-; LE-I64-NEXT: ldr r0, [sp, #60] @ 4-byte Reload
-; LE-I64-NEXT: add lr, sp, #8
-; LE-I64-NEXT: vmov.32 d12[1], r6
-; LE-I64-NEXT: vmov.32 d10[1], r0
-; LE-I64-NEXT: add r0, r4, #64
-; LE-I64-NEXT: vmov.32 d11[1], r1
-; LE-I64-NEXT: vmov.32 d14[1], r5
-; LE-I64-NEXT: vmov.32 d13[1], r10
-; LE-I64-NEXT: vmov.32 d15[1], r7
-; LE-I64-NEXT: vst1.64 {d10, d11}, [r0:128]!
-; LE-I64-NEXT: vst1.64 {d12, d13}, [r0:128]!
-; LE-I64-NEXT: vst1.64 {d14, d15}, [r0:128]!
-; LE-I64-NEXT: vldmia lr, {d16, d17} @ 16-byte Reload
-; LE-I64-NEXT: add lr, sp, #24
-; LE-I64-NEXT: vmov.32 d8[1], r11
-; LE-I64-NEXT: vst1.64 {d16, d17}, [r0:128]
-; LE-I64-NEXT: vldmia lr, {d16, d17} @ 16-byte Reload
-; LE-I64-NEXT: add lr, sp, #64
-; LE-I64-NEXT: vmov.32 d9[1], r9
-; LE-I64-NEXT: vst1.64 {d16, d17}, [r4:128]!
-; LE-I64-NEXT: vst1.64 {d8, d9}, [r4:128]!
-; LE-I64-NEXT: vldmia lr, {d16, d17} @ 16-byte Reload
-; LE-I64-NEXT: add lr, sp, #40
-; LE-I64-NEXT: vst1.64 {d16, d17}, [r4:128]!
-; LE-I64-NEXT: vldmia lr, {d16, d17} @ 16-byte Reload
-; LE-I64-NEXT: vst1.64 {d16, d17}, [r4:128]
-; LE-I64-NEXT: add sp, sp, #80
-; LE-I64-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; LE-I64-NEXT: add sp, sp, #4
-; LE-I64-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
-;
-; BE-I32-LABEL: lrint_v16fp128:
-; BE-I32: @ %bb.0:
-; BE-I32-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-I32-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-I32-NEXT: .pad #4
-; BE-I32-NEXT: sub sp, sp, #4
-; BE-I32-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; BE-I32-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; BE-I32-NEXT: .pad #8
-; BE-I32-NEXT: sub sp, sp, #8
-; BE-I32-NEXT: str r3, [sp, #4] @ 4-byte Spill
-; BE-I32-NEXT: add r3, sp, #224
-; BE-I32-NEXT: mov r11, r2
-; BE-I32-NEXT: mov r6, r1
-; BE-I32-NEXT: mov r7, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #292
-; BE-I32-NEXT: ldr r5, [sp, #288]
-; BE-I32-NEXT: vmov.32 d8[0], r0
-; BE-I32-NEXT: ldm r3, {r1, r2, r3}
-; BE-I32-NEXT: mov r0, r5
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r4, [sp, #304]
-; BE-I32-NEXT: vmov.32 d10[0], r0
-; BE-I32-NEXT: ldr r1, [sp, #308]
-; BE-I32-NEXT: ldr r2, [sp, #312]
-; BE-I32-NEXT: ldr r3, [sp, #316]
-; BE-I32-NEXT: mov r0, r4
-; BE-I32-NEXT: ldr r5, [sp, #244]
-; BE-I32-NEXT: ldr r9, [sp, #248]
-; BE-I32-NEXT: ldr r8, [sp, #196]
-; BE-I32-NEXT: ldr r10, [sp, #200]
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d10[1], r0
-; BE-I32-NEXT: ldr r3, [sp, #252]
-; BE-I32-NEXT: ldr r0, [sp, #240]
-; BE-I32-NEXT: mov r1, r5
-; BE-I32-NEXT: mov r2, r9
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d8[1], r0
-; BE-I32-NEXT: ldr r3, [sp, #204]
-; BE-I32-NEXT: ldr r0, [sp, #192]
-; BE-I32-NEXT: mov r1, r8
-; BE-I32-NEXT: mov r2, r10
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #256
-; BE-I32-NEXT: mov r4, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r3, [sp, #4] @ 4-byte Reload
-; BE-I32-NEXT: mov r5, r0
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: mov r1, r6
-; BE-I32-NEXT: mov r2, r11
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r6, [sp, #320]
-; BE-I32-NEXT: vmov.32 d12[0], r0
-; BE-I32-NEXT: ldr r1, [sp, #324]
-; BE-I32-NEXT: ldr r2, [sp, #328]
-; BE-I32-NEXT: ldr r3, [sp, #332]
-; BE-I32-NEXT: mov r0, r6
-; BE-I32-NEXT: ldr r10, [sp, #176]
-; BE-I32-NEXT: ldr r9, [sp, #180]
-; BE-I32-NEXT: ldr r8, [sp, #112]
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r7, [sp, #272]
-; BE-I32-NEXT: vmov.32 d11[0], r0
-; BE-I32-NEXT: ldr r1, [sp, #276]
-; BE-I32-NEXT: ldr r2, [sp, #280]
-; BE-I32-NEXT: vmov.32 d9[0], r5
-; BE-I32-NEXT: ldr r3, [sp, #284]
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: ldr r6, [sp, #184]
-; BE-I32-NEXT: ldr r11, [sp, #144]
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r3, [sp, #188]
-; BE-I32-NEXT: vmov.32 d9[1], r0
-; BE-I32-NEXT: mov r0, r10
-; BE-I32-NEXT: mov r1, r9
-; BE-I32-NEXT: mov r2, r6
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #160
-; BE-I32-NEXT: mov r6, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d14[0], r0
-; BE-I32-NEXT: ldr r0, [sp, #208]
-; BE-I32-NEXT: ldr r1, [sp, #212]
-; BE-I32-NEXT: ldr r2, [sp, #216]
-; BE-I32-NEXT: vmov.32 d15[0], r4
-; BE-I32-NEXT: ldr r3, [sp, #220]
-; BE-I32-NEXT: vmov.32 d14[1], r6
-; BE-I32-NEXT: ldr r7, [sp, #116]
-; BE-I32-NEXT: ldr r5, [sp, #120]
-; BE-I32-NEXT: ldr r4, [sp, #148]
-; BE-I32-NEXT: ldr r6, [sp, #152]
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r3, [sp, #124]
-; BE-I32-NEXT: vmov.32 d15[1], r0
-; BE-I32-NEXT: mov r0, r8
-; BE-I32-NEXT: mov r1, r7
-; BE-I32-NEXT: mov r2, r5
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: ldr r3, [sp, #156]
-; BE-I32-NEXT: vmov.32 d12[1], r0
-; BE-I32-NEXT: mov r0, r11
-; BE-I32-NEXT: mov r1, r4
-; BE-I32-NEXT: mov r2, r6
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #128
-; BE-I32-NEXT: mov r4, r0
-; BE-I32-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: add r3, sp, #340
-; BE-I32-NEXT: ldr r7, [sp, #336]
-; BE-I32-NEXT: vmov.32 d13[0], r0
-; BE-I32-NEXT: ldm r3, {r1, r2, r3}
-; BE-I32-NEXT: mov r0, r7
-; BE-I32-NEXT: vmov.32 d13[1], r4
-; BE-I32-NEXT: bl lrintl
-; BE-I32-NEXT: vmov.32 d11[1], r0
-; BE-I32-NEXT: vrev64.32 q0, q6
-; BE-I32-NEXT: vrev64.32 q1, q7
-; BE-I32-NEXT: vrev64.32 q2, q4
-; BE-I32-NEXT: vrev64.32 q3, q5
-; BE-I32-NEXT: add sp, sp, #8
-; BE-I32-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; BE-I32-NEXT: add sp, sp, #4
-; BE-I32-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
-;
-; BE-I64-LABEL: lrint_v16fp128:
-; BE-I64: @ %bb.0:
-; BE-I64-NEXT: .save {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-I64-NEXT: push {r4, r5, r6, r7, r8, r9, r10, r11, lr}
-; BE-I64-NEXT: .pad #4
-; BE-I64-NEXT: sub sp, sp, #4
-; BE-I64-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; BE-I64-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; BE-I64-NEXT: .pad #56
-; BE-I64-NEXT: sub sp, sp, #56
-; BE-I64-NEXT: mov r5, r3
-; BE-I64-NEXT: add r3, sp, #392
-; BE-I64-NEXT: mov r6, r2
-; BE-I64-NEXT: mov r4, r0
-; BE-I64-NEXT: ldm r3, {r0, r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r7, [sp, #376]
-; BE-I64-NEXT: add r3, sp, #380
-; BE-I64-NEXT: str r1, [sp] @ 4-byte Spill
-; BE-I64-NEXT: vmov.32 d8[0], r0
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: mov r0, r7
-; BE-I64-NEXT: ldr r8, [sp, #168]
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #172
-; BE-I64-NEXT: mov r11, r1
-; BE-I64-NEXT: vmov.32 d9[0], r0
-; BE-I64-NEXT: mov r0, r8
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r2, [sp, #160]
-; BE-I64-NEXT: mov r8, r1
-; BE-I64-NEXT: ldr r3, [sp, #164]
-; BE-I64-NEXT: vmov.32 d10[0], r0
-; BE-I64-NEXT: mov r0, r6
-; BE-I64-NEXT: mov r1, r5
-; BE-I64-NEXT: ldr r10, [sp, #264]
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #236
-; BE-I64-NEXT: vmov.32 d11[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #232]
-; BE-I64-NEXT: mov r9, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #220
-; BE-I64-NEXT: vmov.32 d12[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #216]
-; BE-I64-NEXT: mov r6, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #268
-; BE-I64-NEXT: mov r7, r1
-; BE-I64-NEXT: vmov.32 d13[0], r0
-; BE-I64-NEXT: mov r0, r10
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #252
-; BE-I64-NEXT: vmov.32 d14[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #248]
-; BE-I64-NEXT: mov r5, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r2, [sp] @ 4-byte Reload
-; BE-I64-NEXT: vmov.32 d15[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #280]
-; BE-I64-NEXT: vmov.32 d14[1], r5
-; BE-I64-NEXT: ldr r5, [sp, #284]
-; BE-I64-NEXT: ldr r3, [sp, #292]
-; BE-I64-NEXT: vmov.32 d13[1], r7
-; BE-I64-NEXT: ldr r7, [sp, #328]
-; BE-I64-NEXT: vmov.32 d12[1], r6
-; BE-I64-NEXT: ldr r6, [sp, #332]
-; BE-I64-NEXT: vmov.32 d10[1], r8
-; BE-I64-NEXT: ldr r8, [sp, #312]
-; BE-I64-NEXT: vmov.32 d8[1], r2
-; BE-I64-NEXT: ldr r2, [sp, #288]
-; BE-I64-NEXT: vmov.32 d11[1], r9
-; BE-I64-NEXT: vmov.32 d9[1], r11
-; BE-I64-NEXT: vmov.32 d15[1], r1
-; BE-I64-NEXT: mov r1, r5
-; BE-I64-NEXT: vstr d14, [sp, #48] @ 8-byte Spill
-; BE-I64-NEXT: vstr d13, [sp, #40] @ 8-byte Spill
-; BE-I64-NEXT: vstr d12, [sp, #32] @ 8-byte Spill
-; BE-I64-NEXT: vstr d11, [sp, #24] @ 8-byte Spill
-; BE-I64-NEXT: vstr d10, [sp, #16] @ 8-byte Spill
-; BE-I64-NEXT: vstr d9, [sp, #8] @ 8-byte Spill
-; BE-I64-NEXT: vstr d8, [sp] @ 8-byte Spill
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: ldr r2, [sp, #336]
-; BE-I64-NEXT: mov r10, r1
-; BE-I64-NEXT: ldr r3, [sp, #340]
-; BE-I64-NEXT: vmov.32 d8[0], r0
-; BE-I64-NEXT: mov r0, r7
-; BE-I64-NEXT: mov r1, r6
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #316
-; BE-I64-NEXT: mov r11, r1
-; BE-I64-NEXT: vmov.32 d9[0], r0
-; BE-I64-NEXT: mov r0, r8
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #204
-; BE-I64-NEXT: vmov.32 d10[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #200]
-; BE-I64-NEXT: mov r9, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #188
-; BE-I64-NEXT: vmov.32 d11[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #184]
-; BE-I64-NEXT: mov r8, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #364
-; BE-I64-NEXT: vmov.32 d12[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #360]
-; BE-I64-NEXT: mov r5, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #348
-; BE-I64-NEXT: vmov.32 d13[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #344]
-; BE-I64-NEXT: mov r6, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: add r3, sp, #300
-; BE-I64-NEXT: vmov.32 d14[0], r0
-; BE-I64-NEXT: ldr r0, [sp, #296]
-; BE-I64-NEXT: mov r7, r1
-; BE-I64-NEXT: ldm r3, {r1, r2, r3}
-; BE-I64-NEXT: bl lrintl
-; BE-I64-NEXT: vldr d17, [sp, #48] @ 8-byte Reload
-; BE-I64-NEXT: vrev64.32 d18, d15
-; BE-I64-NEXT: vrev64.32 d19, d17
-; BE-I64-NEXT: vldr d17, [sp, #40] @ 8-byte Reload
-; BE-I64-NEXT: vmov.32 d16[0], r0
-; BE-I64-NEXT: add r0, r4, #64
-; BE-I64-NEXT: vrev64.32 d20, d17
-; BE-I64-NEXT: vldr d17, [sp, #32] @ 8-byte Reload
-; BE-I64-NEXT: vmov.32 d8[1], r10
-; BE-I64-NEXT: vrev64.32 d21, d17
-; BE-I64-NEXT: vldr d17, [sp, #24] @ 8-byte Reload
-; BE-I64-NEXT: vmov.32 d10[1], r9
-; BE-I64-NEXT: vmov.32 d16[1], r1
-; BE-I64-NEXT: vmov.32 d14[1], r7
-; BE-I64-NEXT: vrev64.32 d22, d17
-; BE-I64-NEXT: vldr d17, [sp, #16] @ 8-byte Reload
-; BE-I64-NEXT: vmov.32 d9[1], r11
-; BE-I64-NEXT: vrev64.32 d0, d8
-; BE-I64-NEXT: vmov.32 d13[1], r6
-; BE-I64-NEXT: vrev64.32 d30, d10
-; BE-I64-NEXT: vrev64.32 d23, d17
-; BE-I64-NEXT: vldr d17, [sp, #8] @ 8-byte Reload
-; BE-I64-NEXT: vrev64.32 d1, d16
-; BE-I64-NEXT: vrev64.32 d26, d14
-; BE-I64-NEXT: vmov.32 d12[1], r5
-; BE-I64-NEXT: vrev64.32 d31, d9
-; BE-I64-NEXT: vrev64.32 d24, d17
-; BE-I64-NEXT: vldr d17, [sp] @ 8-byte Reload
-; BE-I64-NEXT: vst1.64 {d0, d1}, [r0:128]!
-; BE-I64-NEXT: vmov.32 d11[1], r8
-; BE-I64-NEXT: vrev64.32 d27, d13
-; BE-I64-NEXT: vst1.64 {d30, d31}, [r0:128]!
-; BE-I64-NEXT: vrev64.32 d28, d12
-; BE-I64-NEXT: vrev64.32 d25, d17
-; BE-I64-NEXT: vst1.64 {d26, d27}, [r0:128]!
-; BE-I64-NEXT: vrev64.32 d29, d11
-; BE-I64-NEXT: vst1.64 {d24, d25}, [r0:128]
-; BE-I64-NEXT: vst1.64 {d22, d23}, [r4:128]!
-; BE-I64-NEXT: vst1.64 {d28, d29}, [r4:128]!
-; BE-I64-NEXT: vst1.64 {d20, d21}, [r4:128]!
-; BE-I64-NEXT: vst1.64 {d18, d19}, [r4:128]
-; BE-I64-NEXT: add sp, sp, #56
-; BE-I64-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; BE-I64-NEXT: add sp, sp, #4
-; BE-I64-NEXT: pop {r4, r5, r6, r7, r8, r9, r10, r11, pc}
- %a = call <16 x iXLen> @llvm.lrint.v16iXLen.v16fp128(<16 x fp128> %x)
- ret <16 x iXLen> %a
-}
diff --git a/llvm/test/CodeGen/AVR/llrint.ll b/llvm/test/CodeGen/AVR/llrint.ll
index 2980879bb6e3e..e173841c7dfa1 100644
--- a/llvm/test/CodeGen/AVR/llrint.ll
+++ b/llvm/test/CodeGen/AVR/llrint.ll
@@ -28,16 +28,5 @@ entry:
ret i64 %0
}
-; FIXME(#44744): incorrect libcall
-define i64 @testmsxq_builtin(fp128 %x) {
-; CHECK-LABEL: testmsxq_builtin:
-; CHECK: ; %bb.0: ; %entry
-; CHECK-NEXT: call llrintl
-; CHECK-NEXT: ret
-entry:
- %0 = tail call i64 @llvm.llrint.i64.fp128(fp128 %x)
- ret i64 %0
-}
-
declare i64 @llvm.llrint.i64.f32(float) nounwind readnone
declare i64 @llvm.llrint.i64.f64(double) nounwind readnone
diff --git a/llvm/test/CodeGen/AVR/llvm.sincos.ll b/llvm/test/CodeGen/AVR/llvm.sincos.ll
index ff01da9fd167b..13ff02ef7cfdc 100644
--- a/llvm/test/CodeGen/AVR/llvm.sincos.ll
+++ b/llvm/test/CodeGen/AVR/llvm.sincos.ll
@@ -269,132 +269,6 @@ define { <2 x float>, <2 x float> } @test_sincos_v2f32(<2 x float> %a) #0 {
; ret { <2 x double>, <2 x double> } %result
; }
-define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
-; CHECK-LABEL: test_sincos_f128:
-; CHECK: ; %bb.0:
-; CHECK-NEXT: push r2
-; CHECK-NEXT: push r3
-; CHECK-NEXT: push r4
-; CHECK-NEXT: push r5
-; CHECK-NEXT: push r6
-; CHECK-NEXT: push r7
-; CHECK-NEXT: push r28
-; CHECK-NEXT: push r29
-; CHECK-NEXT: in r28, 61
-; CHECK-NEXT: in r29, 62
-; CHECK-NEXT: sbiw r28, 34
-; CHECK-NEXT: in r0, 63
-; CHECK-NEXT: cli
-; CHECK-NEXT: out 62, r29
-; CHECK-NEXT: out 63, r0
-; CHECK-NEXT: out 61, r28
-; CHECK-NEXT: std Y+2, r23 ; 2-byte Folded Spill
-; CHECK-NEXT: std Y+1, r22 ; 2-byte Folded Spill
-; CHECK-NEXT: mov r2, r20
-; CHECK-NEXT: mov r3, r21
-; CHECK-NEXT: mov r4, r18
-; CHECK-NEXT: mov r5, r19
-; CHECK-NEXT: mov r6, r24
-; CHECK-NEXT: mov r7, r25
-; CHECK-NEXT: mov r24, r28
-; CHECK-NEXT: mov r25, r29
-; CHECK-NEXT: adiw r24, 3
-; CHECK-NEXT: rcall cosl
-; CHECK-NEXT: mov r24, r28
-; CHECK-NEXT: mov r25, r29
-; CHECK-NEXT: adiw r24, 19
-; CHECK-NEXT: mov r18, r4
-; CHECK-NEXT: mov r19, r5
-; CHECK-NEXT: mov r20, r2
-; CHECK-NEXT: mov r21, r3
-; CHECK-NEXT: ldd r22, Y+1 ; 2-byte Folded Reload
-; CHECK-NEXT: ldd r23, Y+2 ; 2-byte Folded Reload
-; CHECK-NEXT: rcall sinl
-; CHECK-NEXT: ldd r24, Y+17
-; CHECK-NEXT: ldd r25, Y+18
-; CHECK-NEXT: mov r30, r6
-; CHECK-NEXT: mov r31, r7
-; CHECK-NEXT: std Z+31, r25
-; CHECK-NEXT: std Z+30, r24
-; CHECK-NEXT: ldd r24, Y+15
-; CHECK-NEXT: ldd r25, Y+16
-; CHECK-NEXT: std Z+29, r25
-; CHECK-NEXT: std Z+28, r24
-; CHECK-NEXT: ldd r24, Y+13
-; CHECK-NEXT: ldd r25, Y+14
-; CHECK-NEXT: std Z+27, r25
-; CHECK-NEXT: std Z+26, r24
-; CHECK-NEXT: ldd r24, Y+11
-; CHECK-NEXT: ldd r25, Y+12
-; CHECK-NEXT: std Z+25, r25
-; CHECK-NEXT: std Z+24, r24
-; CHECK-NEXT: ldd r24, Y+9
-; CHECK-NEXT: ldd r25, Y+10
-; CHECK-NEXT: std Z+23, r25
-; CHECK-NEXT: std Z+22, r24
-; CHECK-NEXT: ldd r24, Y+7
-; CHECK-NEXT: ldd r25, Y+8
-; CHECK-NEXT: std Z+21, r25
-; CHECK-NEXT: std Z+20, r24
-; CHECK-NEXT: ldd r24, Y+5
-; CHECK-NEXT: ldd r25, Y+6
-; CHECK-NEXT: std Z+19, r25
-; CHECK-NEXT: std Z+18, r24
-; CHECK-NEXT: ldd r24, Y+3
-; CHECK-NEXT: ldd r25, Y+4
-; CHECK-NEXT: std Z+17, r25
-; CHECK-NEXT: std Z+16, r24
-; CHECK-NEXT: ldd r24, Y+33
-; CHECK-NEXT: ldd r25, Y+34
-; CHECK-NEXT: std Z+15, r25
-; CHECK-NEXT: std Z+14, r24
-; CHECK-NEXT: ldd r24, Y+31
-; CHECK-NEXT: ldd r25, Y+32
-; CHECK-NEXT: std Z+13, r25
-; CHECK-NEXT: std Z+12, r24
-; CHECK-NEXT: ldd r24, Y+29
-; CHECK-NEXT: ldd r25, Y+30
-; CHECK-NEXT: std Z+11, r25
-; CHECK-NEXT: std Z+10, r24
-; CHECK-NEXT: ldd r24, Y+27
-; CHECK-NEXT: ldd r25, Y+28
-; CHECK-NEXT: std Z+9, r25
-; CHECK-NEXT: std Z+8, r24
-; CHECK-NEXT: ldd r24, Y+25
-; CHECK-NEXT: ldd r25, Y+26
-; CHECK-NEXT: std Z+7, r25
-; CHECK-NEXT: std Z+6, r24
-; CHECK-NEXT: ldd r24, Y+23
-; CHECK-NEXT: ldd r25, Y+24
-; CHECK-NEXT: std Z+5, r25
-; CHECK-NEXT: std Z+4, r24
-; CHECK-NEXT: ldd r24, Y+21
-; CHECK-NEXT: ldd r25, Y+22
-; CHECK-NEXT: std Z+3, r25
-; CHECK-NEXT: std Z+2, r24
-; CHECK-NEXT: ldd r24, Y+19
-; CHECK-NEXT: ldd r25, Y+20
-; CHECK-NEXT: std Z+1, r25
-; CHECK-NEXT: st Z, r24
-; CHECK-NEXT: adiw r28, 34
-; CHECK-NEXT: in r0, 63
-; CHECK-NEXT: cli
-; CHECK-NEXT: out 62, r29
-; CHECK-NEXT: out 63, r0
-; CHECK-NEXT: out 61, r28
-; CHECK-NEXT: pop r29
-; CHECK-NEXT: pop r28
-; CHECK-NEXT: pop r7
-; CHECK-NEXT: pop r6
-; CHECK-NEXT: pop r5
-; CHECK-NEXT: pop r4
-; CHECK-NEXT: pop r3
-; CHECK-NEXT: pop r2
-; CHECK-NEXT: ret
- %result = call { fp128, fp128 } @llvm.sincos.f128(fp128 %a)
- ret { fp128, fp128 } %result
-}
-
attributes #0 = { nounwind }
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
diff --git a/llvm/test/CodeGen/AVR/lrint.ll b/llvm/test/CodeGen/AVR/lrint.ll
index 4ef656060bd10..a937e61884d4e 100644
--- a/llvm/test/CodeGen/AVR/lrint.ll
+++ b/llvm/test/CodeGen/AVR/lrint.ll
@@ -28,16 +28,5 @@ entry:
ret i32 %0
}
-; FIXME(#44744): incorrect libcall
-define i32 @testmswq_builtin(fp128 %x) {
-; CHECK-LABEL: testmswq_builtin:
-; CHECK: ; %bb.0: ; %entry
-; CHECK-NEXT: call lrint
-; CHECK-NEXT: ret
-entry:
- %0 = tail call i32 @llvm.lrint.i32.fp128(fp128 %x)
- ret i32 %0
-}
-
declare i32 @llvm.lrint.i32.f32(float) nounwind readnone
declare i32 @llvm.lrint.i32.f64(double) nounwind readnone
diff --git a/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll b/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
index ed8b9b0789c2e..b1b72e4860256 100644
--- a/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
+++ b/llvm/test/CodeGen/Generic/fp128-math-libcalls.ll
@@ -1,35 +1,27 @@
-; Verify that fp128 intrinsics only lower to `long double` calls (e.g. sinl) on
-; platforms where 128 and `long double` have the same layout. Otherwise, lower
-; to f128 versions (e.g. sinf128).
+; Verify that fp128 intrinsics lower to the `l`-suffixed long double calls (e.g.
+; sinl) only on platforms where `long double` is fp128, and otherwise to the
+; explicit f128 versions (e.g. sinf128).
;
; Targets include:
-; * aarch64 (long double == f128, should use ld syms)
-; * arm (long double == f64, should use f128 syms)
-; * s390x (long double == f128, should use ld syms, some hardware support)
-; * x86, x64 (80-bit long double, should use ld syms)
-; * gnu (has f128 symbols on all platforms so we can use those)
-; * 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.
+; * aarch64 linux (long double == f128, uses ld syms)
+; * riscv32 (long double == f128, uses ld syms)
+; * s390x (long double == f128, uses ld syms, some hardware support)
+; * powerpc, x86 gnu (long double != f128, have f128 syms, use those)
+;
+; Targets whose `long double` is not fp128 and which have no f128 libm symbols
+; (arm, x86 musl, MacOS, Windows) have no valid fp128 math libcall and are not
+; exercised here; see #44744.
; 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 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=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 %}
; FIXME(#144006): Windows-MSVC should also be run but has a ldexp selection failure.
; %if x86-registered-target %{ llc < %s -mtriple=x86_64-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-F128 %}
diff --git a/llvm/test/CodeGen/Hexagon/llvm.exp10.ll b/llvm/test/CodeGen/Hexagon/llvm.exp10.ll
index cd94d328f1fee..a730f797e5808 100644
--- a/llvm/test/CodeGen/Hexagon/llvm.exp10.ll
+++ b/llvm/test/CodeGen/Hexagon/llvm.exp10.ll
@@ -141,84 +141,4 @@ define <2 x double> @exp10_v2f64(<2 x double> %x) #0 {
ret <2 x double> %r
}
-define fp128 @exp10_f128(fp128 %x) #0 {
-; CHECK-LABEL: exp10_f128:
-; CHECK: // %bb.0:
-; CHECK-NEXT: {
-; CHECK-NEXT: r16 = r0
-; CHECK-NEXT: memd(r29+#-16) = r17:16
-; CHECK-NEXT: allocframe(#24)
-; CHECK-NEXT: } // 8-byte Folded Spill
-; CHECK-NEXT: {
-; CHECK-NEXT: call exp10l
-; CHECK-NEXT: r0 = add(r29,#0)
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: r1:0 = memd(r29+#0)
-; CHECK-NEXT: r3:2 = memd(r29+#8)
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: memd(r16+#8) = r3:2
-; CHECK-NEXT: memd(r16+#0) = r1:0
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: r17:16 = memd(r29+#16)
-; CHECK-NEXT: dealloc_return
-; CHECK-NEXT: } // 8-byte Folded Reload
- %r = call fp128 @llvm.exp10.f128(fp128 %x)
- ret fp128 %r
-}
-
-define <2 x fp128> @exp10_v2f128(<2 x fp128> %x) #0 {
-; CHECK-LABEL: exp10_v2f128:
-; CHECK: // %bb.0:
-; CHECK-NEXT: {
-; CHECK-NEXT: r16 = r0
-; CHECK-NEXT: memd(r29+#-16) = r17:16
-; CHECK-NEXT: allocframe(#56)
-; CHECK-NEXT: } // 8-byte Folded Spill
-; CHECK-NEXT: {
-; CHECK-NEXT: r0 = add(r29,#16)
-; CHECK-NEXT: memd(r29+#40) = r19:18
-; CHECK-NEXT: memd(r29+#32) = r21:20
-; CHECK-NEXT: } // 8-byte Folded Spill
-; CHECK-NEXT: {
-; CHECK-NEXT: call exp10l
-; CHECK-NEXT: r19:18 = memd(r29+#64)
-; CHECK-NEXT: r21:20 = memd(r29+#72)
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: call exp10l
-; CHECK-NEXT: r0 = add(r29,#0)
-; CHECK-NEXT: r3:2 = combine(r19,r18)
-; CHECK-NEXT: r5:4 = combine(r21,r20)
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: r1:0 = memd(r29+#16)
-; CHECK-NEXT: r3:2 = memd(r29+#24)
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: r5:4 = memd(r29+#0)
-; CHECK-NEXT: r7:6 = memd(r29+#8)
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: memd(r16+#24) = r7:6
-; CHECK-NEXT: memd(r16+#16) = r5:4
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: memd(r16+#8) = r3:2
-; CHECK-NEXT: memd(r16+#0) = r1:0
-; CHECK-NEXT: }
-; CHECK-NEXT: {
-; CHECK-NEXT: r17:16 = memd(r29+#48)
-; CHECK-NEXT: r19:18 = memd(r29+#40)
-; CHECK-NEXT: } // 8-byte Folded Reload
-; CHECK-NEXT: {
-; CHECK-NEXT: r21:20 = memd(r29+#32)
-; CHECK-NEXT: dealloc_return
-; CHECK-NEXT: } // 8-byte Folded Reload
- %r = call <2 x fp128> @llvm.exp10.v2f128(<2 x fp128> %x)
- ret <2 x fp128> %r
-}
-
attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/Hexagon/llvm.sincos.ll b/llvm/test/CodeGen/Hexagon/llvm.sincos.ll
index f02ac2ca8480f..b42a3856ce4cb 100644
--- a/llvm/test/CodeGen/Hexagon/llvm.sincos.ll
+++ b/llvm/test/CodeGen/Hexagon/llvm.sincos.ll
@@ -1093,395 +1093,4 @@ define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) #0 {
ret { <2 x double>, <2 x double> } %result
}
-define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
-; BASE-LABEL: test_sincos_f128:
-; BASE: // %bb.0:
-; BASE-NEXT: {
-; BASE-NEXT: r17:16 = combine(r5,r4)
-; BASE-NEXT: memd(r29+#-16) = r17:16
-; BASE-NEXT: allocframe(#56)
-; BASE-NEXT: } // 8-byte Folded Spill
-; BASE-NEXT: {
-; BASE-NEXT: r20 = r0
-; BASE-NEXT: r0 = add(r29,#0)
-; BASE-NEXT: memd(r29+#32) = r21:20
-; BASE-NEXT: memd(r29+#40) = r19:18
-; BASE-NEXT: } // 8-byte Folded Spill
-; BASE-NEXT: {
-; BASE-NEXT: call sinl
-; BASE-NEXT: r19:18 = combine(r3,r2)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: call cosl
-; BASE-NEXT: r0 = add(r29,#16)
-; BASE-NEXT: r3:2 = combine(r19,r18)
-; BASE-NEXT: r5:4 = combine(r17,r16)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r1:0 = memd(r29+#0)
-; BASE-NEXT: r3:2 = memd(r29+#8)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r5:4 = memd(r29+#16)
-; BASE-NEXT: r7:6 = memd(r29+#24)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: memd(r20+#24) = r7:6
-; BASE-NEXT: memd(r20+#16) = r5:4
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: memd(r20+#8) = r3:2
-; BASE-NEXT: memd(r20+#0) = r1:0
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r17:16 = memd(r29+#48)
-; BASE-NEXT: r19:18 = memd(r29+#40)
-; BASE-NEXT: } // 8-byte Folded Reload
-; BASE-NEXT: {
-; BASE-NEXT: r21:20 = memd(r29+#32)
-; BASE-NEXT: dealloc_return
-; BASE-NEXT: } // 8-byte Folded Reload
-;
-; GNU-LABEL: test_sincos_f128:
-; GNU: // %bb.0:
-; GNU-NEXT: {
-; GNU-NEXT: r16 = r0
-; GNU-NEXT: memd(r29+#-16) = r17:16
-; GNU-NEXT: allocframe(#64)
-; GNU-NEXT: } // 8-byte Folded Spill
-; GNU-NEXT: {
-; GNU-NEXT: r0 = add(r29,#40)
-; GNU-NEXT: r7 = add(r29,#24)
-; GNU-NEXT: r6 = add(r29,#8)
-; GNU-NEXT: memw(r29+#4) = r7.new
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: call sincosl
-; GNU-NEXT: memw(r29+#0) = r6
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r1:0 = memd(r29+#8)
-; GNU-NEXT: r3:2 = memd(r29+#16)
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r5:4 = memd(r29+#24)
-; GNU-NEXT: r7:6 = memd(r29+#32)
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: memd(r16+#24) = r7:6
-; GNU-NEXT: memd(r16+#16) = r5:4
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: memd(r16+#8) = r3:2
-; GNU-NEXT: memd(r16+#0) = r1:0
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r17:16 = memd(r29+#56)
-; GNU-NEXT: dealloc_return
-; GNU-NEXT: } // 8-byte Folded Reload
-;
-; MUSL-LABEL: test_sincos_f128:
-; MUSL: // %bb.0:
-; MUSL-NEXT: {
-; MUSL-NEXT: r17:16 = combine(r5,r4)
-; MUSL-NEXT: memd(r29+#-16) = r17:16
-; MUSL-NEXT: allocframe(#56)
-; MUSL-NEXT: } // 8-byte Folded Spill
-; MUSL-NEXT: {
-; MUSL-NEXT: r20 = r0
-; MUSL-NEXT: r0 = add(r29,#0)
-; MUSL-NEXT: memd(r29+#32) = r21:20
-; MUSL-NEXT: memd(r29+#40) = r19:18
-; MUSL-NEXT: } // 8-byte Folded Spill
-; MUSL-NEXT: {
-; MUSL-NEXT: call sinl
-; MUSL-NEXT: r19:18 = combine(r3,r2)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: call cosl
-; MUSL-NEXT: r0 = add(r29,#16)
-; MUSL-NEXT: r3:2 = combine(r19,r18)
-; MUSL-NEXT: r5:4 = combine(r17,r16)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r1:0 = memd(r29+#0)
-; MUSL-NEXT: r3:2 = memd(r29+#8)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r5:4 = memd(r29+#16)
-; MUSL-NEXT: r7:6 = memd(r29+#24)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: memd(r20+#24) = r7:6
-; MUSL-NEXT: memd(r20+#16) = r5:4
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: memd(r20+#8) = r3:2
-; MUSL-NEXT: memd(r20+#0) = r1:0
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r17:16 = memd(r29+#48)
-; MUSL-NEXT: r19:18 = memd(r29+#40)
-; MUSL-NEXT: } // 8-byte Folded Reload
-; MUSL-NEXT: {
-; MUSL-NEXT: r21:20 = memd(r29+#32)
-; MUSL-NEXT: dealloc_return
-; MUSL-NEXT: } // 8-byte Folded Reload
- %result = call { fp128, fp128 } @llvm.sincos.f128(fp128 %a)
- ret { fp128, fp128 } %result
-}
-
-define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
-; BASE-LABEL: test_sincos_v2f128:
-; BASE: // %bb.0:
-; BASE-NEXT: {
-; BASE-NEXT: r17:16 = combine(r5,r4)
-; BASE-NEXT: memd(r29+#-16) = r17:16
-; BASE-NEXT: allocframe(#104)
-; BASE-NEXT: } // 8-byte Folded Spill
-; BASE-NEXT: {
-; BASE-NEXT: r20 = r0
-; BASE-NEXT: r0 = add(r29,#32)
-; BASE-NEXT: memd(r29+#80) = r21:20
-; BASE-NEXT: memd(r29+#88) = r19:18
-; BASE-NEXT: } // 8-byte Folded Spill
-; BASE-NEXT: {
-; BASE-NEXT: r19:18 = combine(r3,r2)
-; BASE-NEXT: memd(r29+#72) = r23:22
-; BASE-NEXT: memd(r29+#64) = r25:24
-; BASE-NEXT: } // 8-byte Folded Spill
-; BASE-NEXT: {
-; BASE-NEXT: call sinl
-; BASE-NEXT: r23:22 = memd(r29+#112)
-; BASE-NEXT: r25:24 = memd(r29+#120)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: call sinl
-; 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: 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: r0 = add(r29,#16)
-; BASE-NEXT: r3:2 = combine(r23,r22)
-; BASE-NEXT: r5:4 = combine(r25,r24)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r1:0 = memd(r29+#32)
-; BASE-NEXT: r3:2 = memd(r29+#40)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r9:8 = memd(r29+#48)
-; BASE-NEXT: r15:14 = memd(r29+#24)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r5:4 = memd(r29+#0)
-; BASE-NEXT: r7:6 = memd(r29+#8)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r13:12 = memd(r29+#16)
-; BASE-NEXT: r11:10 = memd(r29+#56)
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: memd(r20+#56) = r15:14
-; BASE-NEXT: memd(r20+#48) = r13:12
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: memd(r20+#40) = r11:10
-; BASE-NEXT: memd(r20+#32) = r9:8
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: memd(r20+#24) = r7:6
-; BASE-NEXT: memd(r20+#16) = r5:4
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: memd(r20+#8) = r3:2
-; BASE-NEXT: memd(r20+#0) = r1:0
-; BASE-NEXT: }
-; BASE-NEXT: {
-; BASE-NEXT: r17:16 = memd(r29+#96)
-; BASE-NEXT: r19:18 = memd(r29+#88)
-; BASE-NEXT: } // 8-byte Folded Reload
-; BASE-NEXT: {
-; BASE-NEXT: r21:20 = memd(r29+#80)
-; BASE-NEXT: r23:22 = memd(r29+#72)
-; BASE-NEXT: } // 8-byte Folded Reload
-; BASE-NEXT: {
-; BASE-NEXT: r25:24 = memd(r29+#64)
-; BASE-NEXT: r31:30 = dealloc_return(r30):raw
-; BASE-NEXT: } // 8-byte Folded Reload
-;
-; GNU-LABEL: test_sincos_v2f128:
-; GNU: // %bb.0:
-; GNU-NEXT: {
-; GNU-NEXT: r16 = r0
-; GNU-NEXT: memd(r29+#-16) = r17:16
-; GNU-NEXT: allocframe(#128)
-; GNU-NEXT: } // 8-byte Folded Spill
-; GNU-NEXT: {
-; GNU-NEXT: r0 = add(r29,#88)
-; GNU-NEXT: r17 = r29
-; GNU-NEXT: memd(r29+#112) = r19:18
-; GNU-NEXT: memd(r29+#104) = r21:20
-; GNU-NEXT: } // 8-byte Folded Spill
-; GNU-NEXT: {
-; GNU-NEXT: r6 = add(r29,#56)
-; GNU-NEXT: r1 = add(r29,#72)
-; GNU-NEXT: r19:18 = memd(r29+#136)
-; GNU-NEXT: memw(r17+#0) = r6.new
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: call sincosl
-; GNU-NEXT: r21:20 = memd(r29+#144)
-; GNU-NEXT: memw(r17+#4) = r1
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r0 = add(r29,#24)
-; GNU-NEXT: r3:2 = combine(r19,r18)
-; GNU-NEXT: r5:4 = combine(r21,r20)
-; GNU-NEXT: memw(r17+#4) = r0.new
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: call sincosl
-; GNU-NEXT: r0 = add(r29,#40)
-; GNU-NEXT: r1 = add(r29,#8)
-; GNU-NEXT: memw(r17+#0) = r1.new
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r1:0 = memd(r29+#56)
-; GNU-NEXT: r3:2 = memd(r29+#64)
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r5:4 = memd(r29+#8)
-; GNU-NEXT: r7:6 = memd(r29+#16)
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r9:8 = memd(r29+#72)
-; GNU-NEXT: r13:12 = memd(r29+#24)
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r15:14 = memd(r29+#32)
-; GNU-NEXT: r11:10 = memd(r29+#80)
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: memd(r16+#56) = r15:14
-; GNU-NEXT: memd(r16+#48) = r13:12
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: memd(r16+#40) = r11:10
-; GNU-NEXT: memd(r16+#32) = r9:8
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: memd(r16+#24) = r7:6
-; GNU-NEXT: memd(r16+#16) = r5:4
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: memd(r16+#8) = r3:2
-; GNU-NEXT: memd(r16+#0) = r1:0
-; GNU-NEXT: }
-; GNU-NEXT: {
-; GNU-NEXT: r17:16 = memd(r29+#120)
-; GNU-NEXT: r19:18 = memd(r29+#112)
-; GNU-NEXT: } // 8-byte Folded Reload
-; GNU-NEXT: {
-; GNU-NEXT: r21:20 = memd(r29+#104)
-; GNU-NEXT: dealloc_return
-; GNU-NEXT: } // 8-byte Folded Reload
-;
-; MUSL-LABEL: test_sincos_v2f128:
-; MUSL: // %bb.0:
-; MUSL-NEXT: {
-; MUSL-NEXT: r17:16 = combine(r5,r4)
-; MUSL-NEXT: memd(r29+#-16) = r17:16
-; MUSL-NEXT: allocframe(#104)
-; MUSL-NEXT: } // 8-byte Folded Spill
-; MUSL-NEXT: {
-; MUSL-NEXT: r20 = r0
-; MUSL-NEXT: r0 = add(r29,#32)
-; MUSL-NEXT: memd(r29+#80) = r21:20
-; MUSL-NEXT: memd(r29+#88) = r19:18
-; MUSL-NEXT: } // 8-byte Folded Spill
-; MUSL-NEXT: {
-; MUSL-NEXT: r19:18 = combine(r3,r2)
-; MUSL-NEXT: memd(r29+#72) = r23:22
-; MUSL-NEXT: memd(r29+#64) = r25:24
-; MUSL-NEXT: } // 8-byte Folded Spill
-; MUSL-NEXT: {
-; MUSL-NEXT: call sinl
-; MUSL-NEXT: r23:22 = memd(r29+#112)
-; MUSL-NEXT: r25:24 = memd(r29+#120)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: call sinl
-; 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: 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: r0 = add(r29,#16)
-; MUSL-NEXT: r3:2 = combine(r23,r22)
-; MUSL-NEXT: r5:4 = combine(r25,r24)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r1:0 = memd(r29+#32)
-; MUSL-NEXT: r3:2 = memd(r29+#40)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r9:8 = memd(r29+#48)
-; MUSL-NEXT: r15:14 = memd(r29+#24)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r5:4 = memd(r29+#0)
-; MUSL-NEXT: r7:6 = memd(r29+#8)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r13:12 = memd(r29+#16)
-; MUSL-NEXT: r11:10 = memd(r29+#56)
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: memd(r20+#56) = r15:14
-; MUSL-NEXT: memd(r20+#48) = r13:12
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: memd(r20+#40) = r11:10
-; MUSL-NEXT: memd(r20+#32) = r9:8
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: memd(r20+#24) = r7:6
-; MUSL-NEXT: memd(r20+#16) = r5:4
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: memd(r20+#8) = r3:2
-; MUSL-NEXT: memd(r20+#0) = r1:0
-; MUSL-NEXT: }
-; MUSL-NEXT: {
-; MUSL-NEXT: r17:16 = memd(r29+#96)
-; MUSL-NEXT: r19:18 = memd(r29+#88)
-; MUSL-NEXT: } // 8-byte Folded Reload
-; MUSL-NEXT: {
-; MUSL-NEXT: r21:20 = memd(r29+#80)
-; MUSL-NEXT: r23:22 = memd(r29+#72)
-; MUSL-NEXT: } // 8-byte Folded Reload
-; MUSL-NEXT: {
-; MUSL-NEXT: r25:24 = memd(r29+#64)
-; MUSL-NEXT: r31:30 = dealloc_return(r30):raw
-; MUSL-NEXT: } // 8-byte Folded Reload
- %result = call { <2 x fp128>, <2 x fp128> } @llvm.sincos.v2f128(<2 x fp128> %a)
- ret { <2 x fp128>, <2 x fp128> } %result
-}
-
attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/LoongArch/llvm.exp10.fp128.ll b/llvm/test/CodeGen/LoongArch/llvm.exp10.fp128.ll
new file mode 100644
index 0000000000000..41d2ffec90333
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/llvm.exp10.fp128.ll
@@ -0,0 +1,61 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
+; RUN: llc -mtriple=loongarch64 -mattr=+d < %s | FileCheck -check-prefix=LA64 %s
+
+; On loongarch64 long double is fp128, so llvm.exp10.f128 lowers to a real
+; libcall (unlike loongarch32, see llvm.exp10.ll).
+
+define fp128 @exp10_f128(fp128 %x) #0 {
+; LA64-LABEL: exp10_f128:
+; LA64: # %bb.0:
+; LA64-NEXT: addi.d $sp, $sp, -16
+; LA64-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
+; LA64-NEXT: pcaddu18i $ra, %call36(exp10l)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
+; LA64-NEXT: addi.d $sp, $sp, 16
+; LA64-NEXT: ret
+ %r = call fp128 @llvm.exp10.f128(fp128 %x)
+ ret fp128 %r
+}
+
+define <2 x fp128> @exp10_v2f128(<2 x fp128> %x) #0 {
+; LA64-LABEL: exp10_v2f128:
+; LA64: # %bb.0:
+; LA64-NEXT: addi.d $sp, $sp, -48
+; LA64-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill
+; LA64-NEXT: st.d $fp, $sp, 32 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s0, $sp, 24 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s1, $sp, 16 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s2, $sp, 8 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s3, $sp, 0 # 8-byte Folded Spill
+; LA64-NEXT: ld.d $fp, $a1, 16
+; LA64-NEXT: ld.d $s0, $a1, 24
+; LA64-NEXT: ld.d $a2, $a1, 0
+; LA64-NEXT: ld.d $a1, $a1, 8
+; LA64-NEXT: move $s1, $a0
+; LA64-NEXT: move $a0, $a2
+; LA64-NEXT: pcaddu18i $ra, %call36(exp10l)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: move $s2, $a0
+; LA64-NEXT: move $s3, $a1
+; LA64-NEXT: move $a0, $fp
+; LA64-NEXT: move $a1, $s0
+; LA64-NEXT: pcaddu18i $ra, %call36(exp10l)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: st.d $a1, $s1, 24
+; LA64-NEXT: st.d $a0, $s1, 16
+; LA64-NEXT: st.d $s3, $s1, 8
+; LA64-NEXT: st.d $s2, $s1, 0
+; LA64-NEXT: ld.d $s3, $sp, 0 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s2, $sp, 8 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s1, $sp, 16 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s0, $sp, 24 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $fp, $sp, 32 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload
+; LA64-NEXT: addi.d $sp, $sp, 48
+; LA64-NEXT: ret
+ %r = call <2 x fp128> @llvm.exp10.v2f128(<2 x fp128> %x)
+ ret <2 x fp128> %r
+}
+
+attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/LoongArch/llvm.exp10.ll b/llvm/test/CodeGen/LoongArch/llvm.exp10.ll
index 030b822c4c45d..f7f2e5158e89d 100644
--- a/llvm/test/CodeGen/LoongArch/llvm.exp10.ll
+++ b/llvm/test/CodeGen/LoongArch/llvm.exp10.ll
@@ -217,145 +217,7 @@ define <2 x double> @exp10_v2f64(<2 x double> %x) #0 {
ret <2 x double> %r
}
-define fp128 @exp10_f128(fp128 %x) #0 {
-; LA32-LABEL: exp10_f128:
-; LA32: # %bb.0:
-; LA32-NEXT: addi.w $sp, $sp, -48
-; LA32-NEXT: st.w $ra, $sp, 44 # 4-byte Folded Spill
-; LA32-NEXT: st.w $fp, $sp, 40 # 4-byte Folded Spill
-; LA32-NEXT: ld.w $a2, $a1, 0
-; LA32-NEXT: ld.w $a3, $a1, 4
-; LA32-NEXT: ld.w $a4, $a1, 8
-; LA32-NEXT: ld.w $a1, $a1, 12
-; LA32-NEXT: move $fp, $a0
-; LA32-NEXT: st.w $a1, $sp, 20
-; LA32-NEXT: st.w $a4, $sp, 16
-; LA32-NEXT: st.w $a3, $sp, 12
-; LA32-NEXT: addi.w $a0, $sp, 24
-; LA32-NEXT: addi.w $a1, $sp, 8
-; LA32-NEXT: st.w $a2, $sp, 8
-; LA32-NEXT: bl exp10l
-; LA32-NEXT: ld.w $a0, $sp, 36
-; LA32-NEXT: ld.w $a1, $sp, 32
-; LA32-NEXT: ld.w $a2, $sp, 28
-; LA32-NEXT: ld.w $a3, $sp, 24
-; LA32-NEXT: st.w $a0, $fp, 12
-; LA32-NEXT: st.w $a1, $fp, 8
-; LA32-NEXT: st.w $a2, $fp, 4
-; LA32-NEXT: st.w $a3, $fp, 0
-; LA32-NEXT: ld.w $fp, $sp, 40 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $ra, $sp, 44 # 4-byte Folded Reload
-; LA32-NEXT: addi.w $sp, $sp, 48
-; LA32-NEXT: ret
-;
-; LA64-LABEL: exp10_f128:
-; LA64: # %bb.0:
-; LA64-NEXT: addi.d $sp, $sp, -16
-; LA64-NEXT: st.d $ra, $sp, 8 # 8-byte Folded Spill
-; LA64-NEXT: pcaddu18i $ra, %call36(exp10l)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: ld.d $ra, $sp, 8 # 8-byte Folded Reload
-; LA64-NEXT: addi.d $sp, $sp, 16
-; LA64-NEXT: ret
- %r = call fp128 @llvm.exp10.f128(fp128 %x)
- ret fp128 %r
-}
-
-define <2 x fp128> @exp10_v2f128(<2 x fp128> %x) #0 {
-; LA32-LABEL: exp10_v2f128:
-; LA32: # %bb.0:
-; LA32-NEXT: addi.w $sp, $sp, -96
-; LA32-NEXT: st.w $ra, $sp, 92 # 4-byte Folded Spill
-; LA32-NEXT: st.w $fp, $sp, 88 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s0, $sp, 84 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s1, $sp, 80 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s2, $sp, 76 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s3, $sp, 72 # 4-byte Folded Spill
-; LA32-NEXT: ld.w $s0, $a1, 16
-; LA32-NEXT: ld.w $s1, $a1, 20
-; LA32-NEXT: ld.w $s2, $a1, 24
-; LA32-NEXT: ld.w $s3, $a1, 28
-; LA32-NEXT: ld.w $a2, $a1, 0
-; LA32-NEXT: ld.w $a3, $a1, 4
-; LA32-NEXT: ld.w $a4, $a1, 8
-; LA32-NEXT: ld.w $a1, $a1, 12
-; LA32-NEXT: move $fp, $a0
-; LA32-NEXT: st.w $a1, $sp, 20
-; LA32-NEXT: st.w $a4, $sp, 16
-; LA32-NEXT: st.w $a3, $sp, 12
-; LA32-NEXT: addi.w $a0, $sp, 24
-; LA32-NEXT: addi.w $a1, $sp, 8
-; LA32-NEXT: st.w $a2, $sp, 8
-; LA32-NEXT: bl exp10l
-; LA32-NEXT: st.w $s3, $sp, 52
-; LA32-NEXT: st.w $s2, $sp, 48
-; LA32-NEXT: st.w $s1, $sp, 44
-; LA32-NEXT: addi.w $a0, $sp, 56
-; LA32-NEXT: addi.w $a1, $sp, 40
-; LA32-NEXT: st.w $s0, $sp, 40
-; LA32-NEXT: bl exp10l
-; LA32-NEXT: ld.w $a0, $sp, 24
-; LA32-NEXT: ld.w $a1, $sp, 28
-; LA32-NEXT: ld.w $a2, $sp, 32
-; LA32-NEXT: ld.w $a3, $sp, 36
-; LA32-NEXT: ld.w $a4, $sp, 68
-; LA32-NEXT: ld.w $a5, $sp, 64
-; LA32-NEXT: ld.w $a6, $sp, 60
-; LA32-NEXT: ld.w $a7, $sp, 56
-; LA32-NEXT: st.w $a4, $fp, 28
-; LA32-NEXT: st.w $a5, $fp, 24
-; LA32-NEXT: st.w $a6, $fp, 20
-; LA32-NEXT: st.w $a7, $fp, 16
-; LA32-NEXT: st.w $a3, $fp, 12
-; LA32-NEXT: st.w $a2, $fp, 8
-; LA32-NEXT: st.w $a1, $fp, 4
-; LA32-NEXT: st.w $a0, $fp, 0
-; LA32-NEXT: ld.w $s3, $sp, 72 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s2, $sp, 76 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s1, $sp, 80 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s0, $sp, 84 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $fp, $sp, 88 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $ra, $sp, 92 # 4-byte Folded Reload
-; LA32-NEXT: addi.w $sp, $sp, 96
-; LA32-NEXT: ret
-;
-; LA64-LABEL: exp10_v2f128:
-; LA64: # %bb.0:
-; LA64-NEXT: addi.d $sp, $sp, -48
-; LA64-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill
-; LA64-NEXT: st.d $fp, $sp, 32 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s0, $sp, 24 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s1, $sp, 16 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s2, $sp, 8 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s3, $sp, 0 # 8-byte Folded Spill
-; LA64-NEXT: ld.d $fp, $a1, 16
-; LA64-NEXT: ld.d $s0, $a1, 24
-; LA64-NEXT: ld.d $a2, $a1, 0
-; LA64-NEXT: ld.d $a1, $a1, 8
-; LA64-NEXT: move $s1, $a0
-; LA64-NEXT: move $a0, $a2
-; LA64-NEXT: pcaddu18i $ra, %call36(exp10l)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: move $s2, $a0
-; LA64-NEXT: move $s3, $a1
-; LA64-NEXT: move $a0, $fp
-; LA64-NEXT: move $a1, $s0
-; LA64-NEXT: pcaddu18i $ra, %call36(exp10l)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: st.d $a1, $s1, 24
-; LA64-NEXT: st.d $a0, $s1, 16
-; LA64-NEXT: st.d $s3, $s1, 8
-; LA64-NEXT: st.d $s2, $s1, 0
-; LA64-NEXT: ld.d $s3, $sp, 0 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s2, $sp, 8 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s1, $sp, 16 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s0, $sp, 24 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $fp, $sp, 32 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload
-; LA64-NEXT: addi.d $sp, $sp, 48
-; LA64-NEXT: ret
- %r = call <2 x fp128> @llvm.exp10.v2f128(<2 x fp128> %x)
- ret <2 x fp128> %r
-}
-
attributes #0 = { nounwind }
+
+; fp128 exp10 has no libcall on loongarch32; tested on loongarch64 in
+; llvm.exp10.fp128.ll.
diff --git a/llvm/test/CodeGen/LoongArch/llvm.sincos.fp128.ll b/llvm/test/CodeGen/LoongArch/llvm.sincos.fp128.ll
new file mode 100644
index 0000000000000..80386e7753333
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/llvm.sincos.fp128.ll
@@ -0,0 +1,111 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
+; RUN: llc --mtriple=loongarch64 --mattr=+d < %s | FileCheck %s --check-prefix=LA64
+
+; On loongarch64 long double is fp128, so llvm.sincos.f128 lowers to a real
+; libcall (unlike loongarch32, see llvm.sincos.ll).
+
+define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
+; LA64-LABEL: test_sincos_f128:
+; LA64: # %bb.0:
+; LA64-NEXT: addi.d $sp, $sp, -48
+; LA64-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill
+; LA64-NEXT: st.d $fp, $sp, 32 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s0, $sp, 24 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s1, $sp, 16 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s2, $sp, 8 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s3, $sp, 0 # 8-byte Folded Spill
+; LA64-NEXT: move $fp, $a2
+; LA64-NEXT: move $s0, $a1
+; LA64-NEXT: move $s1, $a0
+; LA64-NEXT: move $a0, $a1
+; LA64-NEXT: move $a1, $a2
+; LA64-NEXT: pcaddu18i $ra, %call36(sinl)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: move $s2, $a0
+; LA64-NEXT: move $s3, $a1
+; LA64-NEXT: move $a0, $s0
+; LA64-NEXT: move $a1, $fp
+; LA64-NEXT: pcaddu18i $ra, %call36(cosl)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: st.d $a1, $s1, 24
+; LA64-NEXT: st.d $a0, $s1, 16
+; LA64-NEXT: st.d $s3, $s1, 8
+; LA64-NEXT: st.d $s2, $s1, 0
+; LA64-NEXT: ld.d $s3, $sp, 0 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s2, $sp, 8 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s1, $sp, 16 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s0, $sp, 24 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $fp, $sp, 32 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload
+; LA64-NEXT: addi.d $sp, $sp, 48
+; LA64-NEXT: ret
+ %result = call { fp128, fp128 } @llvm.sincos.f128(fp128 %a)
+ ret { fp128, fp128 } %result
+}
+
+define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
+; LA64-LABEL: test_sincos_v2f128:
+; LA64: # %bb.0:
+; LA64-NEXT: addi.d $sp, $sp, -96
+; LA64-NEXT: st.d $ra, $sp, 88 # 8-byte Folded Spill
+; LA64-NEXT: st.d $fp, $sp, 80 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s0, $sp, 72 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s1, $sp, 64 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s2, $sp, 56 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s3, $sp, 48 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s4, $sp, 40 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s5, $sp, 32 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s6, $sp, 24 # 8-byte Folded Spill
+; LA64-NEXT: st.d $s7, $sp, 16 # 8-byte Folded Spill
+; LA64-NEXT: ld.d $fp, $a1, 16
+; LA64-NEXT: ld.d $s0, $a1, 24
+; LA64-NEXT: ld.d $s1, $a1, 0
+; LA64-NEXT: ld.d $s2, $a1, 8
+; LA64-NEXT: move $s3, $a0
+; LA64-NEXT: move $a0, $s1
+; LA64-NEXT: move $a1, $s2
+; LA64-NEXT: pcaddu18i $ra, %call36(sinl)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: move $s4, $a0
+; LA64-NEXT: move $s5, $a1
+; LA64-NEXT: move $a0, $fp
+; LA64-NEXT: move $a1, $s0
+; LA64-NEXT: pcaddu18i $ra, %call36(sinl)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: move $s6, $a0
+; LA64-NEXT: move $s7, $a1
+; LA64-NEXT: move $a0, $s1
+; LA64-NEXT: move $a1, $s2
+; LA64-NEXT: pcaddu18i $ra, %call36(cosl)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: move $s1, $a0
+; LA64-NEXT: move $s2, $a1
+; LA64-NEXT: move $a0, $fp
+; LA64-NEXT: move $a1, $s0
+; LA64-NEXT: pcaddu18i $ra, %call36(cosl)
+; LA64-NEXT: jirl $ra, $ra, 0
+; LA64-NEXT: st.d $a1, $s3, 56
+; LA64-NEXT: st.d $a0, $s3, 48
+; LA64-NEXT: st.d $s2, $s3, 40
+; LA64-NEXT: st.d $s1, $s3, 32
+; LA64-NEXT: st.d $s7, $s3, 24
+; LA64-NEXT: st.d $s6, $s3, 16
+; LA64-NEXT: st.d $s5, $s3, 8
+; LA64-NEXT: st.d $s4, $s3, 0
+; LA64-NEXT: ld.d $s7, $sp, 16 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s6, $sp, 24 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s5, $sp, 32 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s4, $sp, 40 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s3, $sp, 48 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s2, $sp, 56 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s1, $sp, 64 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $s0, $sp, 72 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $fp, $sp, 80 # 8-byte Folded Reload
+; LA64-NEXT: ld.d $ra, $sp, 88 # 8-byte Folded Reload
+; LA64-NEXT: addi.d $sp, $sp, 96
+; LA64-NEXT: ret
+ %result = call { <2 x fp128>, <2 x fp128> } @llvm.sincos.v2f128(<2 x fp128> %a)
+ ret { <2 x fp128>, <2 x fp128> } %result
+}
+
+attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/LoongArch/llvm.sincos.ll b/llvm/test/CodeGen/LoongArch/llvm.sincos.ll
index 4ac38a990b664..226e19e319bf2 100644
--- a/llvm/test/CodeGen/LoongArch/llvm.sincos.ll
+++ b/llvm/test/CodeGen/LoongArch/llvm.sincos.ll
@@ -621,256 +621,7 @@ define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) #0 {
ret { <2 x double>, <2 x double> } %result
}
-define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
-; LA32-LABEL: test_sincos_f128:
-; LA32: # %bb.0:
-; LA32-NEXT: addi.w $sp, $sp, -96
-; LA32-NEXT: st.w $ra, $sp, 92 # 4-byte Folded Spill
-; LA32-NEXT: st.w $fp, $sp, 88 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s0, $sp, 84 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s1, $sp, 80 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s2, $sp, 76 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s3, $sp, 72 # 4-byte Folded Spill
-; LA32-NEXT: ld.w $s0, $a1, 0
-; LA32-NEXT: ld.w $s1, $a1, 4
-; LA32-NEXT: ld.w $s2, $a1, 8
-; LA32-NEXT: ld.w $s3, $a1, 12
-; LA32-NEXT: move $fp, $a0
-; LA32-NEXT: st.w $s3, $sp, 52
-; LA32-NEXT: st.w $s2, $sp, 48
-; LA32-NEXT: st.w $s1, $sp, 44
-; LA32-NEXT: addi.w $a0, $sp, 56
-; LA32-NEXT: addi.w $a1, $sp, 40
-; LA32-NEXT: st.w $s0, $sp, 40
-; LA32-NEXT: bl sinl
-; LA32-NEXT: st.w $s3, $sp, 20
-; LA32-NEXT: st.w $s2, $sp, 16
-; LA32-NEXT: st.w $s1, $sp, 12
-; LA32-NEXT: addi.w $a0, $sp, 24
-; LA32-NEXT: addi.w $a1, $sp, 8
-; LA32-NEXT: st.w $s0, $sp, 8
-; LA32-NEXT: bl cosl
-; LA32-NEXT: ld.w $a0, $sp, 56
-; LA32-NEXT: ld.w $a1, $sp, 60
-; LA32-NEXT: ld.w $a2, $sp, 64
-; LA32-NEXT: ld.w $a3, $sp, 68
-; LA32-NEXT: ld.w $a4, $sp, 36
-; LA32-NEXT: ld.w $a5, $sp, 32
-; LA32-NEXT: ld.w $a6, $sp, 28
-; LA32-NEXT: ld.w $a7, $sp, 24
-; LA32-NEXT: st.w $a4, $fp, 28
-; LA32-NEXT: st.w $a5, $fp, 24
-; LA32-NEXT: st.w $a6, $fp, 20
-; LA32-NEXT: st.w $a7, $fp, 16
-; LA32-NEXT: st.w $a3, $fp, 12
-; LA32-NEXT: st.w $a2, $fp, 8
-; LA32-NEXT: st.w $a1, $fp, 4
-; LA32-NEXT: st.w $a0, $fp, 0
-; LA32-NEXT: ld.w $s3, $sp, 72 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s2, $sp, 76 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s1, $sp, 80 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s0, $sp, 84 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $fp, $sp, 88 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $ra, $sp, 92 # 4-byte Folded Reload
-; LA32-NEXT: addi.w $sp, $sp, 96
-; LA32-NEXT: ret
-;
-; LA64-LABEL: test_sincos_f128:
-; LA64: # %bb.0:
-; LA64-NEXT: addi.d $sp, $sp, -48
-; LA64-NEXT: st.d $ra, $sp, 40 # 8-byte Folded Spill
-; LA64-NEXT: st.d $fp, $sp, 32 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s0, $sp, 24 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s1, $sp, 16 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s2, $sp, 8 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s3, $sp, 0 # 8-byte Folded Spill
-; LA64-NEXT: move $fp, $a2
-; LA64-NEXT: move $s0, $a1
-; LA64-NEXT: move $s1, $a0
-; LA64-NEXT: move $a0, $a1
-; LA64-NEXT: move $a1, $a2
-; LA64-NEXT: pcaddu18i $ra, %call36(sinl)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: move $s2, $a0
-; LA64-NEXT: move $s3, $a1
-; LA64-NEXT: move $a0, $s0
-; LA64-NEXT: move $a1, $fp
-; LA64-NEXT: pcaddu18i $ra, %call36(cosl)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: st.d $a1, $s1, 24
-; LA64-NEXT: st.d $a0, $s1, 16
-; LA64-NEXT: st.d $s3, $s1, 8
-; LA64-NEXT: st.d $s2, $s1, 0
-; LA64-NEXT: ld.d $s3, $sp, 0 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s2, $sp, 8 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s1, $sp, 16 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s0, $sp, 24 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $fp, $sp, 32 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $ra, $sp, 40 # 8-byte Folded Reload
-; LA64-NEXT: addi.d $sp, $sp, 48
-; LA64-NEXT: ret
- %result = call { fp128, fp128 } @llvm.sincos.f128(fp128 %a)
- ret { fp128, fp128 } %result
-}
-
-define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) #0 {
-; LA32-LABEL: test_sincos_v2f128:
-; LA32: # %bb.0:
-; LA32-NEXT: addi.w $sp, $sp, -176
-; LA32-NEXT: st.w $ra, $sp, 172 # 4-byte Folded Spill
-; LA32-NEXT: st.w $fp, $sp, 168 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s0, $sp, 164 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s1, $sp, 160 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s2, $sp, 156 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s3, $sp, 152 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s4, $sp, 148 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s5, $sp, 144 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s6, $sp, 140 # 4-byte Folded Spill
-; LA32-NEXT: st.w $s7, $sp, 136 # 4-byte Folded Spill
-; LA32-NEXT: ld.w $s0, $a1, 16
-; LA32-NEXT: ld.w $s1, $a1, 20
-; LA32-NEXT: ld.w $s2, $a1, 24
-; LA32-NEXT: ld.w $s3, $a1, 28
-; LA32-NEXT: ld.w $s4, $a1, 0
-; LA32-NEXT: ld.w $s5, $a1, 4
-; LA32-NEXT: ld.w $s6, $a1, 8
-; LA32-NEXT: ld.w $s7, $a1, 12
-; LA32-NEXT: move $fp, $a0
-; LA32-NEXT: st.w $s7, $sp, 52
-; LA32-NEXT: st.w $s6, $sp, 48
-; LA32-NEXT: st.w $s5, $sp, 44
-; LA32-NEXT: addi.w $a0, $sp, 56
-; LA32-NEXT: addi.w $a1, $sp, 40
-; LA32-NEXT: st.w $s4, $sp, 40
-; LA32-NEXT: bl sinl
-; LA32-NEXT: st.w $s3, $sp, 116
-; LA32-NEXT: st.w $s2, $sp, 112
-; LA32-NEXT: st.w $s1, $sp, 108
-; LA32-NEXT: addi.w $a0, $sp, 120
-; LA32-NEXT: addi.w $a1, $sp, 104
-; LA32-NEXT: st.w $s0, $sp, 104
-; LA32-NEXT: bl sinl
-; LA32-NEXT: st.w $s7, $sp, 20
-; LA32-NEXT: st.w $s6, $sp, 16
-; LA32-NEXT: st.w $s5, $sp, 12
-; LA32-NEXT: addi.w $a0, $sp, 24
-; LA32-NEXT: addi.w $a1, $sp, 8
-; LA32-NEXT: st.w $s4, $sp, 8
-; LA32-NEXT: bl cosl
-; LA32-NEXT: st.w $s3, $sp, 84
-; LA32-NEXT: st.w $s2, $sp, 80
-; LA32-NEXT: st.w $s1, $sp, 76
-; LA32-NEXT: addi.w $a0, $sp, 88
-; LA32-NEXT: addi.w $a1, $sp, 72
-; LA32-NEXT: st.w $s0, $sp, 72
-; LA32-NEXT: bl cosl
-; LA32-NEXT: ld.w $a0, $sp, 56
-; LA32-NEXT: ld.w $a1, $sp, 60
-; LA32-NEXT: ld.w $a2, $sp, 64
-; LA32-NEXT: ld.w $a3, $sp, 68
-; LA32-NEXT: ld.w $a4, $sp, 120
-; LA32-NEXT: ld.w $a5, $sp, 124
-; LA32-NEXT: ld.w $a6, $sp, 128
-; LA32-NEXT: ld.w $a7, $sp, 132
-; LA32-NEXT: ld.w $t0, $sp, 24
-; LA32-NEXT: ld.w $t1, $sp, 28
-; LA32-NEXT: ld.w $t2, $sp, 32
-; LA32-NEXT: ld.w $t3, $sp, 36
-; LA32-NEXT: ld.w $t4, $sp, 100
-; LA32-NEXT: ld.w $t5, $sp, 96
-; LA32-NEXT: ld.w $t6, $sp, 92
-; LA32-NEXT: ld.w $t7, $sp, 88
-; LA32-NEXT: st.w $t4, $fp, 60
-; LA32-NEXT: st.w $t5, $fp, 56
-; LA32-NEXT: st.w $t6, $fp, 52
-; LA32-NEXT: st.w $t7, $fp, 48
-; LA32-NEXT: st.w $t3, $fp, 44
-; LA32-NEXT: st.w $t2, $fp, 40
-; LA32-NEXT: st.w $t1, $fp, 36
-; LA32-NEXT: st.w $t0, $fp, 32
-; LA32-NEXT: st.w $a7, $fp, 28
-; LA32-NEXT: st.w $a6, $fp, 24
-; LA32-NEXT: st.w $a5, $fp, 20
-; LA32-NEXT: st.w $a4, $fp, 16
-; LA32-NEXT: st.w $a3, $fp, 12
-; LA32-NEXT: st.w $a2, $fp, 8
-; LA32-NEXT: st.w $a1, $fp, 4
-; LA32-NEXT: st.w $a0, $fp, 0
-; LA32-NEXT: ld.w $s7, $sp, 136 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s6, $sp, 140 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s5, $sp, 144 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s4, $sp, 148 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s3, $sp, 152 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s2, $sp, 156 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s1, $sp, 160 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $s0, $sp, 164 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $fp, $sp, 168 # 4-byte Folded Reload
-; LA32-NEXT: ld.w $ra, $sp, 172 # 4-byte Folded Reload
-; LA32-NEXT: addi.w $sp, $sp, 176
-; LA32-NEXT: ret
-;
-; LA64-LABEL: test_sincos_v2f128:
-; LA64: # %bb.0:
-; LA64-NEXT: addi.d $sp, $sp, -96
-; LA64-NEXT: st.d $ra, $sp, 88 # 8-byte Folded Spill
-; LA64-NEXT: st.d $fp, $sp, 80 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s0, $sp, 72 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s1, $sp, 64 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s2, $sp, 56 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s3, $sp, 48 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s4, $sp, 40 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s5, $sp, 32 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s6, $sp, 24 # 8-byte Folded Spill
-; LA64-NEXT: st.d $s7, $sp, 16 # 8-byte Folded Spill
-; LA64-NEXT: ld.d $fp, $a1, 16
-; LA64-NEXT: ld.d $s0, $a1, 24
-; LA64-NEXT: ld.d $s1, $a1, 0
-; LA64-NEXT: ld.d $s2, $a1, 8
-; LA64-NEXT: move $s3, $a0
-; LA64-NEXT: move $a0, $s1
-; LA64-NEXT: move $a1, $s2
-; LA64-NEXT: pcaddu18i $ra, %call36(sinl)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: move $s4, $a0
-; LA64-NEXT: move $s5, $a1
-; LA64-NEXT: move $a0, $fp
-; LA64-NEXT: move $a1, $s0
-; LA64-NEXT: pcaddu18i $ra, %call36(sinl)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: move $s6, $a0
-; LA64-NEXT: move $s7, $a1
-; LA64-NEXT: move $a0, $s1
-; LA64-NEXT: move $a1, $s2
-; LA64-NEXT: pcaddu18i $ra, %call36(cosl)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: move $s1, $a0
-; LA64-NEXT: move $s2, $a1
-; LA64-NEXT: move $a0, $fp
-; LA64-NEXT: move $a1, $s0
-; LA64-NEXT: pcaddu18i $ra, %call36(cosl)
-; LA64-NEXT: jirl $ra, $ra, 0
-; LA64-NEXT: st.d $a1, $s3, 56
-; LA64-NEXT: st.d $a0, $s3, 48
-; LA64-NEXT: st.d $s2, $s3, 40
-; LA64-NEXT: st.d $s1, $s3, 32
-; LA64-NEXT: st.d $s7, $s3, 24
-; LA64-NEXT: st.d $s6, $s3, 16
-; LA64-NEXT: st.d $s5, $s3, 8
-; LA64-NEXT: st.d $s4, $s3, 0
-; LA64-NEXT: ld.d $s7, $sp, 16 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s6, $sp, 24 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s5, $sp, 32 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s4, $sp, 40 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s3, $sp, 48 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s2, $sp, 56 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s1, $sp, 64 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $s0, $sp, 72 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $fp, $sp, 80 # 8-byte Folded Reload
-; LA64-NEXT: ld.d $ra, $sp, 88 # 8-byte Folded Reload
-; LA64-NEXT: addi.d $sp, $sp, 96
-; LA64-NEXT: ret
- %result = call { <2 x fp128>, <2 x fp128> } @llvm.sincos.v2f128(<2 x fp128> %a)
- ret { <2 x fp128>, <2 x fp128> } %result
-}
-
attributes #0 = { nounwind }
+
+; fp128 sincos has no libcall on loongarch32; tested on loongarch64 in
+; llvm.sincos.fp128.ll.
diff --git a/llvm/test/CodeGen/LoongArch/lrint-conv.fp128.ll b/llvm/test/CodeGen/LoongArch/lrint-conv.fp128.ll
new file mode 100644
index 0000000000000..ce16996269287
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/lrint-conv.fp128.ll
@@ -0,0 +1,25 @@
+; fp128 lrint/llrint on loongarch64, where long double is fp128 and the call is
+; the correct-width libcall (unlike loongarch32, see lrint-conv.ll).
+
+; RUN: sed 's/ITy/i32/g' %s | llc -mtriple=loongarch64 | FileCheck %s --check-prefixes=LA64-I32
+; RUN: sed 's/ITy/i64/g' %s | llc -mtriple=loongarch64 | FileCheck %s --check-prefixes=LA64-I64
+
+define ITy @test_lrint_ixx_f128(fp128 %x) nounwind {
+; LA64-I32-LABEL: test_lrint_ixx_f128:
+; LA64-I32: pcaddu18i $ra, %call36(lrintl)
+;
+; LA64-I64-LABEL: test_lrint_ixx_f128:
+; LA64-I64: pcaddu18i $ra, %call36(lrintl)
+ %res = tail call ITy @llvm.lrint.ITy.f128(fp128 %x)
+ ret ITy %res
+}
+
+define ITy @test_llrint_ixx_f128(fp128 %x) nounwind {
+; LA64-I32-LABEL: test_llrint_ixx_f128:
+; LA64-I32: pcaddu18i $ra, %call36(llrintl)
+;
+; LA64-I64-LABEL: test_llrint_ixx_f128:
+; LA64-I64: pcaddu18i $ra, %call36(llrintl)
+ %res = tail call ITy @llvm.llrint.ITy.f128(fp128 %x)
+ ret ITy %res
+}
diff --git a/llvm/test/CodeGen/LoongArch/lrint-conv.ll b/llvm/test/CodeGen/LoongArch/lrint-conv.ll
index 262d1c16a6486..65938c53a2dd3 100644
--- a/llvm/test/CodeGen/LoongArch/lrint-conv.ll
+++ b/llvm/test/CodeGen/LoongArch/lrint-conv.ll
@@ -83,29 +83,5 @@ define ITy @test_llrint_ixx_f64(double %x) nounwind {
ret ITy %res
}
-; FIXME(#44744): incorrect libcall on loongarch32
-define ITy @test_lrint_ixx_f128(fp128 %x) nounwind {
-; LA32-LABEL: test_lrint_ixx_f128:
-; LA32: bl lrintl
-;
-; LA64-I32-LABEL: test_lrint_ixx_f128:
-; LA64-I32: pcaddu18i $ra, %call36(lrintl)
-;
-; LA64-I64-LABEL: test_lrint_ixx_f128:
-; LA64-I64: pcaddu18i $ra, %call36(lrintl)
- %res = tail call ITy @llvm.lrint.ITy.f128(fp128 %x)
- ret ITy %res
-}
-
-define ITy @test_llrint_ixx_f128(fp128 %x) nounwind {
-; LA32-LABEL: test_llrint_ixx_f128:
-; LA32: bl llrintl
-;
-; LA64-I32-LABEL: test_llrint_ixx_f128:
-; LA64-I32: pcaddu18i $ra, %call36(llrintl)
-;
-; LA64-I64-LABEL: test_llrint_ixx_f128:
-; LA64-I64: pcaddu18i $ra, %call36(llrintl)
- %res = tail call ITy @llvm.llrint.ITy.f128(fp128 %x)
- ret ITy %res
-}
+; fp128 lrint/llrint has no libcall on loongarch32; tested on loongarch64 in
+; lrint-conv.fp128.ll.
diff --git a/llvm/test/CodeGen/MSP430/llvm.exp10.ll b/llvm/test/CodeGen/MSP430/llvm.exp10.ll
index 7d4cf7e3fab39..bafb34a8e9652 100644
--- a/llvm/test/CodeGen/MSP430/llvm.exp10.ll
+++ b/llvm/test/CodeGen/MSP430/llvm.exp10.ll
@@ -112,87 +112,4 @@ define <2 x double> @exp10_v2f64(<2 x double> %x) #0 {
ret <2 x double> %r
}
-define fp128 @exp10_f128(fp128 %x) #0 {
-; CHECK-LABEL: exp10_f128:
-; CHECK: ; %bb.0:
-; CHECK-NEXT: push r10
-; CHECK-NEXT: sub #32, r1
-; CHECK-NEXT: mov r12, r10
-; CHECK-NEXT: mov 50(r1), 14(r1)
-; CHECK-NEXT: mov 48(r1), 12(r1)
-; CHECK-NEXT: mov 46(r1), 10(r1)
-; CHECK-NEXT: mov 44(r1), 8(r1)
-; CHECK-NEXT: mov 42(r1), 6(r1)
-; CHECK-NEXT: mov 40(r1), 4(r1)
-; CHECK-NEXT: mov 38(r1), 2(r1)
-; CHECK-NEXT: mov 36(r1), 0(r1)
-; CHECK-NEXT: mov r1, r12
-; CHECK-NEXT: add #16, r12
-; CHECK-NEXT: call #exp10l
-; CHECK-NEXT: mov 30(r1), 14(r10)
-; CHECK-NEXT: mov 28(r1), 12(r10)
-; CHECK-NEXT: mov 26(r1), 10(r10)
-; CHECK-NEXT: mov 24(r1), 8(r10)
-; CHECK-NEXT: mov 22(r1), 6(r10)
-; CHECK-NEXT: mov 20(r1), 4(r10)
-; CHECK-NEXT: mov 18(r1), 2(r10)
-; CHECK-NEXT: mov 16(r1), 0(r10)
-; CHECK-NEXT: add #32, r1
-; CHECK-NEXT: pop r10
-; CHECK-NEXT: ret
- %r = call fp128 @llvm.exp10.f128(fp128 %x)
- ret fp128 %r
-}
-
-define <2 x fp128> @exp10_v2f128(<2 x fp128> %x) #0 {
-; CHECK-LABEL: exp10_v2f128:
-; CHECK: ; %bb.0:
-; CHECK-NEXT: push r10
-; CHECK-NEXT: sub #48, r1
-; CHECK-NEXT: mov r12, r10
-; CHECK-NEXT: mov 82(r1), 14(r1)
-; CHECK-NEXT: mov 80(r1), 12(r1)
-; CHECK-NEXT: mov 78(r1), 10(r1)
-; CHECK-NEXT: mov 76(r1), 8(r1)
-; CHECK-NEXT: mov 74(r1), 6(r1)
-; CHECK-NEXT: mov 72(r1), 4(r1)
-; CHECK-NEXT: mov 70(r1), 2(r1)
-; CHECK-NEXT: mov 68(r1), 0(r1)
-; CHECK-NEXT: mov r1, r12
-; CHECK-NEXT: add #32, r12
-; CHECK-NEXT: call #exp10l
-; CHECK-NEXT: mov 66(r1), 14(r1)
-; CHECK-NEXT: mov 64(r1), 12(r1)
-; CHECK-NEXT: mov 62(r1), 10(r1)
-; CHECK-NEXT: mov 60(r1), 8(r1)
-; CHECK-NEXT: mov 58(r1), 6(r1)
-; CHECK-NEXT: mov 56(r1), 4(r1)
-; CHECK-NEXT: mov 54(r1), 2(r1)
-; CHECK-NEXT: mov 52(r1), 0(r1)
-; CHECK-NEXT: mov r1, r12
-; CHECK-NEXT: add #16, r12
-; CHECK-NEXT: call #exp10l
-; CHECK-NEXT: mov 46(r1), 30(r10)
-; CHECK-NEXT: mov 44(r1), 28(r10)
-; CHECK-NEXT: mov 42(r1), 26(r10)
-; CHECK-NEXT: mov 40(r1), 24(r10)
-; CHECK-NEXT: mov 38(r1), 22(r10)
-; CHECK-NEXT: mov 36(r1), 20(r10)
-; CHECK-NEXT: mov 34(r1), 18(r10)
-; CHECK-NEXT: mov 32(r1), 16(r10)
-; CHECK-NEXT: mov 30(r1), 14(r10)
-; CHECK-NEXT: mov 28(r1), 12(r10)
-; CHECK-NEXT: mov 26(r1), 10(r10)
-; CHECK-NEXT: mov 24(r1), 8(r10)
-; CHECK-NEXT: mov 22(r1), 6(r10)
-; CHECK-NEXT: mov 20(r1), 4(r10)
-; CHECK-NEXT: mov 18(r1), 2(r10)
-; CHECK-NEXT: mov 16(r1), 0(r10)
-; CHECK-NEXT: add #48, r1
-; CHECK-NEXT: pop r10
-; CHECK-NEXT: ret
- %r = call <2 x fp128> @llvm.exp10.v2f128(<2 x fp128> %x)
- ret <2 x fp128> %r
-}
-
attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/MSP430/llvm.sincos.ll b/llvm/test/CodeGen/MSP430/llvm.sincos.ll
index c28c10d24ea6d..797b167ffe504 100644
--- a/llvm/test/CodeGen/MSP430/llvm.sincos.ll
+++ b/llvm/test/CodeGen/MSP430/llvm.sincos.ll
@@ -275,77 +275,4 @@ define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) #0 {
ret { <2 x double>, <2 x double> } %result
}
-define { fp128, fp128 } @test_sincos_f128(fp128 %a) #0 {
-; CHECK-LABEL: test_sincos_f128:
-; CHECK: ; %bb.0:
-; CHECK-NEXT: push r4
-; CHECK-NEXT: push r5
-; CHECK-NEXT: push r6
-; CHECK-NEXT: push r7
-; CHECK-NEXT: push r8
-; CHECK-NEXT: push r9
-; CHECK-NEXT: push r10
-; CHECK-NEXT: sub #48, r1
-; CHECK-NEXT: mov r12, r10
-; CHECK-NEXT: mov 78(r1), r12
-; CHECK-NEXT: mov r12, 14(r1)
-; CHECK-NEXT: mov 76(r1), r12
-; CHECK-NEXT: mov r12, 12(r1)
-; CHECK-NEXT: mov 74(r1), r7
-; CHECK-NEXT: mov r7, 10(r1)
-; CHECK-NEXT: mov 72(r1), r6
-; CHECK-NEXT: mov r6, 8(r1)
-; CHECK-NEXT: mov 70(r1), r5
-; CHECK-NEXT: mov r5, 6(r1)
-; CHECK-NEXT: mov 68(r1), r4
-; CHECK-NEXT: mov r4, 4(r1)
-; CHECK-NEXT: mov 66(r1), r9
-; CHECK-NEXT: mov r9, 2(r1)
-; CHECK-NEXT: mov 64(r1), r8
-; CHECK-NEXT: mov r8, 0(r1)
-; CHECK-NEXT: mov r1, r12
-; CHECK-NEXT: add #16, r12
-; CHECK-NEXT: call #cosl
-; CHECK-NEXT: mov 78(r1), r12
-; CHECK-NEXT: mov r12, 14(r1)
-; CHECK-NEXT: mov 76(r1), r12
-; CHECK-NEXT: mov r12, 12(r1)
-; CHECK-NEXT: mov r7, 10(r1)
-; CHECK-NEXT: mov r6, 8(r1)
-; CHECK-NEXT: mov r5, 6(r1)
-; CHECK-NEXT: mov r4, 4(r1)
-; CHECK-NEXT: mov r9, 2(r1)
-; CHECK-NEXT: mov r8, 0(r1)
-; CHECK-NEXT: mov r1, r12
-; CHECK-NEXT: add #32, r12
-; CHECK-NEXT: call #sinl
-; CHECK-NEXT: mov 30(r1), 30(r10)
-; CHECK-NEXT: mov 28(r1), 28(r10)
-; CHECK-NEXT: mov 26(r1), 26(r10)
-; CHECK-NEXT: mov 24(r1), 24(r10)
-; CHECK-NEXT: mov 22(r1), 22(r10)
-; CHECK-NEXT: mov 20(r1), 20(r10)
-; CHECK-NEXT: mov 18(r1), 18(r10)
-; CHECK-NEXT: mov 16(r1), 16(r10)
-; CHECK-NEXT: mov 46(r1), 14(r10)
-; CHECK-NEXT: mov 44(r1), 12(r10)
-; CHECK-NEXT: mov 42(r1), 10(r10)
-; CHECK-NEXT: mov 40(r1), 8(r10)
-; CHECK-NEXT: mov 38(r1), 6(r10)
-; CHECK-NEXT: mov 36(r1), 4(r10)
-; CHECK-NEXT: mov 34(r1), 2(r10)
-; CHECK-NEXT: mov 32(r1), 0(r10)
-; CHECK-NEXT: add #48, r1
-; CHECK-NEXT: pop r10
-; CHECK-NEXT: pop r9
-; CHECK-NEXT: pop r8
-; CHECK-NEXT: pop r7
-; CHECK-NEXT: pop r6
-; CHECK-NEXT: pop r5
-; CHECK-NEXT: pop r4
-; CHECK-NEXT: ret
- %result = call { fp128, fp128 } @llvm.sincos.f16(fp128 %a)
- ret { fp128, fp128 } %result
-}
-
attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/MSP430/lrint-conv.ll b/llvm/test/CodeGen/MSP430/lrint-conv.ll
index 04ab2af6102a0..9ea8851a037c0 100644
--- a/llvm/test/CodeGen/MSP430/lrint-conv.ll
+++ b/llvm/test/CodeGen/MSP430/lrint-conv.ll
@@ -18,43 +18,36 @@
define ITy @test_lrint_ixx_f32(float %x) nounwind {
; CHECK-LABEL: test_lrint_ixx_f32:
-; CHECK: call #lrintf
+; CHECK: ; %bb.0:
+; CHECK-NEXT: call #lrintf
+; CHECK-NEXT: ret
%res = tail call ITy @llvm.lrint.ITy.f32(float %x)
ret ITy %res
}
define ITy @test_llrint_ixx_f32(float %x) nounwind {
; CHECK-LABEL: test_llrint_ixx_f32:
-; CHECK: call #llrintf
+; CHECK: ; %bb.0:
+; CHECK-NEXT: call #llrintf
+; CHECK-NEXT: ret
%res = tail call ITy @llvm.llrint.ITy.f32(float %x)
ret ITy %res
}
define ITy @test_lrint_ixx_f64(double %x) nounwind {
; CHECK-LABEL: test_lrint_ixx_f64:
-; CHECK: call #lrint
+; CHECK: ; %bb.0:
+; CHECK-NEXT: call #lrint
+; CHECK-NEXT: ret
%res = tail call ITy @llvm.lrint.ITy.f64(double %x)
ret ITy %res
}
define ITy @test_llrint_ixx_f64(double %x) nounwind {
; CHECK-LABEL: test_llrint_ixx_f64:
-; CHECK: call #llrint
+; CHECK: ; %bb.0:
+; CHECK-NEXT: call #llrint
+; CHECK-NEXT: ret
%res = tail call ITy @llvm.llrint.ITy.f64(double %x)
ret ITy %res
}
-
-; FIXME(#44744): incorrect libcall
-define ITy @test_lrint_ixx_f128(fp128 %x) nounwind {
-; CHECK-LABEL: test_lrint_ixx_f128:
-; CHECK: call #lrintl
- %res = tail call ITy @llvm.lrint.ITy.f128(fp128 %x)
- ret ITy %res
-}
-
-define ITy @test_llrint_ixx_f128(fp128 %x) nounwind {
-; CHECK-LABEL: test_llrint_ixx_f128:
-; CHECK: call #llrintl
- %res = tail call ITy @llvm.llrint.ITy.f128(fp128 %x)
- ret ITy %res
-}
diff --git a/llvm/test/CodeGen/Mips/ldexp.ll b/llvm/test/CodeGen/Mips/ldexp.ll
index 5014c46b87939..8d266e2fb7017 100644
--- a/llvm/test/CodeGen/Mips/ldexp.ll
+++ b/llvm/test/CodeGen/Mips/ldexp.ll
@@ -125,21 +125,6 @@ define half @ldexp_f16(half %arg0, i32 %arg1) nounwind {
ret half %ldexp
}
-define fp128 @ldexp_f128(fp128 %arg0, i32 %arg1) nounwind {
-; SOFT-LABEL: ldexp_f128:
-; SOFT: # %bb.0:
-; SOFT-NEXT: addiu $sp, $sp, -32
-; SOFT-NEXT: sw $ra, 28($sp) # 4-byte Folded Spill
-; SOFT-NEXT: lw $1, 48($sp)
-; SOFT-NEXT: jal ldexpl
-; SOFT-NEXT: sw $1, 16($sp)
-; SOFT-NEXT: lw $ra, 28($sp) # 4-byte Folded Reload
-; SOFT-NEXT: jr $ra
-; SOFT-NEXT: addiu $sp, $sp, 32
- %ldexp = call fp128 @llvm.ldexp.f128.i32(fp128 %arg0, i32 %arg1)
- ret fp128 %ldexp
-}
-
declare double @llvm.ldexp.f64.i32(double, i32) #0
declare float @llvm.ldexp.f32.i32(float, i32) #0
declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) #0
diff --git a/llvm/test/CodeGen/Mips/llrint-conv-fp128.ll b/llvm/test/CodeGen/Mips/llrint-conv-fp128.ll
new file mode 100644
index 0000000000000..00a03d7b09b84
--- /dev/null
+++ b/llvm/test/CodeGen/Mips/llrint-conv-fp128.ll
@@ -0,0 +1,23 @@
+; RUN: llc < %s -mtriple=mips64el -mattr=+soft-float | FileCheck %s
+
+; fp128 llrint is only available on mips64, where long double is fp128 and the
+; `l`-suffixed call is the correct-width fp128 libcall.
+
+define signext i32 @testmswl(fp128 %x) {
+; CHECK-LABEL: testmswl:
+; CHECK: jal llrintl
+entry:
+ %0 = tail call i64 @llvm.llrint.i64.f128(fp128 %x)
+ %conv = trunc i64 %0 to i32
+ ret i32 %conv
+}
+
+define i64 @testmsll(fp128 %x) {
+; CHECK-LABEL: testmsll:
+; CHECK: jal llrintl
+entry:
+ %0 = tail call i64 @llvm.llrint.i64.f128(fp128 %x)
+ ret i64 %0
+}
+
+declare i64 @llvm.llrint.i64.f128(fp128) nounwind readnone
diff --git a/llvm/test/CodeGen/Mips/llrint-conv.ll b/llvm/test/CodeGen/Mips/llrint-conv.ll
index 0e449b77f515f..e04a006d9a744 100644
--- a/llvm/test/CodeGen/Mips/llrint-conv.ll
+++ b/llvm/test/CodeGen/Mips/llrint-conv.ll
@@ -52,23 +52,8 @@ entry:
ret i64 %0
}
-define signext i32 @testmswl(fp128 %x) {
-; CHECK-LABEL: testmswl:
-; CHECK: jal llrintl
-entry:
- %0 = tail call i64 @llvm.llrint.i64.f128(fp128 %x)
- %conv = trunc i64 %0 to i32
- ret i32 %conv
-}
-
-define i64 @testmsll(fp128 %x) {
-; CHECK-LABEL: testmsll:
-; CHECK: jal llrintl
-entry:
- %0 = tail call i64 @llvm.llrint.i64.f128(fp128 %x)
- ret i64 %0
-}
+; fp128 llrint has no libcall on mips (o32); tested on mips64 in
+; llrint-conv-fp128.ll.
declare i64 @llvm.llrint.i64.f32(float) nounwind readnone
declare i64 @llvm.llrint.i64.f64(double) nounwind readnone
-declare i64 @llvm.llrint.i64.f128(fp128) nounwind readnone
diff --git a/llvm/test/CodeGen/Mips/llvm.frexp.ll b/llvm/test/CodeGen/Mips/llvm.frexp.ll
index 69ad5fef7c66e..f47c6b1082e8c 100644
--- a/llvm/test/CodeGen/Mips/llvm.frexp.ll
+++ b/llvm/test/CodeGen/Mips/llvm.frexp.ll
@@ -438,202 +438,6 @@ define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) noun
ret { <2 x double>, <2 x i32> } %result
}
-define { fp128, i32 } @test_frexp_fp128_i32(fp128 %a) nounwind {
-; MIPSEL-LABEL: test_frexp_fp128_i32:
-; MIPSEL: # %bb.0:
-; MIPSEL-NEXT: addiu $sp, $sp, -40
-; MIPSEL-NEXT: sw $ra, 36($sp) # 4-byte Folded Spill
-; MIPSEL-NEXT: sw $16, 32($sp) # 4-byte Folded Spill
-; MIPSEL-NEXT: move $1, $7
-; MIPSEL-NEXT: move $16, $4
-; MIPSEL-NEXT: addiu $2, $sp, 28
-; MIPSEL-NEXT: sw $2, 16($sp)
-; MIPSEL-NEXT: lw $7, 56($sp)
-; MIPSEL-NEXT: move $4, $5
-; MIPSEL-NEXT: move $5, $6
-; MIPSEL-NEXT: jal frexpl
-; MIPSEL-NEXT: move $6, $1
-; MIPSEL-NEXT: sw $5, 12($16)
-; MIPSEL-NEXT: sw $4, 8($16)
-; MIPSEL-NEXT: sw $3, 4($16)
-; MIPSEL-NEXT: sw $2, 0($16)
-; MIPSEL-NEXT: lw $1, 28($sp)
-; MIPSEL-NEXT: sw $1, 16($16)
-; MIPSEL-NEXT: lw $16, 32($sp) # 4-byte Folded Reload
-; MIPSEL-NEXT: lw $ra, 36($sp) # 4-byte Folded Reload
-; MIPSEL-NEXT: jr $ra
-; MIPSEL-NEXT: addiu $sp, $sp, 40
-;
-; SOFT-FLOAT-32-LABEL: test_frexp_fp128_i32:
-; SOFT-FLOAT-32: # %bb.0:
-; SOFT-FLOAT-32-NEXT: addiu $sp, $sp, -40
-; SOFT-FLOAT-32-NEXT: sw $ra, 36($sp) # 4-byte Folded Spill
-; SOFT-FLOAT-32-NEXT: sw $16, 32($sp) # 4-byte Folded Spill
-; SOFT-FLOAT-32-NEXT: move $1, $7
-; SOFT-FLOAT-32-NEXT: move $16, $4
-; SOFT-FLOAT-32-NEXT: addiu $2, $sp, 28
-; SOFT-FLOAT-32-NEXT: sw $2, 16($sp)
-; SOFT-FLOAT-32-NEXT: lw $7, 56($sp)
-; SOFT-FLOAT-32-NEXT: move $4, $5
-; SOFT-FLOAT-32-NEXT: move $5, $6
-; SOFT-FLOAT-32-NEXT: jal frexpl
-; SOFT-FLOAT-32-NEXT: move $6, $1
-; SOFT-FLOAT-32-NEXT: sw $5, 12($16)
-; SOFT-FLOAT-32-NEXT: sw $4, 8($16)
-; SOFT-FLOAT-32-NEXT: sw $3, 4($16)
-; SOFT-FLOAT-32-NEXT: sw $2, 0($16)
-; SOFT-FLOAT-32-NEXT: lw $1, 28($sp)
-; SOFT-FLOAT-32-NEXT: sw $1, 16($16)
-; SOFT-FLOAT-32-NEXT: lw $16, 32($sp) # 4-byte Folded Reload
-; SOFT-FLOAT-32-NEXT: lw $ra, 36($sp) # 4-byte Folded Reload
-; SOFT-FLOAT-32-NEXT: jr $ra
-; SOFT-FLOAT-32-NEXT: addiu $sp, $sp, 40
-;
-; SOFT-FLOAT-64-LABEL: test_frexp_fp128_i32:
-; SOFT-FLOAT-64: # %bb.0:
-; SOFT-FLOAT-64-NEXT: daddiu $sp, $sp, -16
-; SOFT-FLOAT-64-NEXT: sd $ra, 8($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: jal frexpl
-; SOFT-FLOAT-64-NEXT: daddiu $6, $sp, 4
-; SOFT-FLOAT-64-NEXT: lw $2, 4($sp)
-; SOFT-FLOAT-64-NEXT: ld $ra, 8($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: jr $ra
-; SOFT-FLOAT-64-NEXT: daddiu $sp, $sp, 16
- %result = call { fp128, i32 } @llvm.frexp.fp128.i32(fp128 %a)
- ret { fp128, i32 } %result
-}
-
-define { <2 x fp128>, <2 x i32> } @test_frexp_v2fp128_v2i32(<2 x fp128> %a) nounwind {
-; MIPSEL-LABEL: test_frexp_v2fp128_v2i32:
-; MIPSEL: # %bb.0:
-; MIPSEL-NEXT: addiu $sp, $sp, -48
-; MIPSEL-NEXT: sw $ra, 44($sp) # 4-byte Folded Spill
-; MIPSEL-NEXT: sw $18, 40($sp) # 4-byte Folded Spill
-; MIPSEL-NEXT: sw $17, 36($sp) # 4-byte Folded Spill
-; MIPSEL-NEXT: sw $16, 32($sp) # 4-byte Folded Spill
-; MIPSEL-NEXT: move $16, $7
-; MIPSEL-NEXT: move $17, $6
-; MIPSEL-NEXT: move $18, $4
-; MIPSEL-NEXT: addiu $1, $sp, 28
-; MIPSEL-NEXT: sw $1, 16($sp)
-; MIPSEL-NEXT: lw $4, 72($sp)
-; MIPSEL-NEXT: lw $5, 76($sp)
-; MIPSEL-NEXT: lw $6, 80($sp)
-; MIPSEL-NEXT: lw $7, 84($sp)
-; MIPSEL-NEXT: jal frexpl
-; MIPSEL-NEXT: nop
-; MIPSEL-NEXT: addiu $1, $sp, 24
-; MIPSEL-NEXT: sw $1, 16($sp)
-; MIPSEL-NEXT: lw $7, 68($sp)
-; MIPSEL-NEXT: lw $6, 64($sp)
-; MIPSEL-NEXT: sw $5, 28($18)
-; MIPSEL-NEXT: sw $4, 24($18)
-; MIPSEL-NEXT: sw $3, 20($18)
-; MIPSEL-NEXT: sw $2, 16($18)
-; MIPSEL-NEXT: move $4, $17
-; MIPSEL-NEXT: jal frexpl
-; MIPSEL-NEXT: move $5, $16
-; MIPSEL-NEXT: sw $5, 12($18)
-; MIPSEL-NEXT: sw $4, 8($18)
-; MIPSEL-NEXT: sw $3, 4($18)
-; MIPSEL-NEXT: sw $2, 0($18)
-; MIPSEL-NEXT: lw $1, 28($sp)
-; MIPSEL-NEXT: sw $1, 36($18)
-; MIPSEL-NEXT: lw $1, 24($sp)
-; MIPSEL-NEXT: sw $1, 32($18)
-; MIPSEL-NEXT: lw $16, 32($sp) # 4-byte Folded Reload
-; MIPSEL-NEXT: lw $17, 36($sp) # 4-byte Folded Reload
-; MIPSEL-NEXT: lw $18, 40($sp) # 4-byte Folded Reload
-; MIPSEL-NEXT: lw $ra, 44($sp) # 4-byte Folded Reload
-; MIPSEL-NEXT: jr $ra
-; MIPSEL-NEXT: addiu $sp, $sp, 48
-;
-; SOFT-FLOAT-32-LABEL: test_frexp_v2fp128_v2i32:
-; SOFT-FLOAT-32: # %bb.0:
-; SOFT-FLOAT-32-NEXT: addiu $sp, $sp, -48
-; SOFT-FLOAT-32-NEXT: sw $ra, 44($sp) # 4-byte Folded Spill
-; SOFT-FLOAT-32-NEXT: sw $18, 40($sp) # 4-byte Folded Spill
-; SOFT-FLOAT-32-NEXT: sw $17, 36($sp) # 4-byte Folded Spill
-; SOFT-FLOAT-32-NEXT: sw $16, 32($sp) # 4-byte Folded Spill
-; SOFT-FLOAT-32-NEXT: move $16, $7
-; SOFT-FLOAT-32-NEXT: move $17, $6
-; SOFT-FLOAT-32-NEXT: move $18, $4
-; SOFT-FLOAT-32-NEXT: addiu $1, $sp, 28
-; SOFT-FLOAT-32-NEXT: sw $1, 16($sp)
-; SOFT-FLOAT-32-NEXT: lw $4, 72($sp)
-; SOFT-FLOAT-32-NEXT: lw $5, 76($sp)
-; SOFT-FLOAT-32-NEXT: lw $6, 80($sp)
-; SOFT-FLOAT-32-NEXT: lw $7, 84($sp)
-; SOFT-FLOAT-32-NEXT: jal frexpl
-; SOFT-FLOAT-32-NEXT: nop
-; SOFT-FLOAT-32-NEXT: addiu $1, $sp, 24
-; SOFT-FLOAT-32-NEXT: sw $1, 16($sp)
-; SOFT-FLOAT-32-NEXT: lw $7, 68($sp)
-; SOFT-FLOAT-32-NEXT: lw $6, 64($sp)
-; SOFT-FLOAT-32-NEXT: sw $5, 28($18)
-; SOFT-FLOAT-32-NEXT: sw $4, 24($18)
-; SOFT-FLOAT-32-NEXT: sw $3, 20($18)
-; SOFT-FLOAT-32-NEXT: sw $2, 16($18)
-; SOFT-FLOAT-32-NEXT: move $4, $17
-; SOFT-FLOAT-32-NEXT: jal frexpl
-; SOFT-FLOAT-32-NEXT: move $5, $16
-; SOFT-FLOAT-32-NEXT: sw $5, 12($18)
-; SOFT-FLOAT-32-NEXT: sw $4, 8($18)
-; SOFT-FLOAT-32-NEXT: sw $3, 4($18)
-; SOFT-FLOAT-32-NEXT: sw $2, 0($18)
-; SOFT-FLOAT-32-NEXT: lw $1, 28($sp)
-; SOFT-FLOAT-32-NEXT: sw $1, 36($18)
-; SOFT-FLOAT-32-NEXT: lw $1, 24($sp)
-; SOFT-FLOAT-32-NEXT: sw $1, 32($18)
-; SOFT-FLOAT-32-NEXT: lw $16, 32($sp) # 4-byte Folded Reload
-; SOFT-FLOAT-32-NEXT: lw $17, 36($sp) # 4-byte Folded Reload
-; SOFT-FLOAT-32-NEXT: lw $18, 40($sp) # 4-byte Folded Reload
-; SOFT-FLOAT-32-NEXT: lw $ra, 44($sp) # 4-byte Folded Reload
-; SOFT-FLOAT-32-NEXT: jr $ra
-; SOFT-FLOAT-32-NEXT: addiu $sp, $sp, 48
-;
-; SOFT-FLOAT-64-LABEL: test_frexp_v2fp128_v2i32:
-; SOFT-FLOAT-64: # %bb.0:
-; SOFT-FLOAT-64-NEXT: daddiu $sp, $sp, -64
-; SOFT-FLOAT-64-NEXT: sdc1 $f25, 56($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: sdc1 $f24, 48($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: sd $ra, 40($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: sd $18, 32($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: sd $17, 24($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: sd $16, 16($sp) # 8-byte Folded Spill
-; SOFT-FLOAT-64-NEXT: move $16, $6
-; SOFT-FLOAT-64-NEXT: move $17, $5
-; SOFT-FLOAT-64-NEXT: move $18, $4
-; SOFT-FLOAT-64-NEXT: dmtc1 $7, $f12
-; SOFT-FLOAT-64-NEXT: dmtc1 $8, $f13
-; SOFT-FLOAT-64-NEXT: jal frexpl
-; SOFT-FLOAT-64-NEXT: daddiu $6, $sp, 12
-; SOFT-FLOAT-64-NEXT: mov.d $f24, $f0
-; SOFT-FLOAT-64-NEXT: mov.d $f25, $f2
-; SOFT-FLOAT-64-NEXT: dmtc1 $17, $f12
-; SOFT-FLOAT-64-NEXT: dmtc1 $16, $f13
-; SOFT-FLOAT-64-NEXT: daddiu $6, $sp, 8
-; SOFT-FLOAT-64-NEXT: lw $1, 12($sp)
-; SOFT-FLOAT-64-NEXT: jal frexpl
-; SOFT-FLOAT-64-NEXT: sw $1, 36($18)
-; SOFT-FLOAT-64-NEXT: lw $1, 8($sp)
-; SOFT-FLOAT-64-NEXT: sw $1, 32($18)
-; SOFT-FLOAT-64-NEXT: sdc1 $f25, 24($18)
-; SOFT-FLOAT-64-NEXT: sdc1 $f24, 16($18)
-; SOFT-FLOAT-64-NEXT: sdc1 $f2, 8($18)
-; SOFT-FLOAT-64-NEXT: sdc1 $f0, 0($18)
-; SOFT-FLOAT-64-NEXT: ld $16, 16($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: ld $17, 24($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: ld $18, 32($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: ld $ra, 40($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: ldc1 $f24, 48($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: ldc1 $f25, 56($sp) # 8-byte Folded Reload
-; SOFT-FLOAT-64-NEXT: jr $ra
-; SOFT-FLOAT-64-NEXT: daddiu $sp, $sp, 64
- %result = call { <2 x fp128>, <2 x i32> } @llvm.frexp.v2fp128.v2i32(<2 x fp128> %a)
- ret { <2 x fp128>, <2 x i32> } %result
-}
-
declare { half, i32 } @llvm.frexp.f16.i32(half) #0
declare { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half>) #0
diff --git a/llvm/test/CodeGen/Mips/lrint-conv-fp128.ll b/llvm/test/CodeGen/Mips/lrint-conv-fp128.ll
new file mode 100644
index 0000000000000..f19639f4c23a3
--- /dev/null
+++ b/llvm/test/CodeGen/Mips/lrint-conv-fp128.ll
@@ -0,0 +1,23 @@
+; RUN: llc < %s -mtriple=mips64el -mattr=+soft-float | FileCheck %s
+
+; fp128 lrint is only available on mips64, where long double is fp128 and the
+; `l`-suffixed call is the correct-width fp128 libcall.
+
+define signext i32 @testmswl(fp128 %x) {
+; CHECK-LABEL: testmswl:
+; CHECK: jal lrintl
+entry:
+ %0 = tail call i64 @llvm.lrint.i64.f128(fp128 %x)
+ %conv = trunc i64 %0 to i32
+ ret i32 %conv
+}
+
+define signext i64 @testmsll(fp128 %x) {
+; CHECK-LABEL: testmsll:
+; CHECK: jal lrintl
+entry:
+ %0 = tail call i64 @llvm.lrint.i64.f128(fp128 %x)
+ ret i64 %0
+}
+
+declare i64 @llvm.lrint.i64.f128(fp128) nounwind readnone
diff --git a/llvm/test/CodeGen/Mips/lrint-conv.ll b/llvm/test/CodeGen/Mips/lrint-conv.ll
index 64c5cb9ac5b07..98388741c4366 100644
--- a/llvm/test/CodeGen/Mips/lrint-conv.ll
+++ b/llvm/test/CodeGen/Mips/lrint-conv.ll
@@ -52,23 +52,8 @@ entry:
ret i64 %0
}
-define signext i32 @testmswl(fp128 %x) {
-; CHECK-LABEL: testmswl:
-; CHECK: jal lrintl
-entry:
- %0 = tail call i64 @llvm.lrint.i64.f128(fp128 %x)
- %conv = trunc i64 %0 to i32
- ret i32 %conv
-}
-
-define signext i64 @testmsll(fp128 %x) {
-; CHECK-LABEL: testmsll:
-; CHECK: jal lrintl
-entry:
- %0 = tail call i64 @llvm.lrint.i64.f128(fp128 %x)
- ret i64 %0
-}
+; fp128 lrint has no libcall on mips (o32); tested on mips64 in
+; lrint-conv-fp128.ll.
declare i64 @llvm.lrint.i64.f32(float) nounwind readnone
declare i64 @llvm.lrint.i64.f64(double) nounwind readnone
-declare i64 @llvm.lrint.i64.f128(fp128) nounwind readnone
diff --git a/llvm/test/CodeGen/RISCV/fp128.ll b/llvm/test/CodeGen/RISCV/fp128.ll
index 9beecf0c025c8..19a4a50723513 100644
--- a/llvm/test/CodeGen/RISCV/fp128.ll
+++ b/llvm/test/CodeGen/RISCV/fp128.ll
@@ -573,3 +573,48 @@ define i32 @lround_f128() nounwind {
%r = call i32 @llvm.lround.f128(fp128 %1)
ret i32 %r
}
+
+; fp128 ldexp lowers to ldexpl (long double is fp128).
+define fp128 @ldexp_f128(fp128 %x, i32 %y) nounwind {
+; RV32I-LABEL: ldexp_f128:
+; RV32I: # %bb.0:
+; RV32I-NEXT: addi sp, sp, -48
+; RV32I-NEXT: sw ra, 44(sp) # 4-byte Folded Spill
+; RV32I-NEXT: sw s0, 40(sp) # 4-byte Folded Spill
+; RV32I-NEXT: lw a3, 0(a1)
+; RV32I-NEXT: lw a4, 4(a1)
+; RV32I-NEXT: lw a5, 8(a1)
+; RV32I-NEXT: lw a6, 12(a1)
+; RV32I-NEXT: mv s0, a0
+; RV32I-NEXT: sw a3, 8(sp)
+; RV32I-NEXT: sw a4, 12(sp)
+; RV32I-NEXT: addi a0, sp, 24
+; RV32I-NEXT: addi a1, sp, 8
+; RV32I-NEXT: sw a5, 16(sp)
+; RV32I-NEXT: sw a6, 20(sp)
+; RV32I-NEXT: call ldexpl
+; RV32I-NEXT: lw a0, 24(sp)
+; RV32I-NEXT: lw a1, 28(sp)
+; RV32I-NEXT: lw a2, 32(sp)
+; RV32I-NEXT: lw a3, 36(sp)
+; RV32I-NEXT: sw a0, 0(s0)
+; RV32I-NEXT: sw a1, 4(s0)
+; RV32I-NEXT: sw a2, 8(s0)
+; RV32I-NEXT: sw a3, 12(s0)
+; RV32I-NEXT: lw ra, 44(sp) # 4-byte Folded Reload
+; RV32I-NEXT: lw s0, 40(sp) # 4-byte Folded Reload
+; RV32I-NEXT: addi sp, sp, 48
+; RV32I-NEXT: ret
+;
+; RV64I-LABEL: ldexp_f128:
+; RV64I: # %bb.0:
+; RV64I-NEXT: addi sp, sp, -16
+; RV64I-NEXT: sd ra, 8(sp) # 8-byte Folded Spill
+; RV64I-NEXT: sext.w a2, a2
+; RV64I-NEXT: call ldexpl
+; RV64I-NEXT: ld ra, 8(sp) # 8-byte Folded Reload
+; RV64I-NEXT: addi sp, sp, 16
+; RV64I-NEXT: ret
+ %z = call fp128 @llvm.ldexp.f128.i32(fp128 %x, i32 %y)
+ ret fp128 %z
+}
diff --git a/llvm/test/CodeGen/X86/fminimum-fmaximum-i686.ll b/llvm/test/CodeGen/X86/fminimum-fmaximum-i686.ll
index fd28605c6522b..7021b7fcef085 100644
--- a/llvm/test/CodeGen/X86/fminimum-fmaximum-i686.ll
+++ b/llvm/test/CodeGen/X86/fminimum-fmaximum-i686.ll
@@ -170,56 +170,6 @@ define double @maximum_double(double %x, double %y) nounwind {
ret double %res
}
-define fp128 @maximum_fp128(fp128 %x, fp128 %y) nounwind {
-; CHECK-LABEL: maximum_fp128:
-; CHECK: # %bb.0:
-; CHECK-NEXT: pushl %ebp
-; CHECK-NEXT: movl %esp, %ebp
-; CHECK-NEXT: pushl %ebx
-; CHECK-NEXT: pushl %edi
-; CHECK-NEXT: pushl %esi
-; CHECK-NEXT: andl $-16, %esp
-; CHECK-NEXT: subl $80, %esp
-; CHECK-NEXT: movl 8(%ebp), %esi
-; CHECK-NEXT: movl 36(%ebp), %edi
-; CHECK-NEXT: movl 40(%ebp), %ebx
-; CHECK-NEXT: movl 44(%ebp), %edx
-; CHECK-NEXT: movl 48(%ebp), %ecx
-; CHECK-NEXT: movl 52(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl 32(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl 28(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl 24(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: leal {{[0-9]+}}(%esp), %eax
-; CHECK-NEXT: movl %eax, (%esp)
-; CHECK-NEXT: calll fmaximuml
-; CHECK-NEXT: subl $4, %esp
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %edx
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %edi
-; CHECK-NEXT: movl %edi, 12(%esi)
-; CHECK-NEXT: movl %edx, 8(%esi)
-; CHECK-NEXT: movl %ecx, 4(%esi)
-; CHECK-NEXT: movl %eax, (%esi)
-; CHECK-NEXT: movl %esi, %eax
-; CHECK-NEXT: leal -12(%ebp), %esp
-; CHECK-NEXT: popl %esi
-; CHECK-NEXT: popl %edi
-; CHECK-NEXT: popl %ebx
-; CHECK-NEXT: popl %ebp
-; CHECK-NEXT: retl $4
- %res = call fp128 @llvm.maximum.f128(fp128 %x, fp128 %y)
- ret fp128 %res
-}
-
define half @minimum_half(half %x, half %y) nounwind {
; CHECK-LABEL: minimum_half:
; CHECK: # %bb.0:
@@ -237,47 +187,47 @@ define half @minimum_half(half %x, half %y) nounwind {
; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: cmpl {{[0-9]+}}(%esp), %eax
; CHECK-NEXT: fld %st(0)
-; CHECK-NEXT: jo .LBB4_2
+; CHECK-NEXT: jo .LBB3_2
; CHECK-NEXT: # %bb.1:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fld %st(1)
-; CHECK-NEXT: .LBB4_2:
+; CHECK-NEXT: .LBB3_2:
; CHECK-NEXT: fxch %st(2)
; CHECK-NEXT: fucom %st(1)
; CHECK-NEXT: fnstsw %ax
; CHECK-NEXT: # kill: def $ah killed $ah killed $ax
; CHECK-NEXT: sahf
; CHECK-NEXT: fld %st(1)
-; CHECK-NEXT: ja .LBB4_4
+; CHECK-NEXT: ja .LBB3_4
; CHECK-NEXT: # %bb.3:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fld %st(0)
-; CHECK-NEXT: .LBB4_4:
+; CHECK-NEXT: .LBB3_4:
; CHECK-NEXT: fxch %st(2)
; CHECK-NEXT: fucompp
; CHECK-NEXT: fnstsw %ax
; CHECK-NEXT: # kill: def $ah killed $ah killed $ax
; CHECK-NEXT: sahf
; CHECK-NEXT: flds {{\.?LCPI[0-9]+_[0-9]+}}
-; CHECK-NEXT: jp .LBB4_6
+; CHECK-NEXT: jp .LBB3_6
; CHECK-NEXT: # %bb.5:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fldz
; CHECK-NEXT: fxch %st(1)
-; CHECK-NEXT: .LBB4_6:
+; CHECK-NEXT: .LBB3_6:
; CHECK-NEXT: fstp %st(1)
-; CHECK-NEXT: jne .LBB4_7
+; CHECK-NEXT: jne .LBB3_7
; CHECK-NEXT: # %bb.8:
-; CHECK-NEXT: jp .LBB4_11
+; CHECK-NEXT: jp .LBB3_11
; CHECK-NEXT: # %bb.9:
; CHECK-NEXT: fstp %st(0)
-; CHECK-NEXT: jmp .LBB4_10
-; CHECK-NEXT: .LBB4_7:
+; CHECK-NEXT: jmp .LBB3_10
+; CHECK-NEXT: .LBB3_7:
; CHECK-NEXT: fstp %st(1)
-; CHECK-NEXT: .LBB4_10:
+; CHECK-NEXT: .LBB3_10:
; CHECK-NEXT: fldz
; CHECK-NEXT: fxch %st(1)
-; CHECK-NEXT: .LBB4_11:
+; CHECK-NEXT: .LBB3_11:
; CHECK-NEXT: fstp %st(1)
; CHECK-NEXT: fstps (%esp)
; CHECK-NEXT: calll __truncsfhf2
@@ -298,46 +248,46 @@ define float @minimum_float(float %x, float %y) nounwind {
; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: cmpl (%esp), %eax
; CHECK-NEXT: fld %st(1)
-; CHECK-NEXT: jo .LBB5_2
+; CHECK-NEXT: jo .LBB4_2
; CHECK-NEXT: # %bb.1:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fld %st(0)
-; CHECK-NEXT: .LBB5_2:
+; CHECK-NEXT: .LBB4_2:
; CHECK-NEXT: fxch %st(1)
; CHECK-NEXT: fucom %st(2)
; CHECK-NEXT: fnstsw %ax
; CHECK-NEXT: # kill: def $ah killed $ah killed $ax
; CHECK-NEXT: sahf
; CHECK-NEXT: fld %st(2)
-; CHECK-NEXT: ja .LBB5_4
+; CHECK-NEXT: ja .LBB4_4
; CHECK-NEXT: # %bb.3:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fld %st(0)
-; CHECK-NEXT: .LBB5_4:
+; CHECK-NEXT: .LBB4_4:
; CHECK-NEXT: fxch %st(3)
; CHECK-NEXT: fucompp
; CHECK-NEXT: fnstsw %ax
; CHECK-NEXT: # kill: def $ah killed $ah killed $ax
; CHECK-NEXT: sahf
; CHECK-NEXT: flds {{\.?LCPI[0-9]+_[0-9]+}}
-; CHECK-NEXT: jp .LBB5_6
+; CHECK-NEXT: jp .LBB4_6
; CHECK-NEXT: # %bb.5:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fldz
; CHECK-NEXT: fxch %st(2)
-; CHECK-NEXT: .LBB5_6:
+; CHECK-NEXT: .LBB4_6:
; CHECK-NEXT: fstp %st(2)
-; CHECK-NEXT: jne .LBB5_7
+; CHECK-NEXT: jne .LBB4_7
; CHECK-NEXT: # %bb.8:
-; CHECK-NEXT: jp .LBB5_11
+; CHECK-NEXT: jp .LBB4_11
; CHECK-NEXT: # %bb.9:
; CHECK-NEXT: fstp %st(1)
-; CHECK-NEXT: jmp .LBB5_10
-; CHECK-NEXT: .LBB5_7:
+; CHECK-NEXT: jmp .LBB4_10
+; CHECK-NEXT: .LBB4_7:
; CHECK-NEXT: fstp %st(0)
-; CHECK-NEXT: .LBB5_10:
+; CHECK-NEXT: .LBB4_10:
; CHECK-NEXT: fldz
-; CHECK-NEXT: .LBB5_11:
+; CHECK-NEXT: .LBB4_11:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: popl %eax
; CHECK-NEXT: retl
@@ -357,100 +307,50 @@ define double @minimum_double(double %x, double %y) nounwind {
; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: cmpl {{[0-9]+}}(%esp), %eax
; CHECK-NEXT: fld %st(0)
-; CHECK-NEXT: jo .LBB6_2
+; CHECK-NEXT: jo .LBB5_2
; CHECK-NEXT: # %bb.1:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fld %st(1)
-; CHECK-NEXT: .LBB6_2:
+; CHECK-NEXT: .LBB5_2:
; CHECK-NEXT: fxch %st(2)
; CHECK-NEXT: fucom %st(1)
; CHECK-NEXT: fnstsw %ax
; CHECK-NEXT: # kill: def $ah killed $ah killed $ax
; CHECK-NEXT: sahf
; CHECK-NEXT: fld %st(1)
-; CHECK-NEXT: ja .LBB6_4
+; CHECK-NEXT: ja .LBB5_4
; CHECK-NEXT: # %bb.3:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fld %st(0)
-; CHECK-NEXT: .LBB6_4:
+; CHECK-NEXT: .LBB5_4:
; CHECK-NEXT: fxch %st(2)
; CHECK-NEXT: fucompp
; CHECK-NEXT: fnstsw %ax
; CHECK-NEXT: # kill: def $ah killed $ah killed $ax
; CHECK-NEXT: sahf
; CHECK-NEXT: flds {{\.?LCPI[0-9]+_[0-9]+}}
-; CHECK-NEXT: jp .LBB6_6
+; CHECK-NEXT: jp .LBB5_6
; CHECK-NEXT: # %bb.5:
; CHECK-NEXT: fstp %st(0)
; CHECK-NEXT: fldz
; CHECK-NEXT: fxch %st(1)
-; CHECK-NEXT: .LBB6_6:
+; CHECK-NEXT: .LBB5_6:
; CHECK-NEXT: fstp %st(1)
-; CHECK-NEXT: jne .LBB6_7
+; CHECK-NEXT: jne .LBB5_7
; CHECK-NEXT: # %bb.8:
-; CHECK-NEXT: jp .LBB6_11
+; CHECK-NEXT: jp .LBB5_11
; CHECK-NEXT: # %bb.9:
; CHECK-NEXT: fstp %st(0)
-; CHECK-NEXT: jmp .LBB6_10
-; CHECK-NEXT: .LBB6_7:
+; CHECK-NEXT: jmp .LBB5_10
+; CHECK-NEXT: .LBB5_7:
; CHECK-NEXT: fstp %st(1)
-; CHECK-NEXT: .LBB6_10:
+; CHECK-NEXT: .LBB5_10:
; CHECK-NEXT: fldz
; CHECK-NEXT: fxch %st(1)
-; CHECK-NEXT: .LBB6_11:
+; CHECK-NEXT: .LBB5_11:
; CHECK-NEXT: fstp %st(1)
; CHECK-NEXT: addl $8, %esp
; CHECK-NEXT: retl
%res = call double @llvm.minimum.f64(double %x, double %y)
ret double %res
}
-
-define fp128 @minimum_fp128(fp128 %x, fp128 %y) nounwind {
-; CHECK-LABEL: minimum_fp128:
-; CHECK: # %bb.0:
-; CHECK-NEXT: pushl %ebp
-; CHECK-NEXT: movl %esp, %ebp
-; CHECK-NEXT: pushl %ebx
-; CHECK-NEXT: pushl %edi
-; CHECK-NEXT: pushl %esi
-; CHECK-NEXT: andl $-16, %esp
-; CHECK-NEXT: subl $80, %esp
-; CHECK-NEXT: movl 8(%ebp), %esi
-; CHECK-NEXT: movl 36(%ebp), %edi
-; CHECK-NEXT: movl 40(%ebp), %ebx
-; CHECK-NEXT: movl 44(%ebp), %edx
-; CHECK-NEXT: movl 48(%ebp), %ecx
-; CHECK-NEXT: movl 52(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl 32(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl 28(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: movl 24(%ebp), %eax
-; CHECK-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; CHECK-NEXT: leal {{[0-9]+}}(%esp), %eax
-; CHECK-NEXT: movl %eax, (%esp)
-; CHECK-NEXT: calll fminimuml
-; CHECK-NEXT: subl $4, %esp
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %eax
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %edx
-; CHECK-NEXT: movl {{[0-9]+}}(%esp), %edi
-; CHECK-NEXT: movl %edi, 12(%esi)
-; CHECK-NEXT: movl %edx, 8(%esi)
-; CHECK-NEXT: movl %ecx, 4(%esi)
-; CHECK-NEXT: movl %eax, (%esi)
-; CHECK-NEXT: movl %esi, %eax
-; CHECK-NEXT: leal -12(%ebp), %esp
-; CHECK-NEXT: popl %esi
-; CHECK-NEXT: popl %edi
-; CHECK-NEXT: popl %ebx
-; CHECK-NEXT: popl %ebp
-; CHECK-NEXT: retl $4
- %res = call fp128 @llvm.minimum.f128(fp128 %x, fp128 %y)
- ret fp128 %res
-}
diff --git a/llvm/test/CodeGen/X86/fminimum-fmaximum.ll b/llvm/test/CodeGen/X86/fminimum-fmaximum.ll
index 624dc398bc914..d96df9e30030e 100644
--- a/llvm/test/CodeGen/X86/fminimum-fmaximum.ll
+++ b/llvm/test/CodeGen/X86/fminimum-fmaximum.ll
@@ -3301,169 +3301,4 @@ define float @test_fminimum_daz(float %x) #0 {
ret float %1
}
-define fp128 @maximum_fp128(fp128 %x, fp128 %y) nounwind {
-; SSE2-LABEL: maximum_fp128:
-; SSE2: # %bb.0:
-; SSE2-NEXT: subq $72, %rsp
-; SSE2-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movdqa %xmm0, (%rsp) # 16-byte Spill
-; SSE2-NEXT: callq __trunctfsf2 at PLT
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: movd %xmm0, %eax
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: je .LBB45_2
-; SSE2-NEXT: # %bb.1:
-; SSE2-NEXT: movaps %xmm1, %xmm0
-; SSE2-NEXT: .LBB45_2:
-; SSE2-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: callq __gttf2 at PLT
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: jg .LBB45_4
-; SSE2-NEXT: # %bb.3:
-; SSE2-NEXT: movaps %xmm1, %xmm0
-; SSE2-NEXT: .LBB45_4:
-; SSE2-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: callq __unordtf2 at PLT
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: je .LBB45_6
-; SSE2-NEXT: # %bb.5:
-; SSE2-NEXT: movaps {{.*#+}} xmm0 = [NaN]
-; SSE2-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: .LBB45_6:
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: callq __eqtf2 at PLT
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: je .LBB45_8
-; SSE2-NEXT: # %bb.7:
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: .LBB45_8:
-; SSE2-NEXT: addq $72, %rsp
-; SSE2-NEXT: retq
-;
-; AVX-LABEL: maximum_fp128:
-; AVX: # %bb.0:
-; AVX-NEXT: subq $72, %rsp
-; AVX-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX-NEXT: callq __trunctfsf2 at PLT
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: vmovd %xmm0, %eax
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: je .LBB45_2
-; AVX-NEXT: # %bb.1:
-; AVX-NEXT: vmovaps %xmm1, %xmm0
-; AVX-NEXT: .LBB45_2:
-; AVX-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: callq __gttf2 at PLT
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: jg .LBB45_4
-; AVX-NEXT: # %bb.3:
-; AVX-NEXT: vmovaps %xmm1, %xmm0
-; AVX-NEXT: .LBB45_4:
-; AVX-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: callq __unordtf2 at PLT
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: je .LBB45_6
-; AVX-NEXT: # %bb.5:
-; AVX-NEXT: vmovaps {{.*#+}} xmm0 = [NaN]
-; AVX-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: .LBB45_6:
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: callq __eqtf2 at PLT
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: je .LBB45_8
-; AVX-NEXT: # %bb.7:
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: .LBB45_8:
-; AVX-NEXT: addq $72, %rsp
-; AVX-NEXT: retq
-;
-; AVX10_2-LABEL: maximum_fp128:
-; AVX10_2: # %bb.0:
-; AVX10_2-NEXT: subq $72, %rsp
-; AVX10_2-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: callq __trunctfsf2 at PLT
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: vmovd %xmm0, %eax
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: je .LBB45_2
-; AVX10_2-NEXT: # %bb.1:
-; AVX10_2-NEXT: vmovaps %xmm1, %xmm0
-; AVX10_2-NEXT: .LBB45_2:
-; AVX10_2-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: callq __gttf2 at PLT
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: jg .LBB45_4
-; AVX10_2-NEXT: # %bb.3:
-; AVX10_2-NEXT: vmovaps %xmm1, %xmm0
-; AVX10_2-NEXT: .LBB45_4:
-; AVX10_2-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: callq __unordtf2 at PLT
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: je .LBB45_6
-; AVX10_2-NEXT: # %bb.5:
-; AVX10_2-NEXT: vmovaps {{.*#+}} xmm0 = [NaN]
-; AVX10_2-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: .LBB45_6:
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: callq __eqtf2 at PLT
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: je .LBB45_8
-; AVX10_2-NEXT: # %bb.7:
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: .LBB45_8:
-; AVX10_2-NEXT: addq $72, %rsp
-; AVX10_2-NEXT: retq
-;
-; X86-LABEL: maximum_fp128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: pushl %esi
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $80, %esp
-; X86-NEXT: movl 8(%ebp), %esi
-; X86-NEXT: vmovups 24(%ebp), %ymm0
-; X86-NEXT: vmovups %ymm0, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: vzeroupper
-; X86-NEXT: calll fmaximuml
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: vmovaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: vmovaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: leal -4(%ebp), %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
- %res = call fp128 @llvm.maximum.f128(fp128 %x, fp128 %y)
- ret fp128 %res
-}
-
attributes #0 = { nounwind denormal_fpenv(preservesign) }
diff --git a/llvm/test/CodeGen/X86/fminimumnum-fmaximumnum.ll b/llvm/test/CodeGen/X86/fminimumnum-fmaximumnum.ll
index 8abd68701676c..1f4736c7c9b8b 100644
--- a/llvm/test/CodeGen/X86/fminimumnum-fmaximumnum.ll
+++ b/llvm/test/CodeGen/X86/fminimumnum-fmaximumnum.ll
@@ -3160,383 +3160,3 @@ define float @test_fminimumnum_snan(float %x, float %y) {
%1 = tail call float @llvm.minimumnum.f32(float 0x7ff4000000000000, float %y)
ret float %1
}
-
-define fp128 @test_fmaximumnum_fp128(fp128 %x, fp128 %y) nounwind {
-; SSE2-LABEL: test_fmaximumnum_fp128:
-; SSE2: # %bb.0: # %start
-; SSE2-NEXT: subq $40, %rsp
-; SSE2-NEXT: movaps %xmm1, (%rsp) # 16-byte Spill
-; SSE2-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movaps %xmm0, %xmm1
-; SSE2-NEXT: callq __unordtf2 at PLT
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps %xmm0, %xmm1
-; SSE2-NEXT: jne .LBB41_2
-; SSE2-NEXT: # %bb.1: # %start
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: .LBB41_2: # %start
-; SSE2-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movaps %xmm0, %xmm1
-; SSE2-NEXT: callq __unordtf2 at PLT
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: jne .LBB41_4
-; SSE2-NEXT: # %bb.3: # %start
-; SSE2-NEXT: movaps (%rsp), %xmm1 # 16-byte Reload
-; SSE2-NEXT: .LBB41_4: # %start
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: movaps %xmm1, (%rsp) # 16-byte Spill
-; SSE2-NEXT: callq __gttf2 at PLT
-; SSE2-NEXT: movdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movdqa %xmm0, %xmm1
-; SSE2-NEXT: jg .LBB41_6
-; SSE2-NEXT: # %bb.5: # %start
-; SSE2-NEXT: movdqa (%rsp), %xmm1 # 16-byte Reload
-; SSE2-NEXT: .LBB41_6: # %start
-; SSE2-NEXT: movdqa %xmm1, (%rsp) # 16-byte Spill
-; SSE2-NEXT: callq __trunctfsf2 at PLT
-; SSE2-NEXT: movaps (%rsp), %xmm2 # 16-byte Reload
-; SSE2-NEXT: movd %xmm0, %eax
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: je .LBB41_8
-; SSE2-NEXT: # %bb.7: # %start
-; SSE2-NEXT: movaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: .LBB41_8: # %start
-; SSE2-NEXT: pxor %xmm1, %xmm1
-; SSE2-NEXT: movaps %xmm2, %xmm0
-; SSE2-NEXT: callq __eqtf2 at PLT
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: je .LBB41_10
-; SSE2-NEXT: # %bb.9: # %start
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: .LBB41_10: # %start
-; SSE2-NEXT: addq $40, %rsp
-; SSE2-NEXT: retq
-;
-; AVX-LABEL: test_fmaximumnum_fp128:
-; AVX: # %bb.0: # %start
-; AVX-NEXT: subq $40, %rsp
-; AVX-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm0, %xmm1
-; AVX-NEXT: callq __unordtf2 at PLT
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps %xmm0, %xmm1
-; AVX-NEXT: jne .LBB41_2
-; AVX-NEXT: # %bb.1: # %start
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: .LBB41_2: # %start
-; AVX-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm0, %xmm1
-; AVX-NEXT: callq __unordtf2 at PLT
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: jne .LBB41_4
-; AVX-NEXT: # %bb.3: # %start
-; AVX-NEXT: vmovaps (%rsp), %xmm1 # 16-byte Reload
-; AVX-NEXT: .LBB41_4: # %start
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX-NEXT: callq __gttf2 at PLT
-; AVX-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovdqa %xmm0, %xmm1
-; AVX-NEXT: jg .LBB41_6
-; AVX-NEXT: # %bb.5: # %start
-; AVX-NEXT: vmovdqa (%rsp), %xmm1 # 16-byte Reload
-; AVX-NEXT: .LBB41_6: # %start
-; AVX-NEXT: vmovdqa %xmm1, (%rsp) # 16-byte Spill
-; AVX-NEXT: callq __trunctfsf2 at PLT
-; AVX-NEXT: vmovaps (%rsp), %xmm2 # 16-byte Reload
-; AVX-NEXT: vmovd %xmm0, %eax
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: je .LBB41_8
-; AVX-NEXT: # %bb.7: # %start
-; AVX-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: .LBB41_8: # %start
-; AVX-NEXT: vpxor %xmm1, %xmm1, %xmm1
-; AVX-NEXT: vmovaps %xmm2, %xmm0
-; AVX-NEXT: callq __eqtf2 at PLT
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: je .LBB41_10
-; AVX-NEXT: # %bb.9: # %start
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: .LBB41_10: # %start
-; AVX-NEXT: addq $40, %rsp
-; AVX-NEXT: retq
-;
-; AVX10_2-LABEL: test_fmaximumnum_fp128:
-; AVX10_2: # %bb.0: # %start
-; AVX10_2-NEXT: subq $40, %rsp
-; AVX10_2-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps %xmm0, %xmm1
-; AVX10_2-NEXT: callq __unordtf2 at PLT
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps %xmm0, %xmm1
-; AVX10_2-NEXT: jne .LBB41_2
-; AVX10_2-NEXT: # %bb.1: # %start
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: .LBB41_2: # %start
-; AVX10_2-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps %xmm0, %xmm1
-; AVX10_2-NEXT: callq __unordtf2 at PLT
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: jne .LBB41_4
-; AVX10_2-NEXT: # %bb.3: # %start
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: .LBB41_4: # %start
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: callq __gttf2 at PLT
-; AVX10_2-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovdqa %xmm0, %xmm1
-; AVX10_2-NEXT: jg .LBB41_6
-; AVX10_2-NEXT: # %bb.5: # %start
-; AVX10_2-NEXT: vmovdqa (%rsp), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: .LBB41_6: # %start
-; AVX10_2-NEXT: vmovdqa %xmm1, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: callq __trunctfsf2 at PLT
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm2 # 16-byte Reload
-; AVX10_2-NEXT: vmovd %xmm0, %eax
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: je .LBB41_8
-; AVX10_2-NEXT: # %bb.7: # %start
-; AVX10_2-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: .LBB41_8: # %start
-; AVX10_2-NEXT: vpxor %xmm1, %xmm1, %xmm1
-; AVX10_2-NEXT: vmovaps %xmm2, %xmm0
-; AVX10_2-NEXT: callq __eqtf2 at PLT
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: je .LBB41_10
-; AVX10_2-NEXT: # %bb.9: # %start
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: .LBB41_10: # %start
-; AVX10_2-NEXT: addq $40, %rsp
-; AVX10_2-NEXT: retq
-;
-; X86-LABEL: test_fmaximumnum_fp128:
-; X86: # %bb.0: # %start
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: pushl %esi
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $80, %esp
-; X86-NEXT: movl 8(%ebp), %esi
-; X86-NEXT: vmovups 24(%ebp), %ymm0
-; X86-NEXT: vmovups %ymm0, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: vzeroupper
-; X86-NEXT: calll fmaximum_numl
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: vmovaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: vmovaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: leal -4(%ebp), %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-start:
- %0 = tail call fp128 @llvm.maximumnum.f128(fp128 %x, fp128 %y)
- ret fp128 %0
-}
-
-define fp128 @test_fminimumnum_fp128(fp128 %x, fp128 %y) nounwind {
-; SSE2-LABEL: test_fminimumnum_fp128:
-; SSE2: # %bb.0: # %start
-; SSE2-NEXT: subq $40, %rsp
-; SSE2-NEXT: movaps %xmm1, (%rsp) # 16-byte Spill
-; SSE2-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movaps %xmm0, %xmm1
-; SSE2-NEXT: callq __unordtf2 at PLT
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps %xmm0, %xmm1
-; SSE2-NEXT: jne .LBB42_2
-; SSE2-NEXT: # %bb.1: # %start
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: .LBB42_2: # %start
-; SSE2-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: movaps %xmm0, %xmm1
-; SSE2-NEXT: callq __unordtf2 at PLT
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE2-NEXT: jne .LBB42_4
-; SSE2-NEXT: # %bb.3: # %start
-; SSE2-NEXT: movaps (%rsp), %xmm1 # 16-byte Reload
-; SSE2-NEXT: .LBB42_4: # %start
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: movaps %xmm1, (%rsp) # 16-byte Spill
-; SSE2-NEXT: callq __lttf2 at PLT
-; SSE2-NEXT: movdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movdqa %xmm0, %xmm1
-; SSE2-NEXT: js .LBB42_6
-; SSE2-NEXT: # %bb.5: # %start
-; SSE2-NEXT: movdqa (%rsp), %xmm1 # 16-byte Reload
-; SSE2-NEXT: .LBB42_6: # %start
-; SSE2-NEXT: movdqa %xmm1, (%rsp) # 16-byte Spill
-; SSE2-NEXT: callq __trunctfsf2 at PLT
-; SSE2-NEXT: movaps (%rsp), %xmm2 # 16-byte Reload
-; SSE2-NEXT: movd %xmm0, %eax
-; SSE2-NEXT: negl %eax
-; SSE2-NEXT: jo .LBB42_8
-; SSE2-NEXT: # %bb.7: # %start
-; SSE2-NEXT: movaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE2-NEXT: .LBB42_8: # %start
-; SSE2-NEXT: pxor %xmm1, %xmm1
-; SSE2-NEXT: movaps %xmm2, %xmm0
-; SSE2-NEXT: callq __eqtf2 at PLT
-; SSE2-NEXT: testl %eax, %eax
-; SSE2-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE2-NEXT: je .LBB42_10
-; SSE2-NEXT: # %bb.9: # %start
-; SSE2-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE2-NEXT: .LBB42_10: # %start
-; SSE2-NEXT: addq $40, %rsp
-; SSE2-NEXT: retq
-;
-; AVX-LABEL: test_fminimumnum_fp128:
-; AVX: # %bb.0: # %start
-; AVX-NEXT: subq $40, %rsp
-; AVX-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm0, %xmm1
-; AVX-NEXT: callq __unordtf2 at PLT
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps %xmm0, %xmm1
-; AVX-NEXT: jne .LBB42_2
-; AVX-NEXT: # %bb.1: # %start
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: .LBB42_2: # %start
-; AVX-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm0, %xmm1
-; AVX-NEXT: callq __unordtf2 at PLT
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX-NEXT: jne .LBB42_4
-; AVX-NEXT: # %bb.3: # %start
-; AVX-NEXT: vmovaps (%rsp), %xmm1 # 16-byte Reload
-; AVX-NEXT: .LBB42_4: # %start
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX-NEXT: callq __lttf2 at PLT
-; AVX-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovdqa %xmm0, %xmm1
-; AVX-NEXT: js .LBB42_6
-; AVX-NEXT: # %bb.5: # %start
-; AVX-NEXT: vmovdqa (%rsp), %xmm1 # 16-byte Reload
-; AVX-NEXT: .LBB42_6: # %start
-; AVX-NEXT: vmovdqa %xmm1, (%rsp) # 16-byte Spill
-; AVX-NEXT: callq __trunctfsf2 at PLT
-; AVX-NEXT: vmovaps (%rsp), %xmm2 # 16-byte Reload
-; AVX-NEXT: vmovd %xmm0, %eax
-; AVX-NEXT: negl %eax
-; AVX-NEXT: jo .LBB42_8
-; AVX-NEXT: # %bb.7: # %start
-; AVX-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: .LBB42_8: # %start
-; AVX-NEXT: vpxor %xmm1, %xmm1, %xmm1
-; AVX-NEXT: vmovaps %xmm2, %xmm0
-; AVX-NEXT: callq __eqtf2 at PLT
-; AVX-NEXT: testl %eax, %eax
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: je .LBB42_10
-; AVX-NEXT: # %bb.9: # %start
-; AVX-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX-NEXT: .LBB42_10: # %start
-; AVX-NEXT: addq $40, %rsp
-; AVX-NEXT: retq
-;
-; AVX10_2-LABEL: test_fminimumnum_fp128:
-; AVX10_2: # %bb.0: # %start
-; AVX10_2-NEXT: subq $40, %rsp
-; AVX10_2-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps %xmm0, %xmm1
-; AVX10_2-NEXT: callq __unordtf2 at PLT
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps %xmm0, %xmm1
-; AVX10_2-NEXT: jne .LBB42_2
-; AVX10_2-NEXT: # %bb.1: # %start
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: .LBB42_2: # %start
-; AVX10_2-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: vmovaps %xmm0, %xmm1
-; AVX10_2-NEXT: callq __unordtf2 at PLT
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: jne .LBB42_4
-; AVX10_2-NEXT: # %bb.3: # %start
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: .LBB42_4: # %start
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: vmovaps %xmm1, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: callq __lttf2 at PLT
-; AVX10_2-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovdqa %xmm0, %xmm1
-; AVX10_2-NEXT: js .LBB42_6
-; AVX10_2-NEXT: # %bb.5: # %start
-; AVX10_2-NEXT: vmovdqa (%rsp), %xmm1 # 16-byte Reload
-; AVX10_2-NEXT: .LBB42_6: # %start
-; AVX10_2-NEXT: vmovdqa %xmm1, (%rsp) # 16-byte Spill
-; AVX10_2-NEXT: callq __trunctfsf2 at PLT
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm2 # 16-byte Reload
-; AVX10_2-NEXT: vmovd %xmm0, %eax
-; AVX10_2-NEXT: negl %eax
-; AVX10_2-NEXT: jo .LBB42_8
-; AVX10_2-NEXT: # %bb.7: # %start
-; AVX10_2-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX10_2-NEXT: .LBB42_8: # %start
-; AVX10_2-NEXT: vpxor %xmm1, %xmm1, %xmm1
-; AVX10_2-NEXT: vmovaps %xmm2, %xmm0
-; AVX10_2-NEXT: callq __eqtf2 at PLT
-; AVX10_2-NEXT: testl %eax, %eax
-; AVX10_2-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: je .LBB42_10
-; AVX10_2-NEXT: # %bb.9: # %start
-; AVX10_2-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX10_2-NEXT: .LBB42_10: # %start
-; AVX10_2-NEXT: addq $40, %rsp
-; AVX10_2-NEXT: retq
-;
-; X86-LABEL: test_fminimumnum_fp128:
-; X86: # %bb.0: # %start
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: pushl %esi
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $80, %esp
-; X86-NEXT: movl 8(%ebp), %esi
-; X86-NEXT: vmovups 24(%ebp), %ymm0
-; X86-NEXT: vmovups %ymm0, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: vzeroupper
-; X86-NEXT: calll fminimum_numl
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: vmovaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: vmovaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: leal -4(%ebp), %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-start:
- %0 = tail call fp128 @llvm.minimumnum.f128(fp128 %x, fp128 %y)
- ret fp128 %0
-}
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls-gnu.ll b/llvm/test/CodeGen/X86/fp128-libcalls-gnu.ll
new file mode 100644
index 0000000000000..010151764fd65
--- /dev/null
+++ b/llvm/test/CodeGen/X86/fp128-libcalls-gnu.ll
@@ -0,0 +1,835 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -O2 -mtriple=x86_64-linux-gnu \
+; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=GNU
+; RUN: llc < %s -O2 -mtriple=i686-linux-gnu -mattr=sse2 \
+; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=X86
+
+; These fp128 libcall operations only have a libcall on targets whose libc
+; provides the f128-suffixed math functions (glibc). The android/windows
+; variants have no libcall and are covered by fp128-libcalls.ll (arithmetic
+; only) plus the no-libcall diagnostic tests.
+
+ at vf64 = common dso_local global double 0.000000e+00, align 8
+ at vf128 = common dso_local global fp128 0xL00000000000000000000000000000000, align 16
+
+define dso_local void @Test128Rem(fp128 %d1, fp128 %d2) nounwind {
+; GNU-LABEL: Test128Rem:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq fmodf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Rem:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fmodf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl
+entry:
+ %div = frem fp128 %d1, %d2
+ store fp128 %div, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128_1Rem(fp128 %d1) nounwind {
+; GNU-LABEL: Test128_1Rem:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: movaps %xmm0, %xmm1
+; GNU-NEXT: movaps vf128(%rip), %xmm0
+; GNU-NEXT: callq fmodf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128_1Rem:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl vf128, %edi
+; X86-NEXT: movl vf128+4, %ebx
+; X86-NEXT: movl vf128+8, %ebp
+; X86-NEXT: movl vf128+12, %eax
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fmodf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl
+entry:
+ %0 = load fp128, ptr @vf128, align 16
+ %div = frem fp128 %0, %d1
+ store fp128 %div, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Sqrt(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Sqrt:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq sqrtf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Sqrt:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll sqrtf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.sqrt.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Sin(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Sin:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq sinf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Sin:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll sinf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.sin.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Cos(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Cos:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq cosf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Cos:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll cosf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.cos.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Ceil(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Ceil:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq ceilf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Ceil:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll ceilf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.ceil.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Floor(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Floor:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq floorf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Floor:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll floorf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.floor.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Trunc(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Trunc:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq truncf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Trunc:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll truncf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.trunc.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Nearbyint(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Nearbyint:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq nearbyintf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Nearbyint:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll nearbyintf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.nearbyint.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Rint(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Rint:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq rintf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Rint:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll rintf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.rint.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define dso_local void @Test128Round(fp128 %d1) nounwind {
+; GNU-LABEL: Test128Round:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq roundf128 at PLT
+; GNU-NEXT: movaps %xmm0, vf128(%rip)
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Round:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $56, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll roundf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, vf128
+; X86-NEXT: addl $56, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: retl
+entry:
+ %sqrt = call fp128 @llvm.round.f128(fp128 %d1)
+ store fp128 %sqrt, ptr @vf128, align 16
+ ret void
+}
+
+define fp128 @Test128FMA(fp128 %a, fp128 %b, fp128 %c) nounwind {
+; GNU-LABEL: Test128FMA:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: jmp fmaf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128FMA:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $92, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fmaf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%ebp)
+; X86-NEXT: movl %ebp, %eax
+; X86-NEXT: addl $92, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %call = call fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
+ ret fp128 %call
+}
+
+define fp128 @Test128Acos(fp128 %a) nounwind {
+; GNU-LABEL: Test128Acos:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp acosf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Acos:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll acosf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.acos.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define fp128 @Test128Asin(fp128 %a) nounwind {
+; GNU-LABEL: Test128Asin:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp asinf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Asin:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll asinf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.asin.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define fp128 @Test128Atan(fp128 %a) nounwind {
+; GNU-LABEL: Test128Atan:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp atanf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Atan:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll atanf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.atan.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind {
+; GNU-LABEL: Test128Atan2:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp atan2f128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Atan2:
+; X86: # %bb.0:
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll atan2f128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.atan2.f128(fp128 %a, fp128 %b)
+ ret fp128 %x
+}
+
+define fp128 @Test128Cosh(fp128 %a) nounwind {
+; GNU-LABEL: Test128Cosh:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp coshf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Cosh:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll coshf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.cosh.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define fp128 @Test128Sinh(fp128 %a) nounwind {
+; GNU-LABEL: Test128Sinh:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp sinhf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Sinh:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll sinhf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.sinh.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define fp128 @Test128Tan(fp128 %a) nounwind {
+; GNU-LABEL: Test128Tan:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp tanf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Tan:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll tanf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.tan.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define fp128 @Test128Tanh(fp128 %a) nounwind {
+; GNU-LABEL: Test128Tanh:
+; GNU: # %bb.0:
+; GNU-NEXT: jmp tanhf128 at PLT # TAILCALL
+;
+; X86-LABEL: Test128Tanh:
+; X86: # %bb.0:
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll tanhf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+ %x = call fp128 @llvm.tanh.f128(fp128 %a)
+ ret fp128 %x
+}
+
+define { fp128, fp128 } @Test128Modf(fp128 %a) nounwind {
+; GNU-LABEL: Test128Modf:
+; GNU: # %bb.0:
+; GNU-NEXT: subq $24, %rsp
+; GNU-NEXT: movq %rsp, %rdi
+; GNU-NEXT: callq modff128 at PLT
+; GNU-NEXT: movaps (%rsp), %xmm1
+; GNU-NEXT: addq $24, %rsp
+; GNU-NEXT: retq
+;
+; X86-LABEL: Test128Modf:
+; X86: # %bb.0:
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $80, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: leal {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll modff128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm1
+; X86-NEXT: movaps %xmm1, 16(%esi)
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $80, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: retl $4
+ %x = call { fp128, fp128 } @llvm.modf.f128(fp128 %a)
+ ret { fp128, fp128 } %x
+}
+
+declare fp128 @llvm.sqrt.f128(fp128)
+declare fp128 @llvm.sin.f128(fp128)
+declare fp128 @llvm.cos.f128(fp128)
+declare fp128 @llvm.ceil.f128(fp128)
+declare fp128 @llvm.floor.f128(fp128)
+declare fp128 @llvm.trunc.f128(fp128)
+declare fp128 @llvm.nearbyint.f128(fp128)
+declare fp128 @llvm.rint.f128(fp128)
+declare fp128 @llvm.round.f128(fp128)
+declare fp128 @llvm.fma.f128(fp128, fp128, fp128)
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls-strict-gnu.ll b/llvm/test/CodeGen/X86/fp128-libcalls-strict-gnu.ll
new file mode 100644
index 0000000000000..df4b9b091455b
--- /dev/null
+++ b/llvm/test/CodeGen/X86/fp128-libcalls-strict-gnu.ll
@@ -0,0 +1,1283 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -O2 -mtriple=x86_64-linux-gnu \
+; RUN: -enable-legalize-types-checking \
+; RUN: | FileCheck %s --check-prefix=GNU
+; RUN: llc < %s -O2 -mtriple=i686-linux-gnu -mattr=+sse2 \
+; RUN: -enable-legalize-types-checking \
+; RUN: | FileCheck %s --check-prefix=X86
+
+; These strict fp128 libcall operations only have a libcall on targets whose
+; libc provides the f128-suffixed math functions (glibc). The android/windows
+; variants have no libcall (and i686 windows crashes on strict fma); they are
+; covered by fp128-libcalls-strict.ll (arithmetic/compare only).
+
+define fp128 @fma(fp128 %x, fp128 %y, fp128 %z) nounwind strictfp {
+; GNU-LABEL: fma:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq fmaf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: fma:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $92, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fmaf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%ebp)
+; X86-NEXT: movl %ebp, %eax
+; X86-NEXT: addl $92, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %fma = call fp128 @llvm.experimental.constrained.fma.f128(fp128 %x, fp128 %y, fp128 %z, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %fma
+}
+
+define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
+; GNU-LABEL: frem:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq fmodf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: frem:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fmodf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %div = call fp128 @llvm.experimental.constrained.frem.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %div
+}
+
+define fp128 @ceil(fp128 %x) nounwind strictfp {
+; GNU-LABEL: ceil:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq ceilf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: ceil:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll ceilf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret fp128 %ceil
+}
+
+define fp128 @acos(fp128 %x) nounwind strictfp {
+; GNU-LABEL: acos:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq acosf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: acos:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll acosf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %acos = call fp128 @llvm.experimental.constrained.acos.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %acos
+}
+
+define fp128 @cos(fp128 %x) nounwind strictfp {
+; GNU-LABEL: cos:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq cosf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: cos:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll cosf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %cos = call fp128 @llvm.experimental.constrained.cos.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %cos
+}
+
+define fp128 @cosh(fp128 %x) nounwind strictfp {
+; GNU-LABEL: cosh:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq coshf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: cosh:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll coshf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %cosh = call fp128 @llvm.experimental.constrained.cosh.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %cosh
+}
+
+define fp128 @exp(fp128 %x) nounwind strictfp {
+; GNU-LABEL: exp:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq expf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: exp:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll expf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %exp = call fp128 @llvm.experimental.constrained.exp.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %exp
+}
+
+define fp128 @exp2(fp128 %x) nounwind strictfp {
+; GNU-LABEL: exp2:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq exp2f128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: exp2:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll exp2f128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %exp2 = call fp128 @llvm.experimental.constrained.exp2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %exp2
+}
+
+define fp128 @floor(fp128 %x) nounwind strictfp {
+; GNU-LABEL: floor:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq floorf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: floor:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll floorf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret fp128 %floor
+}
+
+define fp128 @log(fp128 %x) nounwind strictfp {
+; GNU-LABEL: log:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq logf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: log:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll logf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %log = call fp128 @llvm.experimental.constrained.log.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %log
+}
+
+define fp128 @log10(fp128 %x) nounwind strictfp {
+; GNU-LABEL: log10:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq log10f128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: log10:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll log10f128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %log10 = call fp128 @llvm.experimental.constrained.log10.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %log10
+}
+
+define fp128 @log2(fp128 %x) nounwind strictfp {
+; GNU-LABEL: log2:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq log2f128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: log2:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll log2f128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %log2 = call fp128 @llvm.experimental.constrained.log2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %log2
+}
+
+define fp128 @maxnum(fp128 %x, fp128 %y) nounwind strictfp {
+; GNU-LABEL: maxnum:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq fmaxf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: maxnum:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fmaxf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
+ ret fp128 %maxnum
+}
+
+define fp128 @minnum(fp128 %x, fp128 %y) nounwind strictfp {
+; GNU-LABEL: minnum:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq fminf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: minnum:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll fminf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
+ ret fp128 %minnum
+}
+
+define fp128 @nearbyint(fp128 %x) nounwind strictfp {
+; GNU-LABEL: nearbyint:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq nearbyintf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: nearbyint:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll nearbyintf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %nearbyint = call fp128 @llvm.experimental.constrained.nearbyint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %nearbyint
+}
+
+define fp128 @pow(fp128 %x, fp128 %y) nounwind strictfp {
+; GNU-LABEL: pow:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq powf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: pow:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll powf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %pow = call fp128 @llvm.experimental.constrained.pow.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %pow
+}
+
+define fp128 @rint(fp128 %x) nounwind strictfp {
+; GNU-LABEL: rint:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq rintf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: rint:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll rintf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %rint = call fp128 @llvm.experimental.constrained.rint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %rint
+}
+
+define fp128 @round(fp128 %x) nounwind strictfp {
+; GNU-LABEL: round:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq roundf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: round:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll roundf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret fp128 %round
+}
+
+define fp128 @roundeven(fp128 %x) nounwind strictfp {
+; GNU-LABEL: roundeven:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq roundevenf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: roundeven:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll roundevenf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %roundeven = call fp128 @llvm.experimental.constrained.roundeven.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret fp128 %roundeven
+}
+
+define fp128 @asin(fp128 %x) nounwind strictfp {
+; GNU-LABEL: asin:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq asinf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: asin:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll asinf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %asin = call fp128 @llvm.experimental.constrained.asin.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %asin
+}
+
+define fp128 @sin(fp128 %x) nounwind strictfp {
+; GNU-LABEL: sin:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq sinf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: sin:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll sinf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %sin = call fp128 @llvm.experimental.constrained.sin.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %sin
+}
+
+define fp128 @sinh(fp128 %x) nounwind strictfp {
+; GNU-LABEL: sinh:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq sinhf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: sinh:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll sinhf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %sinh = call fp128 @llvm.experimental.constrained.sinh.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %sinh
+}
+
+define fp128 @sqrt(fp128 %x) nounwind strictfp {
+; GNU-LABEL: sqrt:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq sqrtf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: sqrt:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll sqrtf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %sqrt = call fp128 @llvm.experimental.constrained.sqrt.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %sqrt
+}
+
+define fp128 @atan(fp128 %x) nounwind strictfp {
+; GNU-LABEL: atan:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq atanf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: atan:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll atanf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %atan = call fp128 @llvm.experimental.constrained.atan.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %atan
+}
+
+define fp128 @atan2(fp128 %x, fp128 %y) nounwind strictfp {
+; GNU-LABEL: atan2:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq atan2f128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: atan2:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %ebp
+; X86-NEXT: pushl %ebx
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $76, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll atan2f128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $76, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
+; X86-NEXT: popl %ebp
+; X86-NEXT: retl $4
+entry:
+ %atan2 = call fp128 @llvm.experimental.constrained.atan2.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %atan2
+}
+
+define fp128 @tan(fp128 %x) nounwind strictfp {
+; GNU-LABEL: tan:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq tanf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: tan:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll tanf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %tan = call fp128 @llvm.experimental.constrained.tan.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %tan
+}
+
+define fp128 @tanh(fp128 %x) nounwind strictfp {
+; GNU-LABEL: tanh:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq tanhf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: tanh:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll tanhf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %tanh = call fp128 @llvm.experimental.constrained.tanh.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %tanh
+}
+
+define fp128 @trunc(fp128 %x) nounwind strictfp {
+; GNU-LABEL: trunc:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq truncf128 at PLT
+; GNU-NEXT: popq %rax
+; GNU-NEXT: retq
+;
+; X86-LABEL: trunc:
+; X86: # %bb.0: # %entry
+; X86-NEXT: pushl %edi
+; X86-NEXT: pushl %esi
+; X86-NEXT: subl $52, %esp
+; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
+; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
+; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
+; X86-NEXT: movl %eax, (%esp)
+; X86-NEXT: calll truncf128
+; X86-NEXT: subl $4, %esp
+; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
+; X86-NEXT: movaps %xmm0, (%esi)
+; X86-NEXT: movl %esi, %eax
+; X86-NEXT: addl $52, %esp
+; X86-NEXT: popl %esi
+; X86-NEXT: popl %edi
+; X86-NEXT: retl $4
+entry:
+ %trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret fp128 %trunc
+}
+
+define i32 @lrint(fp128 %x) nounwind strictfp {
+; GNU-LABEL: lrint:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq lrintf128 at PLT
+; GNU-NEXT: popq %rcx
+; GNU-NEXT: retq
+;
+; X86-LABEL: lrint:
+; X86: # %bb.0: # %entry
+; X86-NEXT: subl $12, %esp
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: calll lrintf128
+; X86-NEXT: addl $28, %esp
+; X86-NEXT: retl
+entry:
+ %rint = call i32 @llvm.experimental.constrained.lrint.i32.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret i32 %rint
+}
+
+define i64 @llrint(fp128 %x) nounwind strictfp {
+; GNU-LABEL: llrint:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq llrintf128 at PLT
+; GNU-NEXT: popq %rcx
+; GNU-NEXT: retq
+;
+; X86-LABEL: llrint:
+; X86: # %bb.0: # %entry
+; X86-NEXT: subl $12, %esp
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: calll llrintf128
+; X86-NEXT: addl $28, %esp
+; X86-NEXT: retl
+entry:
+ %rint = call i64 @llvm.experimental.constrained.llrint.i64.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret i64 %rint
+}
+
+define i32 @lround(fp128 %x) nounwind strictfp {
+; GNU-LABEL: lround:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq lroundf128 at PLT
+; GNU-NEXT: popq %rcx
+; GNU-NEXT: retq
+;
+; X86-LABEL: lround:
+; X86: # %bb.0: # %entry
+; X86-NEXT: subl $12, %esp
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: calll lroundf128
+; X86-NEXT: addl $28, %esp
+; X86-NEXT: retl
+entry:
+ %round = call i32 @llvm.experimental.constrained.lround.i32.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret i32 %round
+}
+
+define i64 @llround(fp128 %x) nounwind strictfp {
+; GNU-LABEL: llround:
+; GNU: # %bb.0: # %entry
+; GNU-NEXT: pushq %rax
+; GNU-NEXT: callq llroundf128 at PLT
+; GNU-NEXT: popq %rcx
+; GNU-NEXT: retq
+;
+; X86-LABEL: llround:
+; X86: # %bb.0: # %entry
+; X86-NEXT: subl $12, %esp
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: pushl {{[0-9]+}}(%esp)
+; X86-NEXT: calll llroundf128
+; X86-NEXT: addl $28, %esp
+; X86-NEXT: retl
+entry:
+ %round = call i64 @llvm.experimental.constrained.llround.i64.f128(fp128 %x, metadata !"fpexcept.strict") #0
+ ret i64 %round
+}
+
+declare fp128 @llvm.experimental.constrained.fma.f128(fp128, fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.frem.f128(fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
+declare fp128 @llvm.experimental.constrained.acos.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.cos.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.cosh.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.exp.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.exp2.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
+declare fp128 @llvm.experimental.constrained.log.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.log10.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.log2.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata)
+declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
+declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.pow.f128(fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
+declare fp128 @llvm.experimental.constrained.roundeven.f128(fp128, metadata)
+declare fp128 @llvm.experimental.constrained.asin.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.sin.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.sinh.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.atan.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.atan2.f128(fp128, fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.tan.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.tanh.f128(fp128, metadata, metadata)
+declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
+declare i32 @llvm.experimental.constrained.lrint.i32.f128(fp128, metadata, metadata)
+declare i64 @llvm.experimental.constrained.llrint.i64.f128(fp128, metadata, metadata)
+declare i32 @llvm.experimental.constrained.lround.i32.f128(fp128, metadata)
+declare i64 @llvm.experimental.constrained.llround.i64.f128(fp128, metadata)
+
+attributes #0 = { nounwind strictfp }
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
index cae271f7a2ed4..390baa03abdec 100644
--- a/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
+++ b/llvm/test/CodeGen/X86/fp128-libcalls-strict.ll
@@ -15,6 +15,11 @@
; RUN: -enable-legalize-types-checking \
; RUN: | FileCheck %s --check-prefix=WIN-X86
+; NOTE: Only fp128 arithmetic (add/sub/mul/div), powi and the compares have a
+; libcall on every triple here. The strict fp128 math/rem/fma/rounding/lrint
+; cases only have a libcall where libc provides the f128-suffixed functions
+; (glibc); those are covered in fp128-libcalls-strict-gnu.ll.
+
; Check all soft floating point library function calls.
define fp128 @add(fp128 %x, fp128 %y) nounwind strictfp {
@@ -533,311 +538,59 @@ entry:
ret fp128 %div
}
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: fma:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq fmaf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: fma:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $92, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fmaf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%ebp)
-; X86-NEXT: movl %ebp, %eax
-; X86-NEXT: addl $92, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: fma:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $96, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%r9), %xmm0
-; WIN-NEXT: movaps (%rdx), %xmm1
-; WIN-NEXT: movaps (%r8), %xmm2
-; WIN-NEXT: movaps %xmm2, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $96, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
+define fp128 @powi(fp128 %x, i32 %y) nounwind strictfp {
+; CHECK-LABEL: powi:
+; CHECK: # %bb.0: # %entry
+; CHECK-NEXT: pushq %rax
+; CHECK-NEXT: callq __powitf2 at PLT
+; CHECK-NEXT: popq %rax
+; CHECK-NEXT: retq
;
-; WIN-X86-LABEL: fma:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $96, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 52(%ebp), %ebx
-; WIN-X86-NEXT: movl 56(%ebp), %edi
-; WIN-X86-NEXT: movl 60(%ebp), %edx
-; WIN-X86-NEXT: movl 64(%ebp), %ecx
-; WIN-X86-NEXT: movl 68(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 48(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 44(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 40(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 36(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %fma = call fp128 @llvm.experimental.constrained.fma.f128(fp128 %x, fp128 %y, fp128 %z, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %fma
-}
-
-define fp128 @frem(fp128 %x, fp128 %y) nounwind strictfp {
-; ANDROID-LABEL: frem:
+; ANDROID-LABEL: powi:
; ANDROID: # %bb.0: # %entry
; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq fmodl at PLT
+; ANDROID-NEXT: callq __powitf2 at PLT
; ANDROID-NEXT: popq %rax
; ANDROID-NEXT: retq
;
-; GNU-LABEL: frem:
+; GNU-LABEL: powi:
; GNU: # %bb.0: # %entry
; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq fmodf128 at PLT
+; GNU-NEXT: callq __powitf2 at PLT
; GNU-NEXT: popq %rax
; GNU-NEXT: retq
;
-; X86-LABEL: frem:
+; X86-LABEL: powi:
; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
; X86-NEXT: pushl %ebx
; X86-NEXT: pushl %edi
; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fmodf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: frem:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $80, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps (%r8), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $80, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: frem:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl 44(%ebp), %edx
-; WIN-X86-NEXT: movl 48(%ebp), %ecx
-; WIN-X86-NEXT: movl 52(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %div = call fp128 @llvm.experimental.constrained.frem.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %div
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: ceil:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq ceilf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: ceil:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
+; X86-NEXT: subl $64, %esp
; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
+; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
+; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll ceilf128
+; X86-NEXT: calll __powitf2
; X86-NEXT: subl $4, %esp
; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
; X86-NEXT: movaps %xmm0, (%esi)
; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
+; X86-NEXT: addl $64, %esp
; X86-NEXT: popl %esi
; X86-NEXT: popl %edi
+; X86-NEXT: popl %ebx
; X86-NEXT: retl $4
;
-; WIN-LABEL: ceil:
+; WIN-LABEL: powi:
; WIN: # %bb.0: # %entry
; WIN-NEXT: pushq %rsi
; WIN-NEXT: subq $64, %rsp
@@ -846,7 +599,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 __powitf2
; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
; WIN-NEXT: movaps %xmm0, (%rsi)
; WIN-NEXT: movq %rsi, %rax
@@ -854,26 +607,29 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq
;
-; WIN-X86-LABEL: ceil:
+; WIN-X86-LABEL: powi:
; WIN-X86: # %bb.0: # %entry
; WIN-X86-NEXT: pushl %ebp
; WIN-X86-NEXT: movl %esp, %ebp
+; WIN-X86-NEXT: pushl %ebx
; WIN-X86-NEXT: pushl %edi
; WIN-X86-NEXT: pushl %esi
; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
+; WIN-X86-NEXT: subl $80, %esp
; WIN-X86-NEXT: movl 8(%ebp), %esi
; WIN-X86-NEXT: movl 24(%ebp), %eax
; WIN-X86-NEXT: movl 28(%ebp), %ecx
; WIN-X86-NEXT: movl 32(%ebp), %edx
; WIN-X86-NEXT: movl 36(%ebp), %edi
+; WIN-X86-NEXT: movl 40(%ebp), %ebx
+; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
; 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 ___powitf2
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
@@ -883,2875 +639,15 @@ define fp128 @ceil(fp128 %x) nounwind strictfp {
; WIN-X86-NEXT: movl %eax, (%esi)
; WIN-X86-NEXT: movl %ecx, 4(%esi)
; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
+; WIN-X86-NEXT: leal -12(%ebp), %esp
; WIN-X86-NEXT: popl %esi
; WIN-X86-NEXT: popl %edi
+; WIN-X86-NEXT: popl %ebx
; WIN-X86-NEXT: popl %ebp
; WIN-X86-NEXT: retl
entry:
- %ceil = call fp128 @llvm.experimental.constrained.ceil.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret fp128 %ceil
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: acos:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq acosf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: acos:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll acosf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: acos:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: acos:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %acos = call fp128 @llvm.experimental.constrained.acos.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %acos
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: cos:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq cosf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: cos:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll cosf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: cos:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: cos:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %cos = call fp128 @llvm.experimental.constrained.cos.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %cos
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: cosh:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq coshf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: cosh:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll coshf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: cosh:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: cosh:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %cosh = call fp128 @llvm.experimental.constrained.cosh.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %cosh
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: exp:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq expf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: exp:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll expf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: exp:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: exp:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %exp = call fp128 @llvm.experimental.constrained.exp.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %exp
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: exp2:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq exp2f128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: exp2:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll exp2f128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: exp2:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: exp2:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %exp2 = call fp128 @llvm.experimental.constrained.exp2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %exp2
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: floor:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq floorf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: floor:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll floorf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: floor:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: floor:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %floor = call fp128 @llvm.experimental.constrained.floor.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret fp128 %floor
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: log:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq logf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: log:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll logf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: log:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: log:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %log = call fp128 @llvm.experimental.constrained.log.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %log
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: log10:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq log10f128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: log10:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll log10f128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: log10:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: log10:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %log10 = call fp128 @llvm.experimental.constrained.log10.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %log10
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: log2:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq log2f128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: log2:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll log2f128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: log2:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: log2:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %log2 = call fp128 @llvm.experimental.constrained.log2.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %log2
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: maxnum:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq fmaxf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: maxnum:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fmaxf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: maxnum:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $80, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps (%r8), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $80, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: maxnum:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl 44(%ebp), %edx
-; WIN-X86-NEXT: movl 48(%ebp), %ecx
-; WIN-X86-NEXT: movl 52(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %maxnum = call fp128 @llvm.experimental.constrained.maxnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
- ret fp128 %maxnum
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: minnum:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq fminf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: minnum:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fminf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: minnum:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $80, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps (%r8), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $80, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: minnum:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl 44(%ebp), %edx
-; WIN-X86-NEXT: movl 48(%ebp), %ecx
-; WIN-X86-NEXT: movl 52(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %minnum = call fp128 @llvm.experimental.constrained.minnum.f128(fp128 %x, fp128 %y, metadata !"fpexcept.strict") #0
- ret fp128 %minnum
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: nearbyint:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq nearbyintf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: nearbyint:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll nearbyintf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: nearbyint:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: nearbyint:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %nearbyint = call fp128 @llvm.experimental.constrained.nearbyint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %nearbyint
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: pow:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq powf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: pow:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll powf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: pow:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $80, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps (%r8), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $80, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: pow:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl 44(%ebp), %edx
-; WIN-X86-NEXT: movl 48(%ebp), %ecx
-; WIN-X86-NEXT: movl 52(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %pow = call fp128 @llvm.experimental.constrained.pow.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %pow
-}
-
-define fp128 @powi(fp128 %x, i32 %y) nounwind strictfp {
-; CHECK-LABEL: powi:
-; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: pushq %rax
-; CHECK-NEXT: callq __powitf2 at PLT
-; CHECK-NEXT: popq %rax
-; CHECK-NEXT: retq
-;
-; ANDROID-LABEL: powi:
-; ANDROID: # %bb.0: # %entry
-; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: callq __powitf2 at PLT
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: powi:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq __powitf2 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: powi:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $64, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll __powitf2
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $64, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: powi:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
-; WIN-NEXT: callq __powitf2
-; WIN-NEXT: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: powi:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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 ___powitf2
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %powi = call fp128 @llvm.experimental.constrained.powi.f128(fp128 %x, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %powi
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: rint:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq rintf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: rint:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll rintf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: rint:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: rint:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %rint = call fp128 @llvm.experimental.constrained.rint.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %rint
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: round:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq roundf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: round:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll roundf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: round:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: round:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %round = call fp128 @llvm.experimental.constrained.round.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret fp128 %round
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: roundeven:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq roundevenf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: roundeven:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll roundevenf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: roundeven:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: roundeven:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %roundeven = call fp128 @llvm.experimental.constrained.roundeven.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret fp128 %roundeven
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: asin:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq asinf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: asin:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll asinf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: asin:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: asin:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %asin = call fp128 @llvm.experimental.constrained.asin.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %asin
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: sin:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq sinf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: sin:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll sinf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: sin:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: sin:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sin = call fp128 @llvm.experimental.constrained.sin.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %sin
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: sinh:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq sinhf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: sinh:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll sinhf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: sinh:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: sinh:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sinh = call fp128 @llvm.experimental.constrained.sinh.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %sinh
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: sqrt:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq sqrtf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: sqrt:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll sqrtf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: sqrt:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: sqrt:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.experimental.constrained.sqrt.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %sqrt
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: atan:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq atanf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: atan:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll atanf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: atan:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: atan:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %atan = call fp128 @llvm.experimental.constrained.atan.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %atan
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: atan2:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq atan2f128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: atan2:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll atan2f128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: atan2:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $80, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps (%r8), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $80, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: atan2:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl 44(%ebp), %edx
-; WIN-X86-NEXT: movl 48(%ebp), %ecx
-; WIN-X86-NEXT: movl 52(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %atan2 = call fp128 @llvm.experimental.constrained.atan2.f128(fp128 %x, fp128 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %atan2
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: tan:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq tanf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: tan:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll tanf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: tan:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: tan:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %tan = call fp128 @llvm.experimental.constrained.tan.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %tan
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: tanh:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq tanhf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: tanh:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll tanhf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: tanh:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: tanh:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %tanh = call fp128 @llvm.experimental.constrained.tanh.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret fp128 %tanh
-}
-
-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: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: trunc:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq truncf128 at PLT
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: trunc:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll truncf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: trunc:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: trunc:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 8(%esi)
-; WIN-X86-NEXT: movl %edx, 12(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %trunc = call fp128 @llvm.experimental.constrained.trunc.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret fp128 %trunc
-}
-
-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: popq %rcx
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: lrint:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq lrintf128 at PLT
-; GNU-NEXT: popq %rcx
-; GNU-NEXT: retq
-;
-; X86-LABEL: lrint:
-; X86: # %bb.0: # %entry
-; X86-NEXT: subl $12, %esp
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: calll lrintf128
-; X86-NEXT: addl $28, %esp
-; X86-NEXT: retl
-;
-; WIN-LABEL: lrint:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $56, %rsp
-; 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: addq $56, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: lrint:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $16, %esp
-; WIN-X86-NEXT: pushl 20(%ebp)
-; 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: addl $16, %esp
-; WIN-X86-NEXT: movl %ebp, %esp
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %rint = call i32 @llvm.experimental.constrained.lrint.i32.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret i32 %rint
-}
-
-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: popq %rcx
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: llrint:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq llrintf128 at PLT
-; GNU-NEXT: popq %rcx
-; GNU-NEXT: retq
-;
-; X86-LABEL: llrint:
-; X86: # %bb.0: # %entry
-; X86-NEXT: subl $12, %esp
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: calll llrintf128
-; X86-NEXT: addl $28, %esp
-; X86-NEXT: retl
-;
-; WIN-LABEL: llrint:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $56, %rsp
-; 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: addq $56, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: llrint:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $16, %esp
-; WIN-X86-NEXT: pushl 20(%ebp)
-; 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: addl $16, %esp
-; WIN-X86-NEXT: movl %ebp, %esp
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %rint = call i64 @llvm.experimental.constrained.llrint.i64.f128(fp128 %x, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
- ret i64 %rint
-}
-
-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: popq %rcx
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: lround:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq lroundf128 at PLT
-; GNU-NEXT: popq %rcx
-; GNU-NEXT: retq
-;
-; X86-LABEL: lround:
-; X86: # %bb.0: # %entry
-; X86-NEXT: subl $12, %esp
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: calll lroundf128
-; X86-NEXT: addl $28, %esp
-; X86-NEXT: retl
-;
-; WIN-LABEL: lround:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $56, %rsp
-; 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: addq $56, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: lround:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $16, %esp
-; WIN-X86-NEXT: pushl 20(%ebp)
-; 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: addl $16, %esp
-; WIN-X86-NEXT: movl %ebp, %esp
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %round = call i32 @llvm.experimental.constrained.lround.i32.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret i32 %round
-}
-
-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: popq %rcx
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: llround:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq llroundf128 at PLT
-; GNU-NEXT: popq %rcx
-; GNU-NEXT: retq
-;
-; X86-LABEL: llround:
-; X86: # %bb.0: # %entry
-; X86-NEXT: subl $12, %esp
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: pushl {{[0-9]+}}(%esp)
-; X86-NEXT: calll llroundf128
-; X86-NEXT: addl $28, %esp
-; X86-NEXT: retl
-;
-; WIN-LABEL: llround:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $56, %rsp
-; 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: addq $56, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: llround:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $16, %esp
-; WIN-X86-NEXT: pushl 20(%ebp)
-; 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: addl $16, %esp
-; WIN-X86-NEXT: movl %ebp, %esp
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %round = call i64 @llvm.experimental.constrained.llround.i64.f128(fp128 %x, metadata !"fpexcept.strict") #0
- ret i64 %round
+ %powi = call fp128 @llvm.experimental.constrained.powi.f128(fp128 %x, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+ ret fp128 %powi
}
define i64 @cmp(i64 %a, i64 %b, fp128 %x, fp128 %y) #0 {
@@ -3864,13 +760,13 @@ define i64 @cmp(i64 %a, i64 %b, fp128 %x, fp128 %y) #0 {
; WIN-X86-NEXT: calll ___eqtf2
; WIN-X86-NEXT: addl $32, %esp
; WIN-X86-NEXT: testl %eax, %eax
-; WIN-X86-NEXT: je LBB37_1
+; WIN-X86-NEXT: je LBB5_1
; WIN-X86-NEXT: # %bb.2:
; WIN-X86-NEXT: leal 16(%ebp), %ecx
-; WIN-X86-NEXT: jmp LBB37_3
-; WIN-X86-NEXT: LBB37_1:
+; WIN-X86-NEXT: jmp LBB5_3
+; WIN-X86-NEXT: LBB5_1:
; WIN-X86-NEXT: leal 8(%ebp), %ecx
-; WIN-X86-NEXT: LBB37_3:
+; WIN-X86-NEXT: LBB5_3:
; WIN-X86-NEXT: movl (%ecx), %eax
; WIN-X86-NEXT: movl 4(%ecx), %edx
; WIN-X86-NEXT: movl %ebp, %esp
@@ -3994,13 +890,13 @@ define i64 @cmps(i64 %a, i64 %b, fp128 %x, fp128 %y) #0 {
; WIN-X86-NEXT: calll ___eqtf2
; WIN-X86-NEXT: addl $32, %esp
; WIN-X86-NEXT: testl %eax, %eax
-; WIN-X86-NEXT: je LBB38_1
+; WIN-X86-NEXT: je LBB6_1
; WIN-X86-NEXT: # %bb.2:
; WIN-X86-NEXT: leal 16(%ebp), %ecx
-; WIN-X86-NEXT: jmp LBB38_3
-; WIN-X86-NEXT: LBB38_1:
+; WIN-X86-NEXT: jmp LBB6_3
+; WIN-X86-NEXT: LBB6_1:
; WIN-X86-NEXT: leal 8(%ebp), %ecx
-; WIN-X86-NEXT: LBB38_3:
+; WIN-X86-NEXT: LBB6_3:
; WIN-X86-NEXT: movl (%ecx), %eax
; WIN-X86-NEXT: movl 4(%ecx), %edx
; WIN-X86-NEXT: movl %ebp, %esp
@@ -4214,13 +1110,13 @@ define i64 @cmp_ueq_q(i64 %a, i64 %b, fp128 %x, fp128 %y) #0 {
; WIN-X86-NEXT: addl $32, %esp
; WIN-X86-NEXT: orb %bl, %al
; WIN-X86-NEXT: testb $1, %al
-; WIN-X86-NEXT: jne LBB39_1
+; WIN-X86-NEXT: jne LBB7_1
; WIN-X86-NEXT: # %bb.2:
; WIN-X86-NEXT: leal 16(%ebp), %ecx
-; WIN-X86-NEXT: jmp LBB39_3
-; WIN-X86-NEXT: LBB39_1:
+; WIN-X86-NEXT: jmp LBB7_3
+; WIN-X86-NEXT: LBB7_1:
; WIN-X86-NEXT: leal 8(%ebp), %ecx
-; WIN-X86-NEXT: LBB39_3:
+; WIN-X86-NEXT: LBB7_3:
; WIN-X86-NEXT: movl (%ecx), %eax
; WIN-X86-NEXT: movl 4(%ecx), %edx
; WIN-X86-NEXT: leal -12(%ebp), %esp
@@ -4439,13 +1335,13 @@ define i64 @cmp_one_q(i64 %a, i64 %b, fp128 %x, fp128 %y) #0 {
; WIN-X86-NEXT: testl %eax, %eax
; WIN-X86-NEXT: sete %al
; WIN-X86-NEXT: testb %bl, %al
-; WIN-X86-NEXT: jne LBB40_1
+; WIN-X86-NEXT: jne LBB8_1
; WIN-X86-NEXT: # %bb.2:
; WIN-X86-NEXT: leal 16(%ebp), %ecx
-; WIN-X86-NEXT: jmp LBB40_3
-; WIN-X86-NEXT: LBB40_1:
+; WIN-X86-NEXT: jmp LBB8_3
+; WIN-X86-NEXT: LBB8_1:
; WIN-X86-NEXT: leal 8(%ebp), %ecx
-; WIN-X86-NEXT: LBB40_3:
+; WIN-X86-NEXT: LBB8_3:
; WIN-X86-NEXT: movl (%ecx), %eax
; WIN-X86-NEXT: movl 4(%ecx), %edx
; WIN-X86-NEXT: leal -12(%ebp), %esp
@@ -4468,38 +1364,6 @@ declare fp128 @llvm.experimental.constrained.fadd.f128(fp128, fp128, metadata, m
declare fp128 @llvm.experimental.constrained.fsub.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.fma.f128(fp128, fp128, fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.frem.f128(fp128, fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata)
-declare fp128 @llvm.experimental.constrained.acos.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.cos.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.cosh.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.exp.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.exp2.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata)
-declare fp128 @llvm.experimental.constrained.log.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.log10.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.log2.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata)
-declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata)
-declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.pow.f128(fp128, fp128, metadata, metadata)
declare fp128 @llvm.experimental.constrained.powi.f128(fp128, i32, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata)
-declare fp128 @llvm.experimental.constrained.roundeven.f128(fp128, metadata)
-declare fp128 @llvm.experimental.constrained.asin.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.sin.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.sinh.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.atan.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.atan2.f128(fp128, fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.tan.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.tanh.f128(fp128, metadata, metadata)
-declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata)
-declare i32 @llvm.experimental.constrained.lrint.i32.f128(fp128, metadata, metadata)
-declare i64 @llvm.experimental.constrained.llrint.i64.f128(fp128, metadata, metadata)
-declare i32 @llvm.experimental.constrained.lround.i32.f128(fp128, metadata)
-declare i64 @llvm.experimental.constrained.llround.i64.f128(fp128, metadata)
declare i1 @llvm.experimental.constrained.fcmp.f128(fp128, fp128, metadata, metadata)
declare i1 @llvm.experimental.constrained.fcmps.f128(fp128, fp128, metadata, metadata)
diff --git a/llvm/test/CodeGen/X86/fp128-libcalls.ll b/llvm/test/CodeGen/X86/fp128-libcalls.ll
index c594b15ef1cbe..3cb21b5fd59c6 100644
--- a/llvm/test/CodeGen/X86/fp128-libcalls.ll
+++ b/llvm/test/CodeGen/X86/fp128-libcalls.ll
@@ -10,6 +10,11 @@
; RUN: llc < %s -O2 -mtriple=i686-pc-windows-msvc \
; RUN: -enable-legalize-types-checking | FileCheck %s --check-prefix=WIN-X86
+; NOTE: Only fp128 arithmetic (add/sub/mul/div) has a libcall on every triple
+; here. The fp128 math/rem/fma/modf cases only have a libcall where libc
+; provides the f128-suffixed functions (glibc); those are covered in
+; fp128-libcalls-gnu.ll.
+
; Check all soft floating point library function calls.
@vf64 = common dso_local global double 0.000000e+00, align 8
@@ -1042,2049 +1047,3 @@ entry:
store fp128 %div, ptr @vf128, align 16
ret void
}
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Rem:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq fmodf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Rem:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fmodf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Rem:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $88, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; WIN-NEXT: movaps (%rdx), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $88, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Rem:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %edi
-; WIN-X86-NEXT: movl 28(%ebp), %ebx
-; WIN-X86-NEXT: movl 32(%ebp), %ecx
-; WIN-X86-NEXT: movl 36(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 12(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %div = frem fp128 %d1, %d2
- store fp128 %div, ptr @vf128, align 16
- ret void
-}
-
-define dso_local void @Test128_1Rem(fp128 %d1) nounwind {
-; ANDROID-LABEL: Test128_1Rem:
-; ANDROID: # %bb.0: # %entry
-; ANDROID-NEXT: pushq %rax
-; ANDROID-NEXT: movaps %xmm0, %xmm1
-; ANDROID-NEXT: movaps vf128(%rip), %xmm0
-; ANDROID-NEXT: callq fmodl at PLT
-; ANDROID-NEXT: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128_1Rem:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: movaps %xmm0, %xmm1
-; GNU-NEXT: movaps vf128(%rip), %xmm0
-; GNU-NEXT: callq fmodf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128_1Rem:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl vf128, %edi
-; X86-NEXT: movl vf128+4, %ebx
-; X86-NEXT: movl vf128+8, %ebp
-; X86-NEXT: movl vf128+12, %eax
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fmodf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128_1Rem:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $88, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; WIN-NEXT: movaps vf128(%rip), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $88, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128_1Rem:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 16(%ebp), %esi
-; WIN-X86-NEXT: movl 20(%ebp), %edi
-; WIN-X86-NEXT: movl _vf128, %edx
-; WIN-X86-NEXT: movl _vf128+4, %ebx
-; WIN-X86-NEXT: movl _vf128+8, %ecx
-; WIN-X86-NEXT: movl _vf128+12, %eax
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 12(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+8
-; WIN-X86-NEXT: movl %edx, _vf128+12
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %0 = load fp128, ptr @vf128, align 16
- %div = frem fp128 %0, %d1
- store fp128 %div, ptr @vf128, align 16
- ret void
-}
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Sqrt:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq sqrtf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Sqrt:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll sqrtf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Sqrt:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Sqrt:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.sqrt.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.sqrt.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Sin:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq sinf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Sin:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll sinf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Sin:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Sin:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.sin.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.sin.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Cos:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq cosf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Cos:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll cosf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Cos:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Cos:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.cos.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.cos.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Ceil:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq ceilf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Ceil:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll ceilf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Ceil:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Ceil:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.ceil.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.ceil.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Floor:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq floorf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Floor:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll floorf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Floor:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Floor:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.floor.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.floor.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Trunc:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq truncf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Trunc:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll truncf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Trunc:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Trunc:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.trunc.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.trunc.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Nearbyint:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq nearbyintf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Nearbyint:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll nearbyintf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Nearbyint:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Nearbyint:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.nearbyint.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.nearbyint.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Rint:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq rintf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Rint:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll rintf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Rint:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Rint:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.rint.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-declare fp128 @llvm.rint.f128(fp128)
-
-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: movaps %xmm0, vf128(%rip)
-; ANDROID-NEXT: popq %rax
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Round:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: pushq %rax
-; GNU-NEXT: callq roundf128 at PLT
-; GNU-NEXT: movaps %xmm0, vf128(%rip)
-; GNU-NEXT: popq %rax
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Round:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $56, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll roundf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, vf128
-; X86-NEXT: addl $56, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: retl
-;
-; WIN-LABEL: Test128Round:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: subq $72, %rsp
-; WIN-NEXT: movaps (%rcx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, vf128(%rip)
-; WIN-NEXT: addq $72, %rsp
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Round:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $64, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %eax
-; WIN-X86-NEXT: movl 12(%ebp), %ecx
-; WIN-X86-NEXT: movl 16(%ebp), %edx
-; WIN-X86-NEXT: movl 20(%ebp), %esi
-; WIN-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; WIN-X86-NEXT: movl %esi, _vf128+12
-; WIN-X86-NEXT: movl %edx, _vf128+8
-; WIN-X86-NEXT: movl %ecx, _vf128+4
-; WIN-X86-NEXT: movl %eax, _vf128
-; WIN-X86-NEXT: leal -4(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %sqrt = call fp128 @llvm.round.f128(fp128 %d1)
- store fp128 %sqrt, ptr @vf128, align 16
- ret void
-}
-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
-;
-; GNU-LABEL: Test128FMA:
-; GNU: # %bb.0: # %entry
-; GNU-NEXT: jmp fmaf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128FMA:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $92, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll fmaf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%ebp)
-; X86-NEXT: movl %ebp, %eax
-; X86-NEXT: addl $92, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128FMA:
-; WIN: # %bb.0: # %entry
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $96, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%r9), %xmm0
-; WIN-NEXT: movaps (%rdx), %xmm1
-; WIN-NEXT: movaps (%r8), %xmm2
-; WIN-NEXT: movaps %xmm2, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $96, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128FMA:
-; WIN-X86: # %bb.0: # %entry
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $96, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 52(%ebp), %ebx
-; WIN-X86-NEXT: movl 56(%ebp), %edi
-; WIN-X86-NEXT: movl 60(%ebp), %edx
-; WIN-X86-NEXT: movl 64(%ebp), %ecx
-; WIN-X86-NEXT: movl 68(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 48(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 44(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 40(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 36(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
-entry:
- %call = call fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
- ret fp128 %call
-}
-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
-;
-; GNU-LABEL: Test128Acos:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp acosf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Acos:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll acosf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Acos:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Acos:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.acos.f128(fp128 %a)
- ret fp128 %x
-}
-
-define fp128 @Test128Asin(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Asin:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp asinl at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Asin:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp asinf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Asin:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll asinf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Asin:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Asin:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.asin.f128(fp128 %a)
- ret fp128 %x
-}
-
-define fp128 @Test128Atan(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Atan:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp atanl at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Atan:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp atanf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Atan:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll atanf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Atan:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Atan:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.atan.f128(fp128 %a)
- ret fp128 %x
-}
-
-define fp128 @Test128Atan2(fp128 %a, fp128 %b) nounwind {
-; ANDROID-LABEL: Test128Atan2:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp atan2l at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Atan2:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp atan2f128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Atan2:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $76, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ebp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebp, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll atan2f128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $76, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Atan2:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $80, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps (%r8), %xmm1
-; WIN-NEXT: movaps %xmm1, {{[0-9]+}}(%rsp)
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $80, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Atan2:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $80, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl 40(%ebp), %ebx
-; WIN-X86-NEXT: movl 44(%ebp), %edx
-; WIN-X86-NEXT: movl 48(%ebp), %ecx
-; WIN-X86-NEXT: movl 52(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 32(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 28(%ebp), %eax
-; WIN-X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.atan2.f128(fp128 %a, fp128 %b)
- ret fp128 %x
-}
-
-define fp128 @Test128Cosh(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Cosh:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp coshl at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Cosh:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp coshf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Cosh:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll coshf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Cosh:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Cosh:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.cosh.f128(fp128 %a)
- ret fp128 %x
-}
-
-define fp128 @Test128Sinh(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Sinh:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp sinhl at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Sinh:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp sinhf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Sinh:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll sinhf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Sinh:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Sinh:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.sinh.f128(fp128 %a)
- ret fp128 %x
-}
-
-define fp128 @Test128Tan(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Tan:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp tanl at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Tan:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp tanf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Tan:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll tanf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Tan:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Tan:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.tan.f128(fp128 %a)
- ret fp128 %x
-}
-
-define fp128 @Test128Tanh(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Tanh:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: jmp tanhl at PLT # TAILCALL
-;
-; GNU-LABEL: Test128Tanh:
-; GNU: # %bb.0:
-; GNU-NEXT: jmp tanhf128 at PLT # TAILCALL
-;
-; X86-LABEL: Test128Tanh:
-; X86: # %bb.0:
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $52, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll tanhf128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $52, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Tanh:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Tanh:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $48, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl %edx, 8(%esi)
-; WIN-X86-NEXT: movl %ecx, 4(%esi)
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -8(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call fp128 @llvm.tanh.f128(fp128 %a)
- ret fp128 %x
-}
-
-define { fp128, fp128 } @Test128Modf(fp128 %a) nounwind {
-; ANDROID-LABEL: Test128Modf:
-; ANDROID: # %bb.0:
-; ANDROID-NEXT: subq $24, %rsp
-; ANDROID-NEXT: movq %rsp, %rdi
-; ANDROID-NEXT: callq modfl at PLT
-; ANDROID-NEXT: movaps (%rsp), %xmm1
-; ANDROID-NEXT: addq $24, %rsp
-; ANDROID-NEXT: retq
-;
-; GNU-LABEL: Test128Modf:
-; GNU: # %bb.0:
-; GNU-NEXT: subq $24, %rsp
-; GNU-NEXT: movq %rsp, %rdi
-; GNU-NEXT: callq modff128 at PLT
-; GNU-NEXT: movaps (%rsp), %xmm1
-; GNU-NEXT: addq $24, %rsp
-; GNU-NEXT: retq
-;
-; X86-LABEL: Test128Modf:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: subl $80, %esp
-; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; X86-NEXT: movl {{[0-9]+}}(%esp), %edi
-; X86-NEXT: leal {{[0-9]+}}(%esp), %ebx
-; X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; X86-NEXT: movl %eax, {{[0-9]+}}(%esp)
-; X86-NEXT: leal {{[0-9]+}}(%esp), %eax
-; X86-NEXT: movl %eax, (%esp)
-; X86-NEXT: calll modff128
-; X86-NEXT: subl $4, %esp
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm0
-; X86-NEXT: movaps {{[0-9]+}}(%esp), %xmm1
-; X86-NEXT: movaps %xmm1, 16(%esi)
-; X86-NEXT: movaps %xmm0, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: addl $80, %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: retl $4
-;
-; WIN-LABEL: Test128Modf:
-; WIN: # %bb.0:
-; WIN-NEXT: pushq %rsi
-; WIN-NEXT: subq $64, %rsp
-; WIN-NEXT: movq %rcx, %rsi
-; WIN-NEXT: movaps (%rdx), %xmm0
-; WIN-NEXT: movaps %xmm0, {{[0-9]+}}(%rsp)
-; 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: movaps {{[0-9]+}}(%rsp), %xmm0
-; WIN-NEXT: movaps %xmm0, (%rsi)
-; WIN-NEXT: movq %rsi, %rax
-; WIN-NEXT: addq $64, %rsp
-; WIN-NEXT: popq %rsi
-; WIN-NEXT: retq
-;
-; WIN-X86-LABEL: Test128Modf:
-; WIN-X86: # %bb.0:
-; WIN-X86-NEXT: pushl %ebp
-; WIN-X86-NEXT: movl %esp, %ebp
-; WIN-X86-NEXT: pushl %ebx
-; WIN-X86-NEXT: pushl %edi
-; WIN-X86-NEXT: pushl %esi
-; WIN-X86-NEXT: andl $-16, %esp
-; WIN-X86-NEXT: subl $112, %esp
-; WIN-X86-NEXT: movl 8(%ebp), %esi
-; WIN-X86-NEXT: movl 24(%ebp), %eax
-; WIN-X86-NEXT: movl 28(%ebp), %ecx
-; WIN-X86-NEXT: movl 32(%ebp), %edx
-; WIN-X86-NEXT: movl 36(%ebp), %edi
-; WIN-X86-NEXT: leal {{[0-9]+}}(%esp), %ebx
-; WIN-X86-NEXT: movl %ebx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edi, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; WIN-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; 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: 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
-; WIN-X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; 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), %edi
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ebx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; WIN-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; WIN-X86-NEXT: movl %edx, 28(%esi)
-; WIN-X86-NEXT: movl %eax, 24(%esi)
-; WIN-X86-NEXT: movl %ecx, 20(%esi)
-; WIN-X86-NEXT: movl %ebx, 16(%esi)
-; WIN-X86-NEXT: movl %edi, 12(%esi)
-; WIN-X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; WIN-X86-NEXT: movl %eax, 8(%esi)
-; WIN-X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; WIN-X86-NEXT: movl %eax, 4(%esi)
-; WIN-X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; WIN-X86-NEXT: movl %eax, (%esi)
-; WIN-X86-NEXT: movl %esi, %eax
-; WIN-X86-NEXT: leal -12(%ebp), %esp
-; WIN-X86-NEXT: popl %esi
-; WIN-X86-NEXT: popl %edi
-; WIN-X86-NEXT: popl %ebx
-; WIN-X86-NEXT: popl %ebp
-; WIN-X86-NEXT: retl
- %x = call { fp128, fp128 } @llvm.modf.f128(fp128 %a)
- ret { fp128, fp128 } %x
-}
diff --git a/llvm/test/CodeGen/X86/llrint-conv.ll b/llvm/test/CodeGen/X86/llrint-conv.ll
index 01551030d938a..40758b730b467 100644
--- a/llvm/test/CodeGen/X86/llrint-conv.ll
+++ b/llvm/test/CodeGen/X86/llrint-conv.ll
@@ -232,76 +232,6 @@ entry:
}
; FIXME(#44744): incorrect libcall
-define i64 @test_llrint_i64_f128(fp128 %x) nounwind {
-; X86-NOSSE-LABEL: test_llrint_i64_f128:
-; X86-NOSSE: # %bb.0: # %entry
-; X86-NOSSE-NEXT: pushl %ebp
-; X86-NOSSE-NEXT: movl %esp, %ebp
-; X86-NOSSE-NEXT: andl $-16, %esp
-; X86-NOSSE-NEXT: subl $16, %esp
-; X86-NOSSE-NEXT: pushl 20(%ebp)
-; X86-NOSSE-NEXT: pushl 16(%ebp)
-; X86-NOSSE-NEXT: pushl 12(%ebp)
-; X86-NOSSE-NEXT: pushl 8(%ebp)
-; X86-NOSSE-NEXT: calll llrintl
-; X86-NOSSE-NEXT: addl $16, %esp
-; X86-NOSSE-NEXT: movl %ebp, %esp
-; X86-NOSSE-NEXT: popl %ebp
-; X86-NOSSE-NEXT: retl
-;
-; X86-NOX87-LABEL: test_llrint_i64_f128:
-; X86-NOX87: # %bb.0: # %entry
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %ebp, %esp
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; X86-SSE2-LABEL: test_llrint_i64_f128:
-; X86-SSE2: # %bb.0: # %entry
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $16, %esp
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll llrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %ebp, %esp
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: test_llrint_i64_f128:
-; X86-AVX: # %bb.0: # %entry
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $32, %esp
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll llrintl
-; X86-AVX-NEXT: movl %ebp, %esp
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-LABEL: test_llrint_i64_f128:
-; X64: # %bb.0: # %entry
-; X64-NEXT: jmp llrintl at PLT # TAILCALL
-entry:
- %0 = tail call i64 @llvm.llrint.i64.f128(fp128 %x)
- ret i64 %0
-}
-
define i64 @test_llrint_i64_f16_strict(half %x) nounwind strictfp {
; X86-NOSSE-LABEL: test_llrint_i64_f16_strict:
; X86-NOSSE: # %bb.0: # %entry
@@ -483,79 +413,6 @@ entry:
}
; FIXME(#44744): incorrect libcall
-define i64 @test_llrint_i64_f128_strict(fp128 %x) nounwind strictfp {
-; X86-NOSSE-LABEL: test_llrint_i64_f128_strict:
-; X86-NOSSE: # %bb.0: # %entry
-; X86-NOSSE-NEXT: pushl %ebp
-; X86-NOSSE-NEXT: movl %esp, %ebp
-; X86-NOSSE-NEXT: andl $-16, %esp
-; X86-NOSSE-NEXT: subl $16, %esp
-; X86-NOSSE-NEXT: pushl 20(%ebp)
-; X86-NOSSE-NEXT: pushl 16(%ebp)
-; X86-NOSSE-NEXT: pushl 12(%ebp)
-; X86-NOSSE-NEXT: pushl 8(%ebp)
-; X86-NOSSE-NEXT: calll llrintl
-; X86-NOSSE-NEXT: addl $16, %esp
-; X86-NOSSE-NEXT: movl %ebp, %esp
-; X86-NOSSE-NEXT: popl %ebp
-; X86-NOSSE-NEXT: retl
-;
-; X86-NOX87-LABEL: test_llrint_i64_f128_strict:
-; X86-NOX87: # %bb.0: # %entry
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %ebp, %esp
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; X86-SSE2-LABEL: test_llrint_i64_f128_strict:
-; X86-SSE2: # %bb.0: # %entry
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $16, %esp
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll llrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %ebp, %esp
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: test_llrint_i64_f128_strict:
-; X86-AVX: # %bb.0: # %entry
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $32, %esp
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll llrintl
-; X86-AVX-NEXT: movl %ebp, %esp
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-LABEL: test_llrint_i64_f128_strict:
-; X64: # %bb.0: # %entry
-; X64-NEXT: pushq %rax
-; X64-NEXT: callq llrintl at PLT
-; X64-NEXT: popq %rcx
-; X64-NEXT: retq
-entry:
- %0 = tail call i64 @llvm.experimental.constrained.llrint.i64.f128(fp128 %x, metadata!"round.dynamic", metadata!"fpexcept.strict")
- ret i64 %0
-}
-
declare i64 @llvm.llrint.i64.f32(float) nounwind readnone
declare i64 @llvm.llrint.i64.f64(double) nounwind readnone
declare i64 @llvm.llrint.i64.f80(x86_fp80) nounwind readnone
diff --git a/llvm/test/CodeGen/X86/llround-conv.ll b/llvm/test/CodeGen/X86/llround-conv.ll
index 93fec71b6eccc..2b54c90f76906 100644
--- a/llvm/test/CodeGen/X86/llround-conv.ll
+++ b/llvm/test/CodeGen/X86/llround-conv.ll
@@ -185,54 +185,6 @@ define i64 @test_llround_f80(x86_fp80 %x) nounwind {
}
; FIXME(#44744): incorrect libcall
-define i64 @test_llround_f128(fp128 %x) nounwind {
-; X86-LABEL: test_llround_f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll llroundl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X64-LABEL: test_llround_f128:
-; X64: # %bb.0:
-; X64-NEXT: jmp llroundl at PLT # TAILCALL
-;
-; GISEL-X86-LABEL: test_llround_f128:
-; GISEL-X86: # %bb.0:
-; GISEL-X86-NEXT: pushl %esi
-; GISEL-X86-NEXT: subl $24, %esp
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; GISEL-X86-NEXT: movl %eax, (%esp)
-; GISEL-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: calll llroundf128
-; GISEL-X86-NEXT: addl $24, %esp
-; GISEL-X86-NEXT: popl %esi
-; GISEL-X86-NEXT: retl
-;
-; GISEL-X64-LABEL: test_llround_f128:
-; GISEL-X64: # %bb.0:
-; GISEL-X64-NEXT: pushq %rax
-; GISEL-X64-NEXT: callq llroundf128
-; GISEL-X64-NEXT: popq %rcx
-; GISEL-X64-NEXT: retq
- %conv = tail call i64 @llvm.llround.f128(fp128 %x)
- ret i64 %conv
-}
-
define i64 @test_llround_i64_f16(half %x) nounwind {
; X86-NOSSE-LABEL: test_llround_i64_f16:
; X86-NOSSE: # %bb.0:
@@ -413,54 +365,6 @@ define i64 @test_llround_i64_f80(x86_fp80 %x) nounwind {
}
; FIXME(#44744): incorrect libcall
-define i64 @test_llround_i64_f128(fp128 %x) nounwind {
-; X86-LABEL: test_llround_i64_f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll llroundl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X64-LABEL: test_llround_i64_f128:
-; X64: # %bb.0:
-; X64-NEXT: jmp llroundl at PLT # TAILCALL
-;
-; GISEL-X86-LABEL: test_llround_i64_f128:
-; GISEL-X86: # %bb.0:
-; GISEL-X86-NEXT: pushl %esi
-; GISEL-X86-NEXT: subl $24, %esp
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; GISEL-X86-NEXT: movl %eax, (%esp)
-; GISEL-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: calll llroundf128
-; GISEL-X86-NEXT: addl $24, %esp
-; GISEL-X86-NEXT: popl %esi
-; GISEL-X86-NEXT: retl
-;
-; GISEL-X64-LABEL: test_llround_i64_f128:
-; GISEL-X64: # %bb.0:
-; GISEL-X64-NEXT: pushq %rax
-; GISEL-X64-NEXT: callq llroundf128
-; GISEL-X64-NEXT: popq %rcx
-; GISEL-X64-NEXT: retq
- %conv = call i64 @llvm.llround.i64.f128(fp128 %x)
- ret i64 %conv
-}
-
; FIXME: not yet implemented for global isel
; define i64 @test_llround_i64_f16_strict(half %x) nounwind strictfp {
; %conv = call i64 @llvm.experimental.constrained.llround.i64.f16(half %x, metadata!"round.dynamic", metadata!"fpexcept.strict")
diff --git a/llvm/test/CodeGen/X86/lrint-conv-i32.ll b/llvm/test/CodeGen/X86/lrint-conv-i32.ll
index f4cb0d3ff87e6..b74e0bd4dcd93 100644
--- a/llvm/test/CodeGen/X86/lrint-conv-i32.ll
+++ b/llvm/test/CodeGen/X86/lrint-conv-i32.ll
@@ -140,59 +140,6 @@ define i32 @test_lrint_i32_f80(x86_fp80 %x) nounwind {
}
; FIXME(#44744): incorrect libcall
-define i32 @test_lrint_i32_f128(fp128 %x) nounwind {
-; X86-NOSSE-LABEL: test_lrint_i32_f128:
-; X86-NOSSE: # %bb.0:
-; X86-NOSSE-NEXT: pushl %ebp
-; X86-NOSSE-NEXT: movl %esp, %ebp
-; X86-NOSSE-NEXT: andl $-16, %esp
-; X86-NOSSE-NEXT: subl $16, %esp
-; X86-NOSSE-NEXT: pushl 20(%ebp)
-; X86-NOSSE-NEXT: pushl 16(%ebp)
-; X86-NOSSE-NEXT: pushl 12(%ebp)
-; X86-NOSSE-NEXT: pushl 8(%ebp)
-; X86-NOSSE-NEXT: calll lrintl
-; X86-NOSSE-NEXT: addl $16, %esp
-; X86-NOSSE-NEXT: movl %ebp, %esp
-; X86-NOSSE-NEXT: popl %ebp
-; X86-NOSSE-NEXT: retl
-;
-; X86-SSE2-LABEL: test_lrint_i32_f128:
-; X86-SSE2: # %bb.0:
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $16, %esp
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %ebp, %esp
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: test_lrint_i32_f128:
-; X86-AVX: # %bb.0:
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $32, %esp
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: movl %ebp, %esp
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-LABEL: test_lrint_i32_f128:
-; X64: # %bb.0:
-; X64-NEXT: jmp lrintl at PLT # TAILCALL
- %conv = tail call i32 @llvm.lrint.i32.f128(fp128 %x)
- ret i32 %conv
-}
-
define i32 @test_lrint_i32_f16_strict(half %x) nounwind strictfp {
; X86-NOSSE-LABEL: test_lrint_i32_f16_strict:
; X86-NOSSE: # %bb.0:
@@ -338,62 +285,6 @@ define i32 @test_lrint_i32_f80_strict(x86_fp80 %x) nounwind strictfp {
}
; FIXME(#44744): incorrect libcall
-define i32 @test_lrint_i32_f128_strict(fp128 %x) nounwind strictfp {
-; X86-NOSSE-LABEL: test_lrint_i32_f128_strict:
-; X86-NOSSE: # %bb.0:
-; X86-NOSSE-NEXT: pushl %ebp
-; X86-NOSSE-NEXT: movl %esp, %ebp
-; X86-NOSSE-NEXT: andl $-16, %esp
-; X86-NOSSE-NEXT: subl $16, %esp
-; X86-NOSSE-NEXT: pushl 20(%ebp)
-; X86-NOSSE-NEXT: pushl 16(%ebp)
-; X86-NOSSE-NEXT: pushl 12(%ebp)
-; X86-NOSSE-NEXT: pushl 8(%ebp)
-; X86-NOSSE-NEXT: calll lrintl
-; X86-NOSSE-NEXT: addl $16, %esp
-; X86-NOSSE-NEXT: movl %ebp, %esp
-; X86-NOSSE-NEXT: popl %ebp
-; X86-NOSSE-NEXT: retl
-;
-; X86-SSE2-LABEL: test_lrint_i32_f128_strict:
-; X86-SSE2: # %bb.0:
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $16, %esp
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %ebp, %esp
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: test_lrint_i32_f128_strict:
-; X86-AVX: # %bb.0:
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $32, %esp
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: movl %ebp, %esp
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-LABEL: test_lrint_i32_f128_strict:
-; X64: # %bb.0:
-; X64-NEXT: pushq %rax
-; X64-NEXT: callq lrintl at PLT
-; X64-NEXT: popq %rcx
-; X64-NEXT: retq
- %conv = tail call i32 @llvm.experimental.constrained.lrint.i32.f128(fp128 %x, metadata!"round.dynamic", metadata!"fpexcept.strict")
- ret i32 %conv
-}
-
declare i32 @llvm.lrint.i32.f32(float) nounwind readnone
declare i32 @llvm.lrint.i32.f64(double) nounwind readnone
declare i32 @llvm.lrint.i32.f80(x86_fp80) nounwind readnone
diff --git a/llvm/test/CodeGen/X86/lrint-conv-i64.ll b/llvm/test/CodeGen/X86/lrint-conv-i64.ll
index c45918ea4d5ee..46d984cba8a89 100644
--- a/llvm/test/CodeGen/X86/lrint-conv-i64.ll
+++ b/llvm/test/CodeGen/X86/lrint-conv-i64.ll
@@ -194,46 +194,6 @@ define i64 @test_lrint_i64_f80(x86_fp80 %x) nounwind {
}
; FIXME(#44744): incorrect libcall
-define i64 @test_lrint_i64_f128(fp128 %x) nounwind {
-; X86-LABEL: test_lrint_i64_f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll lrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X86-NOX87-LABEL: test_lrint_i64_f128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %ebp, %esp
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; CHECK-LABEL: test_lrint_i64_f128:
-; CHECK: # %bb.0:
-; CHECK-NEXT: jmp lrintl at PLT # TAILCALL
- %conv = tail call i64 @llvm.lrint.i64.f128(fp128 %x)
- ret i64 %conv
-}
-
define i64 @test_lrint_i64_f16_strict(half %x) nounwind {
; X86-NOSSE-LABEL: test_lrint_i64_f16_strict:
; X86-NOSSE: # %bb.0:
@@ -387,49 +347,6 @@ define i64 @test_lrint_i64_f80_strict(x86_fp80 %x) nounwind {
}
; FIXME(#44744): incorrect libcall
-define i64 @test_lrint_i64_f128_strict(fp128 %x) nounwind {
-; X86-LABEL: test_lrint_i64_f128_strict:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll lrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X86-NOX87-LABEL: test_lrint_i64_f128_strict:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %ebp, %esp
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; CHECK-LABEL: test_lrint_i64_f128_strict:
-; CHECK: # %bb.0:
-; CHECK-NEXT: pushq %rax
-; CHECK-NEXT: callq lrintl at PLT
-; CHECK-NEXT: popq %rcx
-; CHECK-NEXT: retq
- %conv = tail call i64 @llvm.experimental.constrained.lrint.i64.f128(fp128 %x, metadata!"round.dynamic", metadata!"fpexcept.strict")
- ret i64 %conv
-}
-
define i32 @PR125324(float %x) nounwind {
; X86-NOSSE-LABEL: PR125324:
; X86-NOSSE: # %bb.0:
diff --git a/llvm/test/CodeGen/X86/lround-conv-i32.ll b/llvm/test/CodeGen/X86/lround-conv-i32.ll
index 4e95da14b45a1..02480d087d884 100644
--- a/llvm/test/CodeGen/X86/lround-conv-i32.ll
+++ b/llvm/test/CodeGen/X86/lround-conv-i32.ll
@@ -158,54 +158,6 @@ define i32 @test_lround_i32_f80(x86_fp80 %x) nounwind {
ret i32 %conv
}
-define i32 @test_lround_i32_f128(fp128 %x) nounwind {
-; X86-LABEL: test_lround_i32_f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll lroundl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X64-LABEL: test_lround_i32_f128:
-; X64: # %bb.0:
-; X64-NEXT: jmp lroundl at PLT # TAILCALL
-;
-; GISEL-X86-LABEL: test_lround_i32_f128:
-; GISEL-X86: # %bb.0:
-; GISEL-X86-NEXT: pushl %esi
-; GISEL-X86-NEXT: subl $24, %esp
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; GISEL-X86-NEXT: movl %eax, (%esp)
-; GISEL-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: calll lroundf128
-; GISEL-X86-NEXT: addl $24, %esp
-; GISEL-X86-NEXT: popl %esi
-; GISEL-X86-NEXT: retl
-;
-; GISEL-X64-LABEL: test_lround_i32_f128:
-; GISEL-X64: # %bb.0:
-; GISEL-X64-NEXT: pushq %rax
-; GISEL-X64-NEXT: callq lroundf128
-; GISEL-X64-NEXT: popq %rcx
-; GISEL-X64-NEXT: retq
- %conv = tail call i32 @llvm.lround.i32.f128(fp128 %x)
- ret i32 %conv
-}
-
; FIXME: not yet implemented in global isel
; define i32 @test_lround_i32_f16_strict(half %x) nounwind strictfp {
; %conv = tail call i32 @llvm.experimental.constrained.lround.i32.f16(half %x, metadata!"round.dynamic", metadata!"fpexcept.strict")
diff --git a/llvm/test/CodeGen/X86/lround-conv-i64.ll b/llvm/test/CodeGen/X86/lround-conv-i64.ll
index 0002bb8936d5d..f07e4a74bd5e3 100644
--- a/llvm/test/CodeGen/X86/lround-conv-i64.ll
+++ b/llvm/test/CodeGen/X86/lround-conv-i64.ll
@@ -188,55 +188,6 @@ entry:
ret i64 %0
}
-define i64 @test_lround_i64_f128(fp128 %x) nounwind {
-; X86-LABEL: test_lround_i64_f128:
-; X86: # %bb.0: # %entry
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll lroundl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X64-LABEL: test_lround_i64_f128:
-; X64: # %bb.0: # %entry
-; X64-NEXT: jmp lroundl at PLT # TAILCALL
-;
-; GISEL-X86-LABEL: test_lround_i64_f128:
-; GISEL-X86: # %bb.0: # %entry
-; GISEL-X86-NEXT: pushl %esi
-; GISEL-X86-NEXT: subl $24, %esp
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %eax
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %edx
-; GISEL-X86-NEXT: movl {{[0-9]+}}(%esp), %esi
-; GISEL-X86-NEXT: movl %eax, (%esp)
-; GISEL-X86-NEXT: movl %ecx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %edx, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: movl %esi, {{[0-9]+}}(%esp)
-; GISEL-X86-NEXT: calll lroundf128
-; GISEL-X86-NEXT: addl $24, %esp
-; GISEL-X86-NEXT: popl %esi
-; GISEL-X86-NEXT: retl
-;
-; GISEL-X64-LABEL: test_lround_i64_f128:
-; GISEL-X64: # %bb.0: # %entry
-; GISEL-X64-NEXT: pushq %rax
-; GISEL-X64-NEXT: callq lroundf128
-; GISEL-X64-NEXT: popq %rcx
-; GISEL-X64-NEXT: retq
-entry:
- %0 = tail call i64 @llvm.lround.i64.f128(fp128 %x)
- ret i64 %0
-}
-
; FIXME: not yet implemented in global isel
; define i64 @test_lround_i64_f16_strict(half %x) nounwind strictfp {
; entry:
diff --git a/llvm/test/CodeGen/X86/vector-llrint.ll b/llvm/test/CodeGen/X86/vector-llrint.ll
index 963816c4e0e2e..50b631c54d875 100644
--- a/llvm/test/CodeGen/X86/vector-llrint.ll
+++ b/llvm/test/CodeGen/X86/vector-llrint.ll
@@ -1695,878 +1695,10 @@ define <8 x i64> @llrint_v8i64_v8f64(<8 x double> %x) nounwind {
}
declare <8 x i64> @llvm.llrint.v8i64.v8f64(<8 x double>)
-define <1 x i64> @llrint_v1i64_v1f128(<1 x fp128> %x) nounwind {
-; X86-LABEL: llrint_v1i64_v1f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: pushl 8(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %ebp, %esp
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl
-;
-; X86-NOX87-LABEL: llrint_v1i64_v1f128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %ebp, %esp
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; SSE-LABEL: llrint_v1i64_v1f128:
-; SSE: # %bb.0:
-; SSE-NEXT: pushq %rax
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: popq %rcx
-; SSE-NEXT: retq
-;
-; AVX-LABEL: llrint_v1i64_v1f128:
-; AVX: # %bb.0:
-; AVX-NEXT: pushq %rax
-; AVX-NEXT: callq llrintl at PLT
-; AVX-NEXT: popq %rcx
-; AVX-NEXT: retq
-;
-; AVX512DQ-LABEL: llrint_v1i64_v1f128:
-; AVX512DQ: # %bb.0:
-; AVX512DQ-NEXT: pushq %rax
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: popq %rcx
-; AVX512DQ-NEXT: retq
- %a = call <1 x i64> @llvm.llrint.v1i64.v1f128(<1 x fp128> %x)
- ret <1 x i64> %a
-}
declare <1 x i64> @llvm.llrint.v1i64.v1f128(<1 x fp128>)
-define <2 x i64> @llrint_v2i64_v2f128(<2 x fp128> %x) nounwind {
-; X86-LABEL: llrint_v2i64_v2f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $16, %esp
-; X86-NEXT: movl 8(%ebp), %esi
-; X86-NEXT: pushl 24(%ebp)
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, %edi
-; X86-NEXT: movl %edx, %ebx
-; X86-NEXT: pushl 40(%ebp)
-; X86-NEXT: pushl 36(%ebp)
-; X86-NEXT: pushl 32(%ebp)
-; X86-NEXT: pushl 28(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %edx, 12(%esi)
-; X86-NEXT: movl %eax, 8(%esi)
-; X86-NEXT: movl %ebx, 4(%esi)
-; X86-NEXT: movl %edi, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: leal -12(%ebp), %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; X86-NOX87-LABEL: llrint_v2i64_v2f128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %esi
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-NOX87-NEXT: pushl 24(%ebp)
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %edi
-; X86-NOX87-NEXT: movl %edx, %ebx
-; X86-NOX87-NEXT: pushl 40(%ebp)
-; X86-NOX87-NEXT: pushl 36(%ebp)
-; X86-NOX87-NEXT: pushl 32(%ebp)
-; X86-NOX87-NEXT: pushl 28(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %edx, 12(%esi)
-; X86-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-NOX87-NEXT: movl %ebx, 4(%esi)
-; X86-NOX87-NEXT: movl %edi, (%esi)
-; X86-NOX87-NEXT: movl %esi, %eax
-; X86-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-NOX87-NEXT: popl %esi
-; X86-NOX87-NEXT: popl %edi
-; X86-NOX87-NEXT: popl %ebx
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl $4
-;
-; SSE-LABEL: llrint_v2i64_v2f128:
-; SSE: # %bb.0:
-; SSE-NEXT: subq $40, %rsp
-; SSE-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm1, %xmm0
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, (%rsp) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: punpcklqdq (%rsp), %xmm0 # 16-byte Folded Reload
-; SSE-NEXT: # xmm0 = xmm0[0],mem[0]
-; SSE-NEXT: addq $40, %rsp
-; SSE-NEXT: retq
-;
-; AVX-LABEL: llrint_v2i64_v2f128:
-; AVX: # %bb.0:
-; AVX-NEXT: subq $40, %rsp
-; AVX-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX-NEXT: vmovaps %xmm1, %xmm0
-; AVX-NEXT: callq llrintl at PLT
-; AVX-NEXT: vmovq %rax, %xmm0
-; AVX-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX-NEXT: callq llrintl at PLT
-; AVX-NEXT: vmovq %rax, %xmm0
-; AVX-NEXT: vpunpcklqdq (%rsp), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX-NEXT: addq $40, %rsp
-; AVX-NEXT: retq
-;
-; AVX512DQ-LABEL: llrint_v2i64_v2f128:
-; AVX512DQ: # %bb.0:
-; AVX512DQ-NEXT: subq $40, %rsp
-; AVX512DQ-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm1, %xmm0
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq (%rsp), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: addq $40, %rsp
-; AVX512DQ-NEXT: retq
- %a = call <2 x i64> @llvm.llrint.v2i64.v2f128(<2 x fp128> %x)
- ret <2 x i64> %a
-}
declare <2 x i64> @llvm.llrint.v2i64.v2f128(<2 x fp128>)
-define <4 x i64> @llrint_v4i64_v4f128(<4 x fp128> %x) nounwind {
-; X86-LABEL: llrint_v4i64_v4f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $32, %esp
-; X86-NEXT: movl 8(%ebp), %esi
-; X86-NEXT: movl 36(%ebp), %edi
-; X86-NEXT: movl 40(%ebp), %ebx
-; X86-NEXT: pushl 24(%ebp)
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl 32(%ebp)
-; X86-NEXT: pushl 28(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl 56(%ebp)
-; X86-NEXT: pushl 52(%ebp)
-; X86-NEXT: pushl 48(%ebp)
-; X86-NEXT: pushl 44(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, %edi
-; X86-NEXT: movl %edx, %ebx
-; X86-NEXT: pushl 72(%ebp)
-; X86-NEXT: pushl 68(%ebp)
-; X86-NEXT: pushl 64(%ebp)
-; X86-NEXT: pushl 60(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %edx, 28(%esi)
-; X86-NEXT: movl %eax, 24(%esi)
-; X86-NEXT: movl %ebx, 20(%esi)
-; X86-NEXT: movl %edi, 16(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 12(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 8(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 4(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: leal -12(%ebp), %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; X86-NOX87-LABEL: llrint_v4i64_v4f128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %esi
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $32, %esp
-; X86-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-NOX87-NEXT: movl 36(%ebp), %edi
-; X86-NOX87-NEXT: movl 40(%ebp), %ebx
-; X86-NOX87-NEXT: pushl 24(%ebp)
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl 32(%ebp)
-; X86-NOX87-NEXT: pushl 28(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 56(%ebp)
-; X86-NOX87-NEXT: pushl 52(%ebp)
-; X86-NOX87-NEXT: pushl 48(%ebp)
-; X86-NOX87-NEXT: pushl 44(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %edi
-; X86-NOX87-NEXT: movl %edx, %ebx
-; X86-NOX87-NEXT: pushl 72(%ebp)
-; X86-NOX87-NEXT: pushl 68(%ebp)
-; X86-NOX87-NEXT: pushl 64(%ebp)
-; X86-NOX87-NEXT: pushl 60(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %edx, 28(%esi)
-; X86-NOX87-NEXT: movl %eax, 24(%esi)
-; X86-NOX87-NEXT: movl %ebx, 20(%esi)
-; X86-NOX87-NEXT: movl %edi, 16(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 12(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 4(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, (%esi)
-; X86-NOX87-NEXT: movl %esi, %eax
-; X86-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-NOX87-NEXT: popl %esi
-; X86-NOX87-NEXT: popl %edi
-; X86-NOX87-NEXT: popl %ebx
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl $4
-;
-; SSE-LABEL: llrint_v4i64_v4f128:
-; SSE: # %bb.0:
-; SSE-NEXT: subq $72, %rsp
-; SSE-NEXT: movaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm0, (%rsp) # 16-byte Spill
-; SSE-NEXT: movaps %xmm1, %xmm0
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: punpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
-; SSE-NEXT: # xmm0 = xmm0[0],mem[0]
-; SSE-NEXT: movdqa %xmm0, (%rsp) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm1
-; SSE-NEXT: punpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Folded Reload
-; SSE-NEXT: # xmm1 = xmm1[0],mem[0]
-; SSE-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE-NEXT: addq $72, %rsp
-; SSE-NEXT: retq
-;
-; AVX1-LABEL: llrint_v4i64_v4f128:
-; AVX1: # %bb.0:
-; AVX1-NEXT: subq $72, %rsp
-; AVX1-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm3, %xmm0
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX1-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX1-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX1-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX1-NEXT: vinsertf128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX1-NEXT: addq $72, %rsp
-; AVX1-NEXT: retq
-;
-; AVX512-LABEL: llrint_v4i64_v4f128:
-; AVX512: # %bb.0:
-; AVX512-NEXT: subq $72, %rsp
-; AVX512-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm3, %xmm0
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512-NEXT: addq $72, %rsp
-; AVX512-NEXT: retq
-;
-; AVX512DQ-LABEL: llrint_v4i64_v4f128:
-; AVX512DQ: # %bb.0:
-; AVX512DQ-NEXT: subq $72, %rsp
-; AVX512DQ-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm3, %xmm0
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: addq $72, %rsp
-; AVX512DQ-NEXT: retq
- %a = call <4 x i64> @llvm.llrint.v4i64.v4f128(<4 x fp128> %x)
- ret <4 x i64> %a
-}
declare <4 x i64> @llvm.llrint.v4i64.v4f128(<4 x fp128>)
-define <8 x i64> @llrint_v8i64_v8f128(<8 x fp128> %x) nounwind {
-; X86-LABEL: llrint_v8i64_v8f128:
-; X86: # %bb.0:
-; X86-NEXT: pushl %ebp
-; X86-NEXT: movl %esp, %ebp
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl %esi
-; X86-NEXT: andl $-16, %esp
-; X86-NEXT: subl $64, %esp
-; X86-NEXT: movl 8(%ebp), %esi
-; X86-NEXT: movl 36(%ebp), %edi
-; X86-NEXT: movl 40(%ebp), %ebx
-; X86-NEXT: pushl 24(%ebp)
-; X86-NEXT: pushl 20(%ebp)
-; X86-NEXT: pushl 16(%ebp)
-; X86-NEXT: pushl 12(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl %ebx
-; X86-NEXT: pushl %edi
-; X86-NEXT: pushl 32(%ebp)
-; X86-NEXT: pushl 28(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl 56(%ebp)
-; X86-NEXT: pushl 52(%ebp)
-; X86-NEXT: pushl 48(%ebp)
-; X86-NEXT: pushl 44(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl 72(%ebp)
-; X86-NEXT: pushl 68(%ebp)
-; X86-NEXT: pushl 64(%ebp)
-; X86-NEXT: pushl 60(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl 88(%ebp)
-; X86-NEXT: pushl 84(%ebp)
-; X86-NEXT: pushl 80(%ebp)
-; X86-NEXT: pushl 76(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl 104(%ebp)
-; X86-NEXT: pushl 100(%ebp)
-; X86-NEXT: pushl 96(%ebp)
-; X86-NEXT: pushl 92(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NEXT: pushl 120(%ebp)
-; X86-NEXT: pushl 116(%ebp)
-; X86-NEXT: pushl 112(%ebp)
-; X86-NEXT: pushl 108(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %eax, %edi
-; X86-NEXT: movl %edx, %ebx
-; X86-NEXT: pushl 136(%ebp)
-; X86-NEXT: pushl 132(%ebp)
-; X86-NEXT: pushl 128(%ebp)
-; X86-NEXT: pushl 124(%ebp)
-; X86-NEXT: calll llrintl
-; X86-NEXT: addl $16, %esp
-; X86-NEXT: movl %edx, 60(%esi)
-; X86-NEXT: movl %eax, 56(%esi)
-; X86-NEXT: movl %ebx, 52(%esi)
-; X86-NEXT: movl %edi, 48(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 44(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 40(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 36(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 32(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 28(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 24(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 20(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 16(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 12(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 8(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, 4(%esi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NEXT: movl %eax, (%esi)
-; X86-NEXT: movl %esi, %eax
-; X86-NEXT: leal -12(%ebp), %esp
-; X86-NEXT: popl %esi
-; X86-NEXT: popl %edi
-; X86-NEXT: popl %ebx
-; X86-NEXT: popl %ebp
-; X86-NEXT: retl $4
-;
-; X86-NOX87-LABEL: llrint_v8i64_v8f128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %esi
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $64, %esp
-; X86-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-NOX87-NEXT: movl 36(%ebp), %edi
-; X86-NOX87-NEXT: movl 40(%ebp), %ebx
-; X86-NOX87-NEXT: pushl 24(%ebp)
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl 32(%ebp)
-; X86-NOX87-NEXT: pushl 28(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 56(%ebp)
-; X86-NOX87-NEXT: pushl 52(%ebp)
-; X86-NOX87-NEXT: pushl 48(%ebp)
-; X86-NOX87-NEXT: pushl 44(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 72(%ebp)
-; X86-NOX87-NEXT: pushl 68(%ebp)
-; X86-NOX87-NEXT: pushl 64(%ebp)
-; X86-NOX87-NEXT: pushl 60(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 88(%ebp)
-; X86-NOX87-NEXT: pushl 84(%ebp)
-; X86-NOX87-NEXT: pushl 80(%ebp)
-; X86-NOX87-NEXT: pushl 76(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 104(%ebp)
-; X86-NOX87-NEXT: pushl 100(%ebp)
-; X86-NOX87-NEXT: pushl 96(%ebp)
-; X86-NOX87-NEXT: pushl 92(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 120(%ebp)
-; X86-NOX87-NEXT: pushl 116(%ebp)
-; X86-NOX87-NEXT: pushl 112(%ebp)
-; X86-NOX87-NEXT: pushl 108(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %edi
-; X86-NOX87-NEXT: movl %edx, %ebx
-; X86-NOX87-NEXT: pushl 136(%ebp)
-; X86-NOX87-NEXT: pushl 132(%ebp)
-; X86-NOX87-NEXT: pushl 128(%ebp)
-; X86-NOX87-NEXT: pushl 124(%ebp)
-; X86-NOX87-NEXT: calll llrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %edx, 60(%esi)
-; X86-NOX87-NEXT: movl %eax, 56(%esi)
-; X86-NOX87-NEXT: movl %ebx, 52(%esi)
-; X86-NOX87-NEXT: movl %edi, 48(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 44(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 40(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 36(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 32(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 28(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 24(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 20(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 16(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 12(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 4(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, (%esi)
-; X86-NOX87-NEXT: movl %esi, %eax
-; X86-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-NOX87-NEXT: popl %esi
-; X86-NOX87-NEXT: popl %edi
-; X86-NOX87-NEXT: popl %ebx
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl $4
-;
-; SSE-LABEL: llrint_v8i64_v8f128:
-; SSE: # %bb.0:
-; SSE-NEXT: subq $136, %rsp
-; SSE-NEXT: movaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm3, (%rsp) # 16-byte Spill
-; SSE-NEXT: movaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps %xmm1, %xmm0
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: punpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
-; SSE-NEXT: # xmm0 = xmm0[0],mem[0]
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps (%rsp), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, (%rsp) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: punpcklqdq (%rsp), %xmm0 # 16-byte Folded Reload
-; SSE-NEXT: # xmm0 = xmm0[0],mem[0]
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: punpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
-; SSE-NEXT: # xmm0 = xmm0[0],mem[0]
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm0
-; SSE-NEXT: movdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: callq llrintl at PLT
-; SSE-NEXT: movq %rax, %xmm3
-; SSE-NEXT: punpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm3 # 16-byte Folded Reload
-; SSE-NEXT: # xmm3 = xmm3[0],mem[0]
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload
-; SSE-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm2 # 16-byte Reload
-; SSE-NEXT: addq $136, %rsp
-; SSE-NEXT: retq
-;
-; AVX1-LABEL: llrint_v8i64_v8f128:
-; AVX1: # %bb.0:
-; AVX1-NEXT: subq $152, %rsp
-; AVX1-NEXT: vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps %xmm3, %xmm0
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX1-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX1-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX1-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX1-NEXT: vinsertf128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX1-NEXT: vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: vzeroupper
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX1-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX1-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX1-NEXT: callq llrintl at PLT
-; AVX1-NEXT: vmovq %rax, %xmm0
-; AVX1-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX1-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX1-NEXT: vinsertf128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm1 # 16-byte Folded Reload
-; AVX1-NEXT: vmovups {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Reload
-; AVX1-NEXT: addq $152, %rsp
-; AVX1-NEXT: retq
-;
-; AVX512-LABEL: llrint_v8i64_v8f128:
-; AVX512: # %bb.0:
-; AVX512-NEXT: subq $152, %rsp
-; AVX512-NEXT: vmovaps %xmm6, (%rsp) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps %xmm7, %xmm0
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: vzeroupper
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-NEXT: callq llrintl at PLT
-; AVX512-NEXT: vmovq %rax, %xmm0
-; AVX512-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-NEXT: vinserti128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512-NEXT: vinserti64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 32-byte Folded Reload
-; AVX512-NEXT: addq $152, %rsp
-; AVX512-NEXT: retq
-;
-; AVX512DQ-LABEL: llrint_v8i64_v8f128:
-; AVX512DQ: # %bb.0:
-; AVX512DQ-NEXT: subq $152, %rsp
-; AVX512DQ-NEXT: vmovaps %xmm6, (%rsp) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps %xmm7, %xmm0
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: vzeroupper
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-NEXT: callq llrintl at PLT
-; AVX512DQ-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-NEXT: vinserti128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512DQ-NEXT: vinserti64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 32-byte Folded Reload
-; AVX512DQ-NEXT: addq $152, %rsp
-; AVX512DQ-NEXT: retq
- %a = call <8 x i64> @llvm.llrint.v8i64.v8f128(<8 x fp128> %x)
- ret <8 x i64> %a
-}
declare <8 x i64> @llvm.llrint.v8i64.v8f128(<8 x fp128>)
diff --git a/llvm/test/CodeGen/X86/vector-lrint.ll b/llvm/test/CodeGen/X86/vector-lrint.ll
index 86070fa541b84..d7261cf772c52 100644
--- a/llvm/test/CodeGen/X86/vector-lrint.ll
+++ b/llvm/test/CodeGen/X86/vector-lrint.ll
@@ -1647,1557 +1647,10 @@ define <8 x iXLen> @lrint_v8f64(<8 x double> %x) nounwind {
}
declare <8 x iXLen> @llvm.lrint.v8iXLen.v8f64(<8 x double>)
-define <1 x iXLen> @lrint_v1fp128(<1 x fp128> %x) nounwind {
-; X86-I32-LABEL: lrint_v1fp128:
-; X86-I32: # %bb.0:
-; X86-I32-NEXT: pushl %ebp
-; X86-I32-NEXT: movl %esp, %ebp
-; X86-I32-NEXT: andl $-16, %esp
-; X86-I32-NEXT: subl $16, %esp
-; X86-I32-NEXT: pushl 20(%ebp)
-; X86-I32-NEXT: pushl 16(%ebp)
-; X86-I32-NEXT: pushl 12(%ebp)
-; X86-I32-NEXT: pushl 8(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %ebp, %esp
-; X86-I32-NEXT: popl %ebp
-; X86-I32-NEXT: retl
-;
-; X86-NOX87-LABEL: lrint_v1fp128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %ebp, %esp
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; X86-I64-LABEL: lrint_v1fp128:
-; X86-I64: # %bb.0:
-; X86-I64-NEXT: pushl %ebp
-; X86-I64-NEXT: movl %esp, %ebp
-; X86-I64-NEXT: andl $-16, %esp
-; X86-I64-NEXT: subl $16, %esp
-; X86-I64-NEXT: pushl 20(%ebp)
-; X86-I64-NEXT: pushl 16(%ebp)
-; X86-I64-NEXT: pushl 12(%ebp)
-; X86-I64-NEXT: pushl 8(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %ebp, %esp
-; X86-I64-NEXT: popl %ebp
-; X86-I64-NEXT: retl
-;
-; X86-I64-NOX87-LABEL: lrint_v1fp128:
-; X86-I64-NOX87: # %bb.0:
-; X86-I64-NOX87-NEXT: pushl %ebp
-; X86-I64-NOX87-NEXT: movl %esp, %ebp
-; X86-I64-NOX87-NEXT: andl $-16, %esp
-; X86-I64-NOX87-NEXT: subl $16, %esp
-; X86-I64-NOX87-NEXT: pushl 20(%ebp)
-; X86-I64-NOX87-NEXT: pushl 16(%ebp)
-; X86-I64-NOX87-NEXT: pushl 12(%ebp)
-; X86-I64-NOX87-NEXT: pushl 8(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %ebp, %esp
-; X86-I64-NOX87-NEXT: popl %ebp
-; X86-I64-NOX87-NEXT: retl
-;
-; X86-SSE2-LABEL: lrint_v1fp128:
-; X86-SSE2: # %bb.0:
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $16, %esp
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %ebp, %esp
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: lrint_v1fp128:
-; X86-AVX: # %bb.0:
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $32, %esp
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: movl %ebp, %esp
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-AVX-i32-LABEL: lrint_v1fp128:
-; X64-AVX-i32: # %bb.0:
-; X64-AVX-i32-NEXT: pushq %rax
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: popq %rcx
-; X64-AVX-i32-NEXT: retq
-;
-; X64-AVX-i64-LABEL: lrint_v1fp128:
-; X64-AVX-i64: # %bb.0:
-; X64-AVX-i64-NEXT: pushq %rax
-; X64-AVX-i64-NEXT: callq lrintl at PLT
-; X64-AVX-i64-NEXT: popq %rcx
-; X64-AVX-i64-NEXT: retq
- %a = call <1 x iXLen> @llvm.lrint.v1iXLen.v1fp128(<1 x fp128> %x)
- ret <1 x iXLen> %a
-}
declare <1 x iXLen> @llvm.lrint.v1iXLen.v1fp128(<1 x fp128>)
-define <2 x iXLen> @lrint_v2fp128(<2 x fp128> %x) nounwind {
-; X86-I32-LABEL: lrint_v2fp128:
-; X86-I32: # %bb.0:
-; X86-I32-NEXT: pushl %ebp
-; X86-I32-NEXT: movl %esp, %ebp
-; X86-I32-NEXT: pushl %ebx
-; X86-I32-NEXT: pushl %edi
-; X86-I32-NEXT: pushl %esi
-; X86-I32-NEXT: andl $-16, %esp
-; X86-I32-NEXT: subl $16, %esp
-; X86-I32-NEXT: movl 32(%ebp), %edi
-; X86-I32-NEXT: movl 36(%ebp), %ebx
-; X86-I32-NEXT: pushl 20(%ebp)
-; X86-I32-NEXT: pushl 16(%ebp)
-; X86-I32-NEXT: pushl 12(%ebp)
-; X86-I32-NEXT: pushl 8(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, %esi
-; X86-I32-NEXT: pushl %ebx
-; X86-I32-NEXT: pushl %edi
-; X86-I32-NEXT: pushl 28(%ebp)
-; X86-I32-NEXT: pushl 24(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, %edx
-; X86-I32-NEXT: movl %esi, %eax
-; X86-I32-NEXT: leal -12(%ebp), %esp
-; X86-I32-NEXT: popl %esi
-; X86-I32-NEXT: popl %edi
-; X86-I32-NEXT: popl %ebx
-; X86-I32-NEXT: popl %ebp
-; X86-I32-NEXT: retl
-;
-; X86-NOX87-LABEL: lrint_v2fp128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %esi
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: movl 32(%ebp), %edi
-; X86-NOX87-NEXT: movl 36(%ebp), %ebx
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: pushl 8(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %esi
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl 28(%ebp)
-; X86-NOX87-NEXT: pushl 24(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %edx
-; X86-NOX87-NEXT: movl %esi, %eax
-; X86-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-NOX87-NEXT: popl %esi
-; X86-NOX87-NEXT: popl %edi
-; X86-NOX87-NEXT: popl %ebx
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl
-;
-; X86-I64-LABEL: lrint_v2fp128:
-; X86-I64: # %bb.0:
-; X86-I64-NEXT: pushl %ebp
-; X86-I64-NEXT: movl %esp, %ebp
-; X86-I64-NEXT: pushl %ebx
-; X86-I64-NEXT: pushl %edi
-; X86-I64-NEXT: pushl %esi
-; X86-I64-NEXT: andl $-16, %esp
-; X86-I64-NEXT: subl $16, %esp
-; X86-I64-NEXT: movl 8(%ebp), %esi
-; X86-I64-NEXT: pushl 24(%ebp)
-; X86-I64-NEXT: pushl 20(%ebp)
-; X86-I64-NEXT: pushl 16(%ebp)
-; X86-I64-NEXT: pushl 12(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, %edi
-; X86-I64-NEXT: movl %edx, %ebx
-; X86-I64-NEXT: pushl 40(%ebp)
-; X86-I64-NEXT: pushl 36(%ebp)
-; X86-I64-NEXT: pushl 32(%ebp)
-; X86-I64-NEXT: pushl 28(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %edx, 12(%esi)
-; X86-I64-NEXT: movl %eax, 8(%esi)
-; X86-I64-NEXT: movl %ebx, 4(%esi)
-; X86-I64-NEXT: movl %edi, (%esi)
-; X86-I64-NEXT: movl %esi, %eax
-; X86-I64-NEXT: leal -12(%ebp), %esp
-; X86-I64-NEXT: popl %esi
-; X86-I64-NEXT: popl %edi
-; X86-I64-NEXT: popl %ebx
-; X86-I64-NEXT: popl %ebp
-; X86-I64-NEXT: retl $4
-;
-; X86-I64-NOX87-LABEL: lrint_v2fp128:
-; X86-I64-NOX87: # %bb.0:
-; X86-I64-NOX87-NEXT: pushl %ebp
-; X86-I64-NOX87-NEXT: movl %esp, %ebp
-; X86-I64-NOX87-NEXT: pushl %ebx
-; X86-I64-NOX87-NEXT: pushl %edi
-; X86-I64-NOX87-NEXT: pushl %esi
-; X86-I64-NOX87-NEXT: andl $-16, %esp
-; X86-I64-NOX87-NEXT: subl $16, %esp
-; X86-I64-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-I64-NOX87-NEXT: pushl 24(%ebp)
-; X86-I64-NOX87-NEXT: pushl 20(%ebp)
-; X86-I64-NOX87-NEXT: pushl 16(%ebp)
-; X86-I64-NOX87-NEXT: pushl 12(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, %edi
-; X86-I64-NOX87-NEXT: movl %edx, %ebx
-; X86-I64-NOX87-NEXT: pushl 40(%ebp)
-; X86-I64-NOX87-NEXT: pushl 36(%ebp)
-; X86-I64-NOX87-NEXT: pushl 32(%ebp)
-; X86-I64-NOX87-NEXT: pushl 28(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %edx, 12(%esi)
-; X86-I64-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-I64-NOX87-NEXT: movl %ebx, 4(%esi)
-; X86-I64-NOX87-NEXT: movl %edi, (%esi)
-; X86-I64-NOX87-NEXT: movl %esi, %eax
-; X86-I64-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-I64-NOX87-NEXT: popl %esi
-; X86-I64-NOX87-NEXT: popl %edi
-; X86-I64-NOX87-NEXT: popl %ebx
-; X86-I64-NOX87-NEXT: popl %ebp
-; X86-I64-NOX87-NEXT: retl $4
-;
-; X86-SSE2-LABEL: lrint_v2fp128:
-; X86-SSE2: # %bb.0:
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: pushl %ebx
-; X86-SSE2-NEXT: pushl %edi
-; X86-SSE2-NEXT: pushl %esi
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $32, %esp
-; X86-SSE2-NEXT: movl 12(%ebp), %edi
-; X86-SSE2-NEXT: movl 16(%ebp), %ebx
-; X86-SSE2-NEXT: movl 20(%ebp), %esi
-; X86-SSE2-NEXT: pushl 36(%ebp)
-; X86-SSE2-NEXT: pushl 32(%ebp)
-; X86-SSE2-NEXT: pushl 28(%ebp)
-; X86-SSE2-NEXT: pushl 24(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movd %eax, %xmm0
-; X86-SSE2-NEXT: movdqa %xmm0, (%esp) # 16-byte Spill
-; X86-SSE2-NEXT: pushl %esi
-; X86-SSE2-NEXT: pushl %ebx
-; X86-SSE2-NEXT: pushl %edi
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movd %eax, %xmm0
-; X86-SSE2-NEXT: punpckldq (%esp), %xmm0 # 16-byte Folded Reload
-; X86-SSE2-NEXT: # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
-; X86-SSE2-NEXT: leal -12(%ebp), %esp
-; X86-SSE2-NEXT: popl %esi
-; X86-SSE2-NEXT: popl %edi
-; X86-SSE2-NEXT: popl %ebx
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: lrint_v2fp128:
-; X86-AVX: # %bb.0:
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $48, %esp
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: vmovups 24(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: vmovd %eax, %xmm0
-; X86-AVX-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: vmovdqa {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 # 16-byte Reload
-; X86-AVX-NEXT: vpinsrd $1, %eax, %xmm0, %xmm0
-; X86-AVX-NEXT: movl %ebp, %esp
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-AVX-i32-LABEL: lrint_v2fp128:
-; X64-AVX-i32: # %bb.0:
-; X64-AVX-i32-NEXT: pushq %rbx
-; X64-AVX-i32-NEXT: subq $16, %rsp
-; X64-AVX-i32-NEXT: vmovaps %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX-i32-NEXT: vmovaps %xmm1, %xmm0
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: movl %eax, %ebx
-; X64-AVX-i32-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: vmovd %eax, %xmm0
-; X64-AVX-i32-NEXT: vpinsrd $1, %ebx, %xmm0, %xmm0
-; X64-AVX-i32-NEXT: addq $16, %rsp
-; X64-AVX-i32-NEXT: popq %rbx
-; X64-AVX-i32-NEXT: retq
-;
-; X64-AVX-i64-LABEL: lrint_v2fp128:
-; X64-AVX-i64: # %bb.0:
-; X64-AVX-i64-NEXT: subq $40, %rsp
-; X64-AVX-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX-i64-NEXT: vmovaps %xmm1, %xmm0
-; X64-AVX-i64-NEXT: callq lrintl at PLT
-; X64-AVX-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX-i64-NEXT: callq lrintl at PLT
-; X64-AVX-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX-i64-NEXT: vpunpcklqdq (%rsp), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX-i64-NEXT: addq $40, %rsp
-; X64-AVX-i64-NEXT: retq
- %a = call <2 x iXLen> @llvm.lrint.v2iXLen.v2fp128(<2 x fp128> %x)
- ret <2 x iXLen> %a
-}
declare <2 x iXLen> @llvm.lrint.v2iXLen.v2fp128(<2 x fp128>)
-define <4 x iXLen> @lrint_v4fp128(<4 x fp128> %x) nounwind {
-; X86-I32-LABEL: lrint_v4fp128:
-; X86-I32: # %bb.0:
-; X86-I32-NEXT: pushl %ebp
-; X86-I32-NEXT: movl %esp, %ebp
-; X86-I32-NEXT: pushl %ebx
-; X86-I32-NEXT: pushl %edi
-; X86-I32-NEXT: pushl %esi
-; X86-I32-NEXT: andl $-16, %esp
-; X86-I32-NEXT: subl $16, %esp
-; X86-I32-NEXT: movl 8(%ebp), %esi
-; X86-I32-NEXT: movl 36(%ebp), %ebx
-; X86-I32-NEXT: movl 40(%ebp), %edi
-; X86-I32-NEXT: pushl 24(%ebp)
-; X86-I32-NEXT: pushl 20(%ebp)
-; X86-I32-NEXT: pushl 16(%ebp)
-; X86-I32-NEXT: pushl 12(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I32-NEXT: pushl %edi
-; X86-I32-NEXT: pushl %ebx
-; X86-I32-NEXT: pushl 32(%ebp)
-; X86-I32-NEXT: pushl 28(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, %ebx
-; X86-I32-NEXT: pushl 56(%ebp)
-; X86-I32-NEXT: pushl 52(%ebp)
-; X86-I32-NEXT: pushl 48(%ebp)
-; X86-I32-NEXT: pushl 44(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, %edi
-; X86-I32-NEXT: pushl 72(%ebp)
-; X86-I32-NEXT: pushl 68(%ebp)
-; X86-I32-NEXT: pushl 64(%ebp)
-; X86-I32-NEXT: pushl 60(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, 12(%esi)
-; X86-I32-NEXT: movl %edi, 8(%esi)
-; X86-I32-NEXT: movl %ebx, 4(%esi)
-; X86-I32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I32-NEXT: movl %eax, (%esi)
-; X86-I32-NEXT: movl %esi, %eax
-; X86-I32-NEXT: leal -12(%ebp), %esp
-; X86-I32-NEXT: popl %esi
-; X86-I32-NEXT: popl %edi
-; X86-I32-NEXT: popl %ebx
-; X86-I32-NEXT: popl %ebp
-; X86-I32-NEXT: retl $4
-;
-; X86-NOX87-LABEL: lrint_v4fp128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %esi
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $16, %esp
-; X86-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-NOX87-NEXT: movl 36(%ebp), %ebx
-; X86-NOX87-NEXT: movl 40(%ebp), %edi
-; X86-NOX87-NEXT: pushl 24(%ebp)
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl 32(%ebp)
-; X86-NOX87-NEXT: pushl 28(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %ebx
-; X86-NOX87-NEXT: pushl 56(%ebp)
-; X86-NOX87-NEXT: pushl 52(%ebp)
-; X86-NOX87-NEXT: pushl 48(%ebp)
-; X86-NOX87-NEXT: pushl 44(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %edi
-; X86-NOX87-NEXT: pushl 72(%ebp)
-; X86-NOX87-NEXT: pushl 68(%ebp)
-; X86-NOX87-NEXT: pushl 64(%ebp)
-; X86-NOX87-NEXT: pushl 60(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, 12(%esi)
-; X86-NOX87-NEXT: movl %edi, 8(%esi)
-; X86-NOX87-NEXT: movl %ebx, 4(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, (%esi)
-; X86-NOX87-NEXT: movl %esi, %eax
-; X86-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-NOX87-NEXT: popl %esi
-; X86-NOX87-NEXT: popl %edi
-; X86-NOX87-NEXT: popl %ebx
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl $4
-;
-; X86-I64-LABEL: lrint_v4fp128:
-; X86-I64: # %bb.0:
-; X86-I64-NEXT: pushl %ebp
-; X86-I64-NEXT: movl %esp, %ebp
-; X86-I64-NEXT: pushl %ebx
-; X86-I64-NEXT: pushl %edi
-; X86-I64-NEXT: pushl %esi
-; X86-I64-NEXT: andl $-16, %esp
-; X86-I64-NEXT: subl $32, %esp
-; X86-I64-NEXT: movl 8(%ebp), %esi
-; X86-I64-NEXT: movl 36(%ebp), %edi
-; X86-I64-NEXT: movl 40(%ebp), %ebx
-; X86-I64-NEXT: pushl 24(%ebp)
-; X86-I64-NEXT: pushl 20(%ebp)
-; X86-I64-NEXT: pushl 16(%ebp)
-; X86-I64-NEXT: pushl 12(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl %ebx
-; X86-I64-NEXT: pushl %edi
-; X86-I64-NEXT: pushl 32(%ebp)
-; X86-I64-NEXT: pushl 28(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl 56(%ebp)
-; X86-I64-NEXT: pushl 52(%ebp)
-; X86-I64-NEXT: pushl 48(%ebp)
-; X86-I64-NEXT: pushl 44(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, %edi
-; X86-I64-NEXT: movl %edx, %ebx
-; X86-I64-NEXT: pushl 72(%ebp)
-; X86-I64-NEXT: pushl 68(%ebp)
-; X86-I64-NEXT: pushl 64(%ebp)
-; X86-I64-NEXT: pushl 60(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %edx, 28(%esi)
-; X86-I64-NEXT: movl %eax, 24(%esi)
-; X86-I64-NEXT: movl %ebx, 20(%esi)
-; X86-I64-NEXT: movl %edi, 16(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 12(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 8(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 4(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, (%esi)
-; X86-I64-NEXT: movl %esi, %eax
-; X86-I64-NEXT: leal -12(%ebp), %esp
-; X86-I64-NEXT: popl %esi
-; X86-I64-NEXT: popl %edi
-; X86-I64-NEXT: popl %ebx
-; X86-I64-NEXT: popl %ebp
-; X86-I64-NEXT: retl $4
-;
-; X86-I64-NOX87-LABEL: lrint_v4fp128:
-; X86-I64-NOX87: # %bb.0:
-; X86-I64-NOX87-NEXT: pushl %ebp
-; X86-I64-NOX87-NEXT: movl %esp, %ebp
-; X86-I64-NOX87-NEXT: pushl %ebx
-; X86-I64-NOX87-NEXT: pushl %edi
-; X86-I64-NOX87-NEXT: pushl %esi
-; X86-I64-NOX87-NEXT: andl $-16, %esp
-; X86-I64-NOX87-NEXT: subl $32, %esp
-; X86-I64-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-I64-NOX87-NEXT: movl 36(%ebp), %edi
-; X86-I64-NOX87-NEXT: movl 40(%ebp), %ebx
-; X86-I64-NOX87-NEXT: pushl 24(%ebp)
-; X86-I64-NOX87-NEXT: pushl 20(%ebp)
-; X86-I64-NOX87-NEXT: pushl 16(%ebp)
-; X86-I64-NOX87-NEXT: pushl 12(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl %ebx
-; X86-I64-NOX87-NEXT: pushl %edi
-; X86-I64-NOX87-NEXT: pushl 32(%ebp)
-; X86-I64-NOX87-NEXT: pushl 28(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl 56(%ebp)
-; X86-I64-NOX87-NEXT: pushl 52(%ebp)
-; X86-I64-NOX87-NEXT: pushl 48(%ebp)
-; X86-I64-NOX87-NEXT: pushl 44(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, %edi
-; X86-I64-NOX87-NEXT: movl %edx, %ebx
-; X86-I64-NOX87-NEXT: pushl 72(%ebp)
-; X86-I64-NOX87-NEXT: pushl 68(%ebp)
-; X86-I64-NOX87-NEXT: pushl 64(%ebp)
-; X86-I64-NOX87-NEXT: pushl 60(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %edx, 28(%esi)
-; X86-I64-NOX87-NEXT: movl %eax, 24(%esi)
-; X86-I64-NOX87-NEXT: movl %ebx, 20(%esi)
-; X86-I64-NOX87-NEXT: movl %edi, 16(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 12(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 4(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, (%esi)
-; X86-I64-NOX87-NEXT: movl %esi, %eax
-; X86-I64-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-I64-NOX87-NEXT: popl %esi
-; X86-I64-NOX87-NEXT: popl %edi
-; X86-I64-NOX87-NEXT: popl %ebx
-; X86-I64-NOX87-NEXT: popl %ebp
-; X86-I64-NOX87-NEXT: retl $4
-;
-; X86-SSE2-LABEL: lrint_v4fp128:
-; X86-SSE2: # %bb.0:
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: pushl %ebx
-; X86-SSE2-NEXT: pushl %edi
-; X86-SSE2-NEXT: pushl %esi
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $48, %esp
-; X86-SSE2-NEXT: movl 48(%ebp), %edi
-; X86-SSE2-NEXT: movl 52(%ebp), %ebx
-; X86-SSE2-NEXT: pushl 36(%ebp)
-; X86-SSE2-NEXT: pushl 32(%ebp)
-; X86-SSE2-NEXT: pushl 28(%ebp)
-; X86-SSE2-NEXT: pushl 24(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, %esi
-; X86-SSE2-NEXT: pushl %ebx
-; X86-SSE2-NEXT: pushl %edi
-; X86-SSE2-NEXT: pushl 44(%ebp)
-; X86-SSE2-NEXT: pushl 40(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, %edi
-; X86-SSE2-NEXT: pushl 68(%ebp)
-; X86-SSE2-NEXT: pushl 64(%ebp)
-; X86-SSE2-NEXT: pushl 60(%ebp)
-; X86-SSE2-NEXT: pushl 56(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movd %eax, %xmm0
-; X86-SSE2-NEXT: movd %edi, %xmm1
-; X86-SSE2-NEXT: punpckldq {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
-; X86-SSE2-NEXT: movdqa %xmm1, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-SSE2-NEXT: movd %esi, %xmm0
-; X86-SSE2-NEXT: movdqa %xmm0, (%esp) # 16-byte Spill
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movd %eax, %xmm0
-; X86-SSE2-NEXT: punpckldq (%esp), %xmm0 # 16-byte Folded Reload
-; X86-SSE2-NEXT: # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
-; X86-SSE2-NEXT: punpcklqdq {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 # 16-byte Folded Reload
-; X86-SSE2-NEXT: # xmm0 = xmm0[0],mem[0]
-; X86-SSE2-NEXT: leal -12(%ebp), %esp
-; X86-SSE2-NEXT: popl %esi
-; X86-SSE2-NEXT: popl %edi
-; X86-SSE2-NEXT: popl %ebx
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX-LABEL: lrint_v4fp128:
-; X86-AVX: # %bb.0:
-; X86-AVX-NEXT: pushl %ebp
-; X86-AVX-NEXT: movl %esp, %ebp
-; X86-AVX-NEXT: pushl %edi
-; X86-AVX-NEXT: pushl %esi
-; X86-AVX-NEXT: andl $-16, %esp
-; X86-AVX-NEXT: subl $32, %esp
-; X86-AVX-NEXT: vmovups 40(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: movl %eax, %esi
-; X86-AVX-NEXT: vmovups 24(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: movl %eax, %edi
-; X86-AVX-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: vmovups 56(%ebp), %xmm0
-; X86-AVX-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX-NEXT: vmovd %eax, %xmm0
-; X86-AVX-NEXT: vpinsrd $1, %edi, %xmm0, %xmm0
-; X86-AVX-NEXT: vpinsrd $2, %esi, %xmm0, %xmm0
-; X86-AVX-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-AVX-NEXT: calll lrintl
-; X86-AVX-NEXT: vmovdqa {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 # 16-byte Reload
-; X86-AVX-NEXT: vpinsrd $3, %eax, %xmm0, %xmm0
-; X86-AVX-NEXT: leal -8(%ebp), %esp
-; X86-AVX-NEXT: popl %esi
-; X86-AVX-NEXT: popl %edi
-; X86-AVX-NEXT: popl %ebp
-; X86-AVX-NEXT: retl
-;
-; X64-AVX-i32-LABEL: lrint_v4fp128:
-; X64-AVX-i32: # %bb.0:
-; X64-AVX-i32-NEXT: pushq %rbx
-; X64-AVX-i32-NEXT: subq $48, %rsp
-; X64-AVX-i32-NEXT: vmovaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX-i32-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX-i32-NEXT: vmovaps %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX-i32-NEXT: vmovaps %xmm1, %xmm0
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: movl %eax, %ebx
-; X64-AVX-i32-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: vmovd %eax, %xmm0
-; X64-AVX-i32-NEXT: vpinsrd $1, %ebx, %xmm0, %xmm0
-; X64-AVX-i32-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: vmovdqa (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX-i32-NEXT: vpinsrd $2, %eax, %xmm0, %xmm0
-; X64-AVX-i32-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX-i32-NEXT: callq lrintl at PLT
-; X64-AVX-i32-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX-i32-NEXT: vpinsrd $3, %eax, %xmm0, %xmm0
-; X64-AVX-i32-NEXT: addq $48, %rsp
-; X64-AVX-i32-NEXT: popq %rbx
-; X64-AVX-i32-NEXT: retq
-;
-; X64-AVX1-i64-LABEL: lrint_v4fp128:
-; X64-AVX1-i64: # %bb.0:
-; X64-AVX1-i64-NEXT: subq $72, %rsp
-; X64-AVX1-i64-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm3, %xmm0
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX1-i64-NEXT: vinsertf128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: addq $72, %rsp
-; X64-AVX1-i64-NEXT: retq
-;
-; AVX512-i64-LABEL: lrint_v4fp128:
-; AVX512-i64: # %bb.0:
-; AVX512-i64-NEXT: subq $72, %rsp
-; AVX512-i64-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm3, %xmm0
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-i64-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: addq $72, %rsp
-; AVX512-i64-NEXT: retq
-;
-; AVX512DQ-i64-LABEL: lrint_v4fp128:
-; AVX512DQ-i64: # %bb.0:
-; AVX512DQ-i64-NEXT: subq $72, %rsp
-; AVX512DQ-i64-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm3, %xmm0
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-i64-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: addq $72, %rsp
-; AVX512DQ-i64-NEXT: retq
- %a = call <4 x iXLen> @llvm.lrint.v4iXLen.v4fp128(<4 x fp128> %x)
- ret <4 x iXLen> %a
-}
declare <4 x iXLen> @llvm.lrint.v4iXLen.v4fp128(<4 x fp128>)
-define <8 x iXLen> @lrint_v8fp128(<8 x fp128> %x) nounwind {
-; X86-I32-LABEL: lrint_v8fp128:
-; X86-I32: # %bb.0:
-; X86-I32-NEXT: pushl %ebp
-; X86-I32-NEXT: movl %esp, %ebp
-; X86-I32-NEXT: pushl %ebx
-; X86-I32-NEXT: pushl %edi
-; X86-I32-NEXT: pushl %esi
-; X86-I32-NEXT: andl $-16, %esp
-; X86-I32-NEXT: subl $32, %esp
-; X86-I32-NEXT: movl 8(%ebp), %esi
-; X86-I32-NEXT: movl 36(%ebp), %ebx
-; X86-I32-NEXT: movl 40(%ebp), %edi
-; X86-I32-NEXT: pushl 24(%ebp)
-; X86-I32-NEXT: pushl 20(%ebp)
-; X86-I32-NEXT: pushl 16(%ebp)
-; X86-I32-NEXT: pushl 12(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I32-NEXT: pushl %edi
-; X86-I32-NEXT: pushl %ebx
-; X86-I32-NEXT: pushl 32(%ebp)
-; X86-I32-NEXT: pushl 28(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I32-NEXT: pushl 56(%ebp)
-; X86-I32-NEXT: pushl 52(%ebp)
-; X86-I32-NEXT: pushl 48(%ebp)
-; X86-I32-NEXT: pushl 44(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I32-NEXT: pushl 72(%ebp)
-; X86-I32-NEXT: pushl 68(%ebp)
-; X86-I32-NEXT: pushl 64(%ebp)
-; X86-I32-NEXT: pushl 60(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I32-NEXT: pushl 88(%ebp)
-; X86-I32-NEXT: pushl 84(%ebp)
-; X86-I32-NEXT: pushl 80(%ebp)
-; X86-I32-NEXT: pushl 76(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I32-NEXT: pushl 104(%ebp)
-; X86-I32-NEXT: pushl 100(%ebp)
-; X86-I32-NEXT: pushl 96(%ebp)
-; X86-I32-NEXT: pushl 92(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, %ebx
-; X86-I32-NEXT: pushl 120(%ebp)
-; X86-I32-NEXT: pushl 116(%ebp)
-; X86-I32-NEXT: pushl 112(%ebp)
-; X86-I32-NEXT: pushl 108(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, %edi
-; X86-I32-NEXT: pushl 136(%ebp)
-; X86-I32-NEXT: pushl 132(%ebp)
-; X86-I32-NEXT: pushl 128(%ebp)
-; X86-I32-NEXT: pushl 124(%ebp)
-; X86-I32-NEXT: calll lrintl
-; X86-I32-NEXT: addl $16, %esp
-; X86-I32-NEXT: movl %eax, 28(%esi)
-; X86-I32-NEXT: movl %edi, 24(%esi)
-; X86-I32-NEXT: movl %ebx, 20(%esi)
-; X86-I32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I32-NEXT: movl %eax, 16(%esi)
-; X86-I32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I32-NEXT: movl %eax, 12(%esi)
-; X86-I32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I32-NEXT: movl %eax, 8(%esi)
-; X86-I32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I32-NEXT: movl %eax, 4(%esi)
-; X86-I32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I32-NEXT: movl %eax, (%esi)
-; X86-I32-NEXT: movl %esi, %eax
-; X86-I32-NEXT: leal -12(%ebp), %esp
-; X86-I32-NEXT: popl %esi
-; X86-I32-NEXT: popl %edi
-; X86-I32-NEXT: popl %ebx
-; X86-I32-NEXT: popl %ebp
-; X86-I32-NEXT: retl $4
-;
-; X86-NOX87-LABEL: lrint_v8fp128:
-; X86-NOX87: # %bb.0:
-; X86-NOX87-NEXT: pushl %ebp
-; X86-NOX87-NEXT: movl %esp, %ebp
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %esi
-; X86-NOX87-NEXT: andl $-16, %esp
-; X86-NOX87-NEXT: subl $32, %esp
-; X86-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-NOX87-NEXT: movl 36(%ebp), %ebx
-; X86-NOX87-NEXT: movl 40(%ebp), %edi
-; X86-NOX87-NEXT: pushl 24(%ebp)
-; X86-NOX87-NEXT: pushl 20(%ebp)
-; X86-NOX87-NEXT: pushl 16(%ebp)
-; X86-NOX87-NEXT: pushl 12(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl %edi
-; X86-NOX87-NEXT: pushl %ebx
-; X86-NOX87-NEXT: pushl 32(%ebp)
-; X86-NOX87-NEXT: pushl 28(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 56(%ebp)
-; X86-NOX87-NEXT: pushl 52(%ebp)
-; X86-NOX87-NEXT: pushl 48(%ebp)
-; X86-NOX87-NEXT: pushl 44(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 72(%ebp)
-; X86-NOX87-NEXT: pushl 68(%ebp)
-; X86-NOX87-NEXT: pushl 64(%ebp)
-; X86-NOX87-NEXT: pushl 60(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 88(%ebp)
-; X86-NOX87-NEXT: pushl 84(%ebp)
-; X86-NOX87-NEXT: pushl 80(%ebp)
-; X86-NOX87-NEXT: pushl 76(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-NOX87-NEXT: pushl 104(%ebp)
-; X86-NOX87-NEXT: pushl 100(%ebp)
-; X86-NOX87-NEXT: pushl 96(%ebp)
-; X86-NOX87-NEXT: pushl 92(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %ebx
-; X86-NOX87-NEXT: pushl 120(%ebp)
-; X86-NOX87-NEXT: pushl 116(%ebp)
-; X86-NOX87-NEXT: pushl 112(%ebp)
-; X86-NOX87-NEXT: pushl 108(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, %edi
-; X86-NOX87-NEXT: pushl 136(%ebp)
-; X86-NOX87-NEXT: pushl 132(%ebp)
-; X86-NOX87-NEXT: pushl 128(%ebp)
-; X86-NOX87-NEXT: pushl 124(%ebp)
-; X86-NOX87-NEXT: calll lrintl
-; X86-NOX87-NEXT: addl $16, %esp
-; X86-NOX87-NEXT: movl %eax, 28(%esi)
-; X86-NOX87-NEXT: movl %edi, 24(%esi)
-; X86-NOX87-NEXT: movl %ebx, 20(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 16(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 12(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, 4(%esi)
-; X86-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-NOX87-NEXT: movl %eax, (%esi)
-; X86-NOX87-NEXT: movl %esi, %eax
-; X86-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-NOX87-NEXT: popl %esi
-; X86-NOX87-NEXT: popl %edi
-; X86-NOX87-NEXT: popl %ebx
-; X86-NOX87-NEXT: popl %ebp
-; X86-NOX87-NEXT: retl $4
-;
-; X86-I64-LABEL: lrint_v8fp128:
-; X86-I64: # %bb.0:
-; X86-I64-NEXT: pushl %ebp
-; X86-I64-NEXT: movl %esp, %ebp
-; X86-I64-NEXT: pushl %ebx
-; X86-I64-NEXT: pushl %edi
-; X86-I64-NEXT: pushl %esi
-; X86-I64-NEXT: andl $-16, %esp
-; X86-I64-NEXT: subl $64, %esp
-; X86-I64-NEXT: movl 8(%ebp), %esi
-; X86-I64-NEXT: movl 36(%ebp), %edi
-; X86-I64-NEXT: movl 40(%ebp), %ebx
-; X86-I64-NEXT: pushl 24(%ebp)
-; X86-I64-NEXT: pushl 20(%ebp)
-; X86-I64-NEXT: pushl 16(%ebp)
-; X86-I64-NEXT: pushl 12(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl %ebx
-; X86-I64-NEXT: pushl %edi
-; X86-I64-NEXT: pushl 32(%ebp)
-; X86-I64-NEXT: pushl 28(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl 56(%ebp)
-; X86-I64-NEXT: pushl 52(%ebp)
-; X86-I64-NEXT: pushl 48(%ebp)
-; X86-I64-NEXT: pushl 44(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl 72(%ebp)
-; X86-I64-NEXT: pushl 68(%ebp)
-; X86-I64-NEXT: pushl 64(%ebp)
-; X86-I64-NEXT: pushl 60(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl 88(%ebp)
-; X86-I64-NEXT: pushl 84(%ebp)
-; X86-I64-NEXT: pushl 80(%ebp)
-; X86-I64-NEXT: pushl 76(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl 104(%ebp)
-; X86-I64-NEXT: pushl 100(%ebp)
-; X86-I64-NEXT: pushl 96(%ebp)
-; X86-I64-NEXT: pushl 92(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NEXT: pushl 120(%ebp)
-; X86-I64-NEXT: pushl 116(%ebp)
-; X86-I64-NEXT: pushl 112(%ebp)
-; X86-I64-NEXT: pushl 108(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %eax, %edi
-; X86-I64-NEXT: movl %edx, %ebx
-; X86-I64-NEXT: pushl 136(%ebp)
-; X86-I64-NEXT: pushl 132(%ebp)
-; X86-I64-NEXT: pushl 128(%ebp)
-; X86-I64-NEXT: pushl 124(%ebp)
-; X86-I64-NEXT: calll lrintl
-; X86-I64-NEXT: addl $16, %esp
-; X86-I64-NEXT: movl %edx, 60(%esi)
-; X86-I64-NEXT: movl %eax, 56(%esi)
-; X86-I64-NEXT: movl %ebx, 52(%esi)
-; X86-I64-NEXT: movl %edi, 48(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 44(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 40(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 36(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 32(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 28(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 24(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 20(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 16(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 12(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 8(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, 4(%esi)
-; X86-I64-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NEXT: movl %eax, (%esi)
-; X86-I64-NEXT: movl %esi, %eax
-; X86-I64-NEXT: leal -12(%ebp), %esp
-; X86-I64-NEXT: popl %esi
-; X86-I64-NEXT: popl %edi
-; X86-I64-NEXT: popl %ebx
-; X86-I64-NEXT: popl %ebp
-; X86-I64-NEXT: retl $4
-;
-; X86-I64-NOX87-LABEL: lrint_v8fp128:
-; X86-I64-NOX87: # %bb.0:
-; X86-I64-NOX87-NEXT: pushl %ebp
-; X86-I64-NOX87-NEXT: movl %esp, %ebp
-; X86-I64-NOX87-NEXT: pushl %ebx
-; X86-I64-NOX87-NEXT: pushl %edi
-; X86-I64-NOX87-NEXT: pushl %esi
-; X86-I64-NOX87-NEXT: andl $-16, %esp
-; X86-I64-NOX87-NEXT: subl $64, %esp
-; X86-I64-NOX87-NEXT: movl 8(%ebp), %esi
-; X86-I64-NOX87-NEXT: movl 36(%ebp), %edi
-; X86-I64-NOX87-NEXT: movl 40(%ebp), %ebx
-; X86-I64-NOX87-NEXT: pushl 24(%ebp)
-; X86-I64-NOX87-NEXT: pushl 20(%ebp)
-; X86-I64-NOX87-NEXT: pushl 16(%ebp)
-; X86-I64-NOX87-NEXT: pushl 12(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl %ebx
-; X86-I64-NOX87-NEXT: pushl %edi
-; X86-I64-NOX87-NEXT: pushl 32(%ebp)
-; X86-I64-NOX87-NEXT: pushl 28(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl 56(%ebp)
-; X86-I64-NOX87-NEXT: pushl 52(%ebp)
-; X86-I64-NOX87-NEXT: pushl 48(%ebp)
-; X86-I64-NOX87-NEXT: pushl 44(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl 72(%ebp)
-; X86-I64-NOX87-NEXT: pushl 68(%ebp)
-; X86-I64-NOX87-NEXT: pushl 64(%ebp)
-; X86-I64-NOX87-NEXT: pushl 60(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl 88(%ebp)
-; X86-I64-NOX87-NEXT: pushl 84(%ebp)
-; X86-I64-NOX87-NEXT: pushl 80(%ebp)
-; X86-I64-NOX87-NEXT: pushl 76(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl 104(%ebp)
-; X86-I64-NOX87-NEXT: pushl 100(%ebp)
-; X86-I64-NOX87-NEXT: pushl 96(%ebp)
-; X86-I64-NOX87-NEXT: pushl 92(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-I64-NOX87-NEXT: pushl 120(%ebp)
-; X86-I64-NOX87-NEXT: pushl 116(%ebp)
-; X86-I64-NOX87-NEXT: pushl 112(%ebp)
-; X86-I64-NOX87-NEXT: pushl 108(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %eax, %edi
-; X86-I64-NOX87-NEXT: movl %edx, %ebx
-; X86-I64-NOX87-NEXT: pushl 136(%ebp)
-; X86-I64-NOX87-NEXT: pushl 132(%ebp)
-; X86-I64-NOX87-NEXT: pushl 128(%ebp)
-; X86-I64-NOX87-NEXT: pushl 124(%ebp)
-; X86-I64-NOX87-NEXT: calll lrintl
-; X86-I64-NOX87-NEXT: addl $16, %esp
-; X86-I64-NOX87-NEXT: movl %edx, 60(%esi)
-; X86-I64-NOX87-NEXT: movl %eax, 56(%esi)
-; X86-I64-NOX87-NEXT: movl %ebx, 52(%esi)
-; X86-I64-NOX87-NEXT: movl %edi, 48(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 44(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 40(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 36(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 32(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 28(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 24(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 20(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 16(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 12(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 8(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, 4(%esi)
-; X86-I64-NOX87-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
-; X86-I64-NOX87-NEXT: movl %eax, (%esi)
-; X86-I64-NOX87-NEXT: movl %esi, %eax
-; X86-I64-NOX87-NEXT: leal -12(%ebp), %esp
-; X86-I64-NOX87-NEXT: popl %esi
-; X86-I64-NOX87-NEXT: popl %edi
-; X86-I64-NOX87-NEXT: popl %ebx
-; X86-I64-NOX87-NEXT: popl %ebp
-; X86-I64-NOX87-NEXT: retl $4
-;
-; X86-SSE2-LABEL: lrint_v8fp128:
-; X86-SSE2: # %bb.0:
-; X86-SSE2-NEXT: pushl %ebp
-; X86-SSE2-NEXT: movl %esp, %ebp
-; X86-SSE2-NEXT: pushl %ebx
-; X86-SSE2-NEXT: pushl %edi
-; X86-SSE2-NEXT: pushl %esi
-; X86-SSE2-NEXT: andl $-16, %esp
-; X86-SSE2-NEXT: subl $64, %esp
-; X86-SSE2-NEXT: movl 108(%ebp), %esi
-; X86-SSE2-NEXT: movl 112(%ebp), %edi
-; X86-SSE2-NEXT: movl 116(%ebp), %ebx
-; X86-SSE2-NEXT: pushl 100(%ebp)
-; X86-SSE2-NEXT: pushl 96(%ebp)
-; X86-SSE2-NEXT: pushl 92(%ebp)
-; X86-SSE2-NEXT: pushl 88(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-SSE2-NEXT: pushl %ebx
-; X86-SSE2-NEXT: pushl %edi
-; X86-SSE2-NEXT: pushl %esi
-; X86-SSE2-NEXT: pushl 104(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-SSE2-NEXT: pushl 132(%ebp)
-; X86-SSE2-NEXT: pushl 128(%ebp)
-; X86-SSE2-NEXT: pushl 124(%ebp)
-; X86-SSE2-NEXT: pushl 120(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, (%esp) # 4-byte Spill
-; X86-SSE2-NEXT: pushl 20(%ebp)
-; X86-SSE2-NEXT: pushl 16(%ebp)
-; X86-SSE2-NEXT: pushl 12(%ebp)
-; X86-SSE2-NEXT: pushl 8(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, %esi
-; X86-SSE2-NEXT: pushl 36(%ebp)
-; X86-SSE2-NEXT: pushl 32(%ebp)
-; X86-SSE2-NEXT: pushl 28(%ebp)
-; X86-SSE2-NEXT: pushl 24(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, %edi
-; X86-SSE2-NEXT: pushl 52(%ebp)
-; X86-SSE2-NEXT: pushl 48(%ebp)
-; X86-SSE2-NEXT: pushl 44(%ebp)
-; X86-SSE2-NEXT: pushl 40(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movl %eax, %ebx
-; X86-SSE2-NEXT: pushl 68(%ebp)
-; X86-SSE2-NEXT: pushl 64(%ebp)
-; X86-SSE2-NEXT: pushl 60(%ebp)
-; X86-SSE2-NEXT: pushl 56(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movd %eax, %xmm0
-; X86-SSE2-NEXT: movd %ebx, %xmm1
-; X86-SSE2-NEXT: movd %edi, %xmm2
-; X86-SSE2-NEXT: movd %esi, %xmm4
-; X86-SSE2-NEXT: movss (%esp), %xmm3 # 4-byte Reload
-; X86-SSE2-NEXT: # xmm3 = mem[0],zero,zero,zero
-; X86-SSE2-NEXT: movss {{[-0-9]+}}(%e{{[sb]}}p), %xmm5 # 4-byte Reload
-; X86-SSE2-NEXT: # xmm5 = mem[0],zero,zero,zero
-; X86-SSE2-NEXT: movss {{[-0-9]+}}(%e{{[sb]}}p), %xmm6 # 4-byte Reload
-; X86-SSE2-NEXT: # xmm6 = mem[0],zero,zero,zero
-; X86-SSE2-NEXT: movaps %xmm6, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-SSE2-NEXT: punpckldq {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
-; X86-SSE2-NEXT: punpckldq {{.*#+}} xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
-; X86-SSE2-NEXT: punpcklqdq {{.*#+}} xmm4 = xmm4[0],xmm1[0]
-; X86-SSE2-NEXT: movdqa %xmm4, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-SSE2-NEXT: unpcklps {{.*#+}} xmm5 = xmm5[0],xmm3[0],xmm5[1],xmm3[1]
-; X86-SSE2-NEXT: movaps %xmm5, (%esp) # 16-byte Spill
-; X86-SSE2-NEXT: pushl 84(%ebp)
-; X86-SSE2-NEXT: pushl 80(%ebp)
-; X86-SSE2-NEXT: pushl 76(%ebp)
-; X86-SSE2-NEXT: pushl 72(%ebp)
-; X86-SSE2-NEXT: calll lrintl
-; X86-SSE2-NEXT: addl $16, %esp
-; X86-SSE2-NEXT: movd %eax, %xmm1
-; X86-SSE2-NEXT: punpckldq {{[-0-9]+}}(%e{{[sb]}}p), %xmm1 # 16-byte Folded Reload
-; X86-SSE2-NEXT: # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
-; X86-SSE2-NEXT: punpcklqdq (%esp), %xmm1 # 16-byte Folded Reload
-; X86-SSE2-NEXT: # xmm1 = xmm1[0],mem[0]
-; X86-SSE2-NEXT: movaps {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 # 16-byte Reload
-; X86-SSE2-NEXT: leal -12(%ebp), %esp
-; X86-SSE2-NEXT: popl %esi
-; X86-SSE2-NEXT: popl %edi
-; X86-SSE2-NEXT: popl %ebx
-; X86-SSE2-NEXT: popl %ebp
-; X86-SSE2-NEXT: retl
-;
-; X86-AVX1-LABEL: lrint_v8fp128:
-; X86-AVX1: # %bb.0:
-; X86-AVX1-NEXT: pushl %ebp
-; X86-AVX1-NEXT: movl %esp, %ebp
-; X86-AVX1-NEXT: pushl %ebx
-; X86-AVX1-NEXT: pushl %edi
-; X86-AVX1-NEXT: pushl %esi
-; X86-AVX1-NEXT: andl $-16, %esp
-; X86-AVX1-NEXT: subl $80, %esp
-; X86-AVX1-NEXT: vmovups 40(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-AVX1-NEXT: vmovups 24(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-AVX1-NEXT: vmovups 8(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X86-AVX1-NEXT: vmovups 120(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: movl %eax, %esi
-; X86-AVX1-NEXT: vmovups 104(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: movl %eax, %edi
-; X86-AVX1-NEXT: vmovups 88(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: movl %eax, %ebx
-; X86-AVX1-NEXT: vmovups 72(%ebp), %xmm0
-; X86-AVX1-NEXT: vmovups %xmm0, (%esp)
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: vmovd %eax, %xmm0
-; X86-AVX1-NEXT: vpinsrd $1, %ebx, %xmm0, %xmm0
-; X86-AVX1-NEXT: vpinsrd $2, %edi, %xmm0, %xmm0
-; X86-AVX1-NEXT: vpinsrd $3, %esi, %xmm0, %xmm0
-; X86-AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-AVX1-NEXT: vmovd {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 # 4-byte Folded Reload
-; X86-AVX1-NEXT: # xmm0 = mem[0],zero,zero,zero
-; X86-AVX1-NEXT: vpinsrd $1, {{[-0-9]+}}(%e{{[sb]}}p), %xmm0, %xmm0 # 4-byte Folded Reload
-; X86-AVX1-NEXT: vmovups 56(%ebp), %xmm1
-; X86-AVX1-NEXT: vmovups %xmm1, (%esp)
-; X86-AVX1-NEXT: vpinsrd $2, {{[-0-9]+}}(%e{{[sb]}}p), %xmm0, %xmm0 # 4-byte Folded Reload
-; X86-AVX1-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
-; X86-AVX1-NEXT: calll lrintl
-; X86-AVX1-NEXT: vmovdqa {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 # 16-byte Reload
-; X86-AVX1-NEXT: vpinsrd $3, %eax, %xmm0, %xmm0
-; X86-AVX1-NEXT: vinsertf128 $1, {{[-0-9]+}}(%e{{[sb]}}p), %ymm0, %ymm0 # 16-byte Folded Reload
-; X86-AVX1-NEXT: leal -12(%ebp), %esp
-; X86-AVX1-NEXT: popl %esi
-; X86-AVX1-NEXT: popl %edi
-; X86-AVX1-NEXT: popl %ebx
-; X86-AVX1-NEXT: popl %ebp
-; X86-AVX1-NEXT: retl
-;
-; X64-AVX1-i32-LABEL: lrint_v8fp128:
-; X64-AVX1-i32: # %bb.0:
-; X64-AVX1-i32-NEXT: pushq %rbx
-; X64-AVX1-i32-NEXT: subq $112, %rsp
-; X64-AVX1-i32-NEXT: vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm4, (%rsp) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps %xmm5, %xmm0
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: movl %eax, %ebx
-; X64-AVX1-i32-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: vmovd %eax, %xmm0
-; X64-AVX1-i32-NEXT: vpinsrd $1, %ebx, %xmm0, %xmm0
-; X64-AVX1-i32-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: vmovdqa (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: vpinsrd $2, %eax, %xmm0, %xmm0
-; X64-AVX1-i32-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: vpinsrd $3, %eax, %xmm0, %xmm0
-; X64-AVX1-i32-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: movl %eax, %ebx
-; X64-AVX1-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: vmovd %eax, %xmm0
-; X64-AVX1-i32-NEXT: vpinsrd $1, %ebx, %xmm0, %xmm0
-; X64-AVX1-i32-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: vpinsrd $2, %eax, %xmm0, %xmm0
-; X64-AVX1-i32-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i32-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: callq lrintl at PLT
-; X64-AVX1-i32-NEXT: vmovdqa {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i32-NEXT: vpinsrd $3, %eax, %xmm0, %xmm0
-; X64-AVX1-i32-NEXT: vinsertf128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 16-byte Folded Reload
-; X64-AVX1-i32-NEXT: addq $112, %rsp
-; X64-AVX1-i32-NEXT: popq %rbx
-; X64-AVX1-i32-NEXT: retq
-;
-; X64-AVX1-i64-LABEL: lrint_v8fp128:
-; X64-AVX1-i64: # %bb.0:
-; X64-AVX1-i64-NEXT: subq $152, %rsp
-; X64-AVX1-i64-NEXT: vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm2, (%rsp) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps %xmm3, %xmm0
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX1-i64-NEXT: vinsertf128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: vzeroupper
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; X64-AVX1-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; X64-AVX1-i64-NEXT: callq lrintl at PLT
-; X64-AVX1-i64-NEXT: vmovq %rax, %xmm0
-; X64-AVX1-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; X64-AVX1-i64-NEXT: vinsertf128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm1 # 16-byte Folded Reload
-; X64-AVX1-i64-NEXT: vmovups {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Reload
-; X64-AVX1-i64-NEXT: addq $152, %rsp
-; X64-AVX1-i64-NEXT: retq
-;
-; AVX512-i64-LABEL: lrint_v8fp128:
-; AVX512-i64: # %bb.0:
-; AVX512-i64-NEXT: subq $152, %rsp
-; AVX512-i64-NEXT: vmovaps %xmm6, (%rsp) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps %xmm7, %xmm0
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-i64-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: vzeroupper
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512-i64-NEXT: callq lrintl at PLT
-; AVX512-i64-NEXT: vmovq %rax, %xmm0
-; AVX512-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512-i64-NEXT: vinserti128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512-i64-NEXT: vinserti64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 32-byte Folded Reload
-; AVX512-i64-NEXT: addq $152, %rsp
-; AVX512-i64-NEXT: retq
-;
-; AVX512DQ-i64-LABEL: lrint_v8fp128:
-; AVX512DQ-i64: # %bb.0:
-; AVX512DQ-i64-NEXT: subq $152, %rsp
-; AVX512DQ-i64-NEXT: vmovaps %xmm6, (%rsp) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm5, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm4, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps %xmm7, %xmm0
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps (%rsp), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, (%rsp) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-i64-NEXT: vinserti128 $1, (%rsp), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: vzeroupper
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vmovdqa %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; AVX512DQ-i64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
-; AVX512DQ-i64-NEXT: callq lrintl at PLT
-; AVX512DQ-i64-NEXT: vmovq %rax, %xmm0
-; AVX512DQ-i64-NEXT: vpunpcklqdq {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: # xmm0 = xmm0[0],mem[0]
-; AVX512DQ-i64-NEXT: vinserti128 $1, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 16-byte Folded Reload
-; AVX512DQ-i64-NEXT: vinserti64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 32-byte Folded Reload
-; AVX512DQ-i64-NEXT: addq $152, %rsp
-; AVX512DQ-i64-NEXT: retq
- %a = call <8 x iXLen> @llvm.lrint.v8iXLen.v8fp128(<8 x fp128> %x)
- ret <8 x iXLen> %a
-}
declare <8 x iXLen> @llvm.lrint.v8iXLen.v8fp128(<8 x fp128>)
diff --git a/llvm/test/CodeGen/XCore/llvm.exp10.ll b/llvm/test/CodeGen/XCore/llvm.exp10.ll
index 0431c0e45a45e..f3eb735c08658 100644
--- a/llvm/test/CodeGen/XCore/llvm.exp10.ll
+++ b/llvm/test/CodeGen/XCore/llvm.exp10.ll
@@ -51,19 +51,4 @@ define <2 x double> @exp10_v2f64(<2 x double> %x) #0 {
ret <2 x double> %r
}
-; CHECK-LABEL: exp10_f128:
-; CHECK: bl exp10l
-define fp128 @exp10_f128(fp128 %x) #0 {
- %r = call fp128 @llvm.exp10.f128(fp128 %x)
- ret fp128 %r
-}
-
-; CHECK-LABEL: exp10_v2f128:
-; CHECK: bl exp10l
-; CHECK: bl exp10l
-define <2 x fp128> @exp10_v2f128(<2 x fp128> %x) #0 {
- %r = call <2 x fp128> @llvm.exp10.v2f128(<2 x fp128> %x)
- ret <2 x fp128> %r
-}
-
attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/XCore/llvm.frexp.ll b/llvm/test/CodeGen/XCore/llvm.frexp.ll
index b9c200e0a5e0e..4065a44aeb322 100644
--- a/llvm/test/CodeGen/XCore/llvm.frexp.ll
+++ b/llvm/test/CodeGen/XCore/llvm.frexp.ll
@@ -55,21 +55,6 @@ define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) noun
ret { <2 x double>, <2 x i32> } %result
}
-define { fp128, i32 } @test_frexp_fp128_i32(fp128 %a) nounwind {
-; CHECK-LABEL: test_frexp_fp128_i32:
-; CHECK: bl frexpl
- %result = call { fp128, i32 } @llvm.frexp.fp128.i32(fp128 %a)
- ret { fp128, i32 } %result
-}
-
-define { <2 x fp128>, <2 x i32> } @test_frexp_v2fp128_v2i32(<2 x fp128> %a) nounwind {
-; CHECK-LABEL: test_frexp_v2fp128_v2i32:
-; CHECK: bl frexpl
-; CHECK: bl frexpl
- %result = call { <2 x fp128>, <2 x i32> } @llvm.frexp.v2fp128.v2i32(<2 x fp128> %a)
- ret { <2 x fp128>, <2 x i32> } %result
-}
-
declare { half, i32 } @llvm.frexp.f16.i32(half) #0
declare { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half>) #0
diff --git a/llvm/test/CodeGen/XCore/llvm.sincos.ll b/llvm/test/CodeGen/XCore/llvm.sincos.ll
index cae875d092bc6..7dfac069f3017 100644
--- a/llvm/test/CodeGen/XCore/llvm.sincos.ll
+++ b/llvm/test/CodeGen/XCore/llvm.sincos.ll
@@ -62,21 +62,3 @@ define { <2 x double>, <2 x double> } @test_sincos_v2f64(<2 x double> %a) nounwi
%result = call { <2 x double>, <2 x double> } @llvm.sincos.v2f64(<2 x double> %a)
ret { <2 x double>, <2 x double> } %result
}
-
-; CHECK-LABEL: test_sincos_f128:
-; CHECK: bl sinl
-; CHECK: bl cosl
-define { fp128, fp128 } @test_sincos_f128(fp128 %a) nounwind {
- %result = call { fp128, fp128 } @llvm.sincos.f128(fp128 %a)
- ret { fp128, fp128 } %result
-}
-
-; CHECK-LABEL: test_sincos_v2f128:
-; CHECK: bl sinl
-; CHECK: bl cosl
-; CHECK: bl cosl
-; CHECK: bl sinl
-define { <2 x fp128>, <2 x fp128> } @test_sincos_v2f128(<2 x fp128> %a) nounwind {
- %result = call { <2 x fp128>, <2 x fp128> } @llvm.sincos.v2f128(<2 x fp128> %a)
- ret { <2 x fp128>, <2 x fp128> } %result
-}
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td b/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
index c4bf02c08dd2d..cd1f59067c7ba 100644
--- a/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
@@ -46,7 +46,7 @@ def MSP430LibraryWithCondCC : SystemRuntimeLibrary<isMSP430,
>;
-// CHECK: void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const llvm::Triple &TT, ExceptionHandling ExceptionModel, FloatABI::ABIType FloatABI, EABI EABIVersion, StringRef ABIName) {
+// CHECK: void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const llvm::Triple &TT, ExceptionHandling ExceptionModel, FloatABI::ABIType FloatABI, EABI EABIVersion, StringRef ABIName, LongDoubleFormat LongDoubleFormat) {
// CHECK: if (TT.getArch() == Triple::avr && TT.isOSHurd()) {
// CHECK-NEXT: const CallingConv::ID DefaultCC = isFoo() ? CallingConv::Fast : CallingConv::GHC;
// CHECK-NEXT: for (CallingConv::ID &Entry : LibcallImplCallingConvs) {
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter.td b/llvm/test/TableGen/RuntimeLibcallEmitter.td
index d34c24a241bd6..51c3e02885f4b 100644
--- a/llvm/test/TableGen/RuntimeLibcallEmitter.td
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter.td
@@ -210,7 +210,7 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add calloc, LibraryWithCondi
// CHECK: return enum_seq(RTLIB::Unsupported, RTLIB::Unsupported);
// CHECK-NEXT: }
-// CHECK: void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const llvm::Triple &TT, ExceptionHandling ExceptionModel, FloatABI::ABIType FloatABI, EABI EABIVersion, StringRef ABIName) {
+// CHECK: void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const llvm::Triple &TT, ExceptionHandling ExceptionModel, FloatABI::ABIType FloatABI, EABI EABIVersion, StringRef ABIName, LongDoubleFormat LongDoubleFormat) {
// CHECK-EMPTY:
// CHECK-NEXT: if (TT.getArch() == Triple::blah) {
// CHECK-NEXT: static constexpr LibcallImplBitset SystemAvailableImpls({
diff --git a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
index f4d83e472bdc3..7a76c1740b53b 100644
--- a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
@@ -376,7 +376,7 @@ void RuntimeLibcallEmitter::emitSystemRuntimeLibrarySetCalls(
OS << "void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets("
"const llvm::Triple &TT, ExceptionHandling ExceptionModel, "
"FloatABI::ABIType FloatABI, EABI EABIVersion, "
- "StringRef ABIName) {\n";
+ "StringRef ABIName, LongDoubleFormat LongDoubleFormat) {\n";
ArrayRef<const Record *> AllLibs =
Records.getAllDerivedDefinitions("SystemRuntimeLibrary");
>From 10d6b3028f31a132fad440a41283199907991fe1 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Fri, 14 Aug 2026 18:46:50 +0200
Subject: [PATCH 2/4] Reword comment
Co-authored-by: Paul Kirth <paulkirth at google.com>
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 16cd8c538a91a..8856889607556 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -2002,8 +2002,7 @@ defvar DefaultRuntimeLibcallImpls_longdouble_f128 =
// FIXME: Ideally we would just use dags everywhere, but for the
// arm64ec case we need iterable lists so we can add the # prefix
//
-// The fp128 long double libcalls are removed here and re-added per-target
-// gated on the long double format.
+// The fp128 long double libcalls are added on a per-target basis.
defvar DefaultRuntimeLibcallImplsBaseList =
!listremove(
!listremove(
>From cec142aaac79f794c8de7adfeb2db0072a5c2688 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Fri, 14 Aug 2026 18:47:04 +0200
Subject: [PATCH 3/4] reword another comment
Co-authored-by: Paul Kirth <paulkirth at google.com>
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 8856889607556..248e4bc76db0e 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -2196,7 +2196,7 @@ def isWindowsArm64EC : RuntimeLibcallAvailability<(all_of IsWindowsArm64EC)>;
def isAArch64_ILP64
: RuntimeLibcallAvailability<(all_of IsAArch64_ILP64)>;
-// frexpl/ldexpl/exp10l are added separately with their own OS guards.
+// frexpl/ldexpl/exp10l are added separately based on the Target Triple.
defvar AArch64LongDoubleF128Body =
!listremove(DefaultRuntimeLibcallImpls_longdouble_f128,
[frexpl_f128, ldexpl_f128, exp10l_f128]);
>From 8ce626e2b1d59704189dc22534773d7a72f04940 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Fri, 14 Aug 2026 18:47:50 +0200
Subject: [PATCH 4/4] Remove fixme
Co-authored-by: Matt Arsenault <arsenm2 at gmail.com>
---
llvm/test/CodeGen/X86/lrint-conv-i32.ll | 1 -
1 file changed, 1 deletion(-)
diff --git a/llvm/test/CodeGen/X86/lrint-conv-i32.ll b/llvm/test/CodeGen/X86/lrint-conv-i32.ll
index b74e0bd4dcd93..f48e4cbb47539 100644
--- a/llvm/test/CodeGen/X86/lrint-conv-i32.ll
+++ b/llvm/test/CodeGen/X86/lrint-conv-i32.ll
@@ -139,7 +139,6 @@ define i32 @test_lrint_i32_f80(x86_fp80 %x) nounwind {
ret i32 %conv
}
-; FIXME(#44744): incorrect libcall
define i32 @test_lrint_i32_f16_strict(half %x) nounwind strictfp {
; X86-NOSSE-LABEL: test_lrint_i32_f16_strict:
; X86-NOSSE: # %bb.0:
More information about the llvm-commits
mailing list