This is an archive of the discontinued LLVM Phabricator instance.

Differential D44592

[X86] Properly implement the calling convention for f80 for win64
ClosedPublic

Authored by mstorsjo on Mar 16 2018, 4:08 PM.

Details

Reviewers
rnk
compnerd
efriedma
craig.topper
RKSimon
Commits
rG802b43415650: [X86] Properly implement the calling convention for f80 for mingw/x86_64
rL327957: [X86] Properly implement the calling convention for f80 for mingw/x86_64
Summary

In these cases, both parameters and return values are passed as a pointer to a stack allocation.

MSVC doesn't use the f80 data type at all, while it is used for long doubles on mingw.

The CCIfNotSubtarget part feels rather unclean, is there any other way to match this earlier and have it stop matching, to trigger the same behaviour as if there was no match?

This is an alternative to D44582, fixing the same issue.

Diff Detail

Repository
rL LLVM

Event Timeline

mstorsjo created this revision.Mar 16 2018, 4:08 PM
mstorsjo mentioned this in D44582: [Builtins] Fix calling long double math functions on x86_64 mingw.
mstorsjo added a reviewer: craig.topper.Mar 17 2018, 4:59 AM
mstorsjo updated this revision to Diff 138897.Mar 19 2018, 4:51 AM

Added a separate standalone testcase that shows the intended behaviour.

mstorsjo edited the summary of this revision. (Show Details)Mar 19 2018, 4:52 AM
mstorsjo added a reviewer: RKSimon.
rnk accepted this revision.Mar 19 2018, 5:21 PM

lgtm

This revision is now accepted and ready to land.Mar 19 2018, 5:21 PM
Closed by commit rL327957: [X86] Properly implement the calling convention for f80 for mingw/x86_64 (authored by mstorsjo). · Explain WhyMar 19 2018, 11:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
Target/
X86/
20 lines
test/
CodeGen/
X86/
85 lines
26 lines
22 lines

Diff 139077

llvm/trunk/lib/Target/X86/X86CallingConv.td

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// CCIfSubtarget - Match if the current subtarget has a feature F. /// CCIfSubtarget - Match if the current subtarget has a feature F.
class CCIfSubtarget<string F, CCAction A> class CCIfSubtarget<string F, CCAction A>
: CCIf<!strconcat("static_cast<const X86Subtarget&>" : CCIf<!strconcat("static_cast<const X86Subtarget&>"
"(State.getMachineFunction().getSubtarget()).", F), "(State.getMachineFunction().getSubtarget()).", F),
A>; A>;
/// CCIfNotSubtarget - Match if the current subtarget doesn't has a feature F.
class CCIfNotSubtarget<string F, CCAction A>
: CCIf<!strconcat("!static_cast<const X86Subtarget&>"
"(State.getMachineFunction().getSubtarget()).", F),
A>;
// Register classes for RegCall // Register classes for RegCall
class RC_X86_RegCall { class RC_X86_RegCall {
list<Register> GPR_8 = []; list<Register> GPR_8 = [];
list<Register> GPR_16 = []; list<Register> GPR_16 = [];
list<Register> GPR_32 = []; list<Register> GPR_32 = [];
list<Register> GPR_64 = []; list<Register> GPR_64 = [];
list<Register> FP_CALL = [FP0]; list<Register> FP_CALL = [FP0];
list<Register> FP_RET = [FP0, FP1]; list<Register> FP_RET = [FP0, FP1];
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Linesdef RetCC_X86Common : CallingConv<[
// supported while using the AVX-512 target feature. // supported while using the AVX-512 target feature.
CCIfType<[v64i8, v32i16, v16i32, v8i64, v16f32, v8f64], CCIfType<[v64i8, v32i16, v16i32, v8i64, v16f32, v8f64],
CCAssignToReg<[ZMM0,ZMM1,ZMM2,ZMM3]>>, CCAssignToReg<[ZMM0,ZMM1,ZMM2,ZMM3]>>,
// MMX vector types are always returned in MM0. If the target doesn't have // MMX vector types are always returned in MM0. If the target doesn't have
// MM0, it doesn't support these vector types. // MM0, it doesn't support these vector types.
CCIfType<[x86mmx], CCAssignToReg<[MM0]>>, CCIfType<[x86mmx], CCAssignToReg<[MM0]>>,
// Long double types are always returned in FP0 (even with SSE). // Long double types are always returned in FP0 (even with SSE),
CCIfType<[f80], CCAssignToReg<[FP0, FP1]>> // except on Win64.
CCIfNotSubtarget<"isTargetWin64()", CCIfType<[f80], CCAssignToReg<[FP0, FP1]>>>
]>; ]>;
// X86-32 C return-value convention. // X86-32 C return-value convention.
def RetCC_X86_32_C : CallingConv<[ def RetCC_X86_32_C : CallingConv<[
// The X86-32 calling convention returns FP values in FP0, unless marked // The X86-32 calling convention returns FP values in FP0, unless marked
// with "inreg" (used here to distinguish one kind of reg from another, // with "inreg" (used here to distinguish one kind of reg from another,
// weirdly; this is really the sse-regparm calling convention) in which // weirdly; this is really the sse-regparm calling convention) in which
// case they use XMM0, otherwise it is the same as the common X86 calling // case they use XMM0, otherwise it is the same as the common X86 calling
▲ Show 20 Lines • Show All 341 Lines • ▼ Show 20 Linesdef CC_X86_Win64_C : CallingConv<[
// 256 bit vectors are passed by pointer // 256 bit vectors are passed by pointer
CCIfType<[v32i8, v16i16, v8i32, v4i64, v8f32, v4f64], CCPassIndirect<i64>>, CCIfType<[v32i8, v16i16, v8i32, v4i64, v8f32, v4f64], CCPassIndirect<i64>>,
// 512 bit vectors are passed by pointer // 512 bit vectors are passed by pointer
CCIfType<[v16i32, v16f32, v8f64, v8i64], CCPassIndirect<i64>>, CCIfType<[v16i32, v16f32, v8f64, v8i64], CCPassIndirect<i64>>,
// Long doubles are passed by pointer
CCIfType<[f80], CCPassIndirect<i64>>,
// The first 4 MMX vector arguments are passed in GPRs. // The first 4 MMX vector arguments are passed in GPRs.
CCIfType<[x86mmx], CCBitConvertToType<i64>>, CCIfType<[x86mmx], CCBitConvertToType<i64>>,
// The first 4 integer arguments are passed in integer registers. // The first 4 integer arguments are passed in integer registers.
CCIfType<[i32], CCAssignToRegWithShadow<[ECX , EDX , R8D , R9D ], CCIfType<[i32], CCAssignToRegWithShadow<[ECX , EDX , R8D , R9D ],
[XMM0, XMM1, XMM2, XMM3]>>, [XMM0, XMM1, XMM2, XMM3]>>,
// Do not pass the sret argument in RCX, the Win64 thiscall calling // Do not pass the sret argument in RCX, the Win64 thiscall calling
// convention requires "this" to be passed in RCX. // convention requires "this" to be passed in RCX.
CCIfCC<"CallingConv::X86_ThisCall", CCIfCC<"CallingConv::X86_ThisCall",
CCIfSRet<CCIfType<[i64], CCAssignToRegWithShadow<[RDX , R8 , R9 ], CCIfSRet<CCIfType<[i64], CCAssignToRegWithShadow<[RDX , R8 , R9 ],
[XMM1, XMM2, XMM3]>>>>, [XMM1, XMM2, XMM3]>>>>,
CCIfType<[i64], CCAssignToRegWithShadow<[RCX , RDX , R8 , R9 ], CCIfType<[i64], CCAssignToRegWithShadow<[RCX , RDX , R8 , R9 ],
[XMM0, XMM1, XMM2, XMM3]>>, [XMM0, XMM1, XMM2, XMM3]>>,
// The first 4 FP/Vector arguments are passed in XMM registers. // The first 4 FP/Vector arguments are passed in XMM registers.
CCIfType<[f32, f64, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], CCIfType<[f32, f64, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
CCAssignToRegWithShadow<[XMM0, XMM1, XMM2, XMM3], CCAssignToRegWithShadow<[XMM0, XMM1, XMM2, XMM3],
[RCX , RDX , R8 , R9 ]>>, [RCX , RDX , R8 , R9 ]>>,
// Integer/FP values get stored in stack slots that are 8 bytes in size and // Integer/FP values get stored in stack slots that are 8 bytes in size and
// 8-byte aligned if there are no more registers to hold them. // 8-byte aligned if there are no more registers to hold them.
CCIfType<[i32, i64, f32, f64], CCAssignToStack<8, 8>>, CCIfType<[i32, i64, f32, f64], CCAssignToStack<8, 8>>
// Long doubles get stack slots whose size and alignment depends on the
// subtarget.
CCIfType<[f80], CCAssignToStack<0, 0>>
]>; ]>;
def CC_X86_Win64_VectorCall : CallingConv<[ def CC_X86_Win64_VectorCall : CallingConv<[
CCCustom<"CC_X86_64_VectorCall">, CCCustom<"CC_X86_64_VectorCall">,
// Delegate to fastcall to handle integer types. // Delegate to fastcall to handle integer types.
CCDelegateTo<CC_X86_Win64_C> CCDelegateTo<CC_X86_Win64_C>
]>; ]>;
▲ Show 20 Lines • Show All 495 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/finite-libcalls.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
; GNU-NEXT: fldt {{[0-9]+}}(%rsp) ; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
; GNU-NEXT: fstpt (%rsp) ; GNU-NEXT: fstpt (%rsp)
; GNU-NEXT: callq __expl_finite ; GNU-NEXT: callq __expl_finite
; GNU-NEXT: addq $24, %rsp ; GNU-NEXT: addq $24, %rsp
; GNU-NEXT: retq ; GNU-NEXT: retq
; ;
; WIN-LABEL: exp_f80: ; WIN-LABEL: exp_f80:
; WIN: # %bb.0: ; WIN: # %bb.0:
; WIN-NEXT: subq $56, %rsp ; WIN-NEXT: pushq %rsi
; WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; WIN-NEXT: subq $64, %rsp
; WIN-NEXT: movq %rcx, %rsi
; WIN-NEXT: fldt (%rdx)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: callq expl ; WIN-NEXT: callq expl
; WIN-NEXT: addq $56, %rsp ; WIN-NEXT: fldt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt (%rsi)
; WIN-NEXT: movq %rsi, %rax
; WIN-NEXT: addq $64, %rsp
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq ; WIN-NEXT: retq
; ;
; MAC-LABEL: exp_f80: ; MAC-LABEL: exp_f80:
; MAC: ## %bb.0: ; MAC: ## %bb.0:
; MAC-NEXT: subq $24, %rsp ; MAC-NEXT: subq $24, %rsp
; MAC-NEXT: fldt {{[0-9]+}}(%rsp) ; MAC-NEXT: fldt {{[0-9]+}}(%rsp)
; MAC-NEXT: fstpt (%rsp) ; MAC-NEXT: fstpt (%rsp)
; MAC-NEXT: callq _expl ; MAC-NEXT: callq _expl
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; GNU-NEXT: fldt {{[0-9]+}}(%rsp) ; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
; GNU-NEXT: fstpt (%rsp) ; GNU-NEXT: fstpt (%rsp)
; GNU-NEXT: callq __exp2l_finite ; GNU-NEXT: callq __exp2l_finite
; GNU-NEXT: addq $24, %rsp ; GNU-NEXT: addq $24, %rsp
; GNU-NEXT: retq ; GNU-NEXT: retq
; ;
; WIN-LABEL: exp2_f80: ; WIN-LABEL: exp2_f80:
; WIN: # %bb.0: ; WIN: # %bb.0:
; WIN-NEXT: subq $56, %rsp ; WIN-NEXT: pushq %rsi
; WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; WIN-NEXT: subq $64, %rsp
; WIN-NEXT: movq %rcx, %rsi
; WIN-NEXT: fldt (%rdx)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: callq exp2l ; WIN-NEXT: callq exp2l
; WIN-NEXT: addq $56, %rsp ; WIN-NEXT: fldt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt (%rsi)
; WIN-NEXT: movq %rsi, %rax
; WIN-NEXT: addq $64, %rsp
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq ; WIN-NEXT: retq
; ;
; MAC-LABEL: exp2_f80: ; MAC-LABEL: exp2_f80:
; MAC: ## %bb.0: ; MAC: ## %bb.0:
; MAC-NEXT: subq $24, %rsp ; MAC-NEXT: subq $24, %rsp
; MAC-NEXT: fldt {{[0-9]+}}(%rsp) ; MAC-NEXT: fldt {{[0-9]+}}(%rsp)
; MAC-NEXT: fstpt (%rsp) ; MAC-NEXT: fstpt (%rsp)
; MAC-NEXT: callq _exp2l ; MAC-NEXT: callq _exp2l
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; GNU-NEXT: fldt {{[0-9]+}}(%rsp) ; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
; GNU-NEXT: fstpt (%rsp) ; GNU-NEXT: fstpt (%rsp)
; GNU-NEXT: callq __logl_finite ; GNU-NEXT: callq __logl_finite
; GNU-NEXT: addq $24, %rsp ; GNU-NEXT: addq $24, %rsp
; GNU-NEXT: retq ; GNU-NEXT: retq
; ;
; WIN-LABEL: log_f80: ; WIN-LABEL: log_f80:
; WIN: # %bb.0: ; WIN: # %bb.0:
; WIN-NEXT: subq $56, %rsp ; WIN-NEXT: pushq %rsi
; WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; WIN-NEXT: subq $64, %rsp
; WIN-NEXT: movq %rcx, %rsi
; WIN-NEXT: fldt (%rdx)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: callq logl ; WIN-NEXT: callq logl
; WIN-NEXT: addq $56, %rsp ; WIN-NEXT: fldt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt (%rsi)
; WIN-NEXT: movq %rsi, %rax
; WIN-NEXT: addq $64, %rsp
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq ; WIN-NEXT: retq
; ;
; MAC-LABEL: log_f80: ; MAC-LABEL: log_f80:
; MAC: ## %bb.0: ; MAC: ## %bb.0:
; MAC-NEXT: subq $24, %rsp ; MAC-NEXT: subq $24, %rsp
; MAC-NEXT: fldt {{[0-9]+}}(%rsp) ; MAC-NEXT: fldt {{[0-9]+}}(%rsp)
; MAC-NEXT: fstpt (%rsp) ; MAC-NEXT: fstpt (%rsp)
; MAC-NEXT: callq _logl ; MAC-NEXT: callq _logl
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; GNU-NEXT: fldt {{[0-9]+}}(%rsp) ; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
; GNU-NEXT: fstpt (%rsp) ; GNU-NEXT: fstpt (%rsp)
; GNU-NEXT: callq __log2l_finite ; GNU-NEXT: callq __log2l_finite
; GNU-NEXT: addq $24, %rsp ; GNU-NEXT: addq $24, %rsp
; GNU-NEXT: retq ; GNU-NEXT: retq
; ;
; WIN-LABEL: log2_f80: ; WIN-LABEL: log2_f80:
; WIN: # %bb.0: ; WIN: # %bb.0:
; WIN-NEXT: subq $56, %rsp ; WIN-NEXT: pushq %rsi
; WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; WIN-NEXT: subq $64, %rsp
; WIN-NEXT: movq %rcx, %rsi
; WIN-NEXT: fldt (%rdx)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: callq log2l ; WIN-NEXT: callq log2l
; WIN-NEXT: addq $56, %rsp ; WIN-NEXT: fldt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt (%rsi)
; WIN-NEXT: movq %rsi, %rax
; WIN-NEXT: addq $64, %rsp
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq ; WIN-NEXT: retq
; ;
; MAC-LABEL: log2_f80: ; MAC-LABEL: log2_f80:
; MAC: ## %bb.0: ; MAC: ## %bb.0:
; MAC-NEXT: subq $24, %rsp ; MAC-NEXT: subq $24, %rsp
; MAC-NEXT: fldt {{[0-9]+}}(%rsp) ; MAC-NEXT: fldt {{[0-9]+}}(%rsp)
; MAC-NEXT: fstpt (%rsp) ; MAC-NEXT: fstpt (%rsp)
; MAC-NEXT: callq _log2l ; MAC-NEXT: callq _log2l
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; GNU-NEXT: fldt {{[0-9]+}}(%rsp) ; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
; GNU-NEXT: fstpt (%rsp) ; GNU-NEXT: fstpt (%rsp)
; GNU-NEXT: callq __log10l_finite ; GNU-NEXT: callq __log10l_finite
; GNU-NEXT: addq $24, %rsp ; GNU-NEXT: addq $24, %rsp
; GNU-NEXT: retq ; GNU-NEXT: retq
; ;
; WIN-LABEL: log10_f80: ; WIN-LABEL: log10_f80:
; WIN: # %bb.0: ; WIN: # %bb.0:
; WIN-NEXT: subq $56, %rsp ; WIN-NEXT: pushq %rsi
; WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; WIN-NEXT: subq $64, %rsp
; WIN-NEXT: movq %rcx, %rsi
; WIN-NEXT: fldt (%rdx)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[0-9]+}}(%rsp)
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rcx
; WIN-NEXT: leaq {{[0-9]+}}(%rsp), %rdx
; WIN-NEXT: callq log10l ; WIN-NEXT: callq log10l
; WIN-NEXT: addq $56, %rsp ; WIN-NEXT: fldt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt (%rsi)
; WIN-NEXT: movq %rsi, %rax
; WIN-NEXT: addq $64, %rsp
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq ; WIN-NEXT: retq
; ;
; MAC-LABEL: log10_f80: ; MAC-LABEL: log10_f80:
; MAC: ## %bb.0: ; MAC: ## %bb.0:
; MAC-NEXT: subq $24, %rsp ; MAC-NEXT: subq $24, %rsp
; MAC-NEXT: fldt {{[0-9]+}}(%rsp) ; MAC-NEXT: fldt {{[0-9]+}}(%rsp)
; MAC-NEXT: fstpt (%rsp) ; MAC-NEXT: fstpt (%rsp)
; MAC-NEXT: callq _log10l ; MAC-NEXT: callq _log10l
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; GNU-NEXT: fstpt {{[0-9]+}}(%rsp) ; GNU-NEXT: fstpt {{[0-9]+}}(%rsp)
; GNU-NEXT: fstpt (%rsp) ; GNU-NEXT: fstpt (%rsp)
; GNU-NEXT: callq __powl_finite ; GNU-NEXT: callq __powl_finite
; GNU-NEXT: addq $40, %rsp ; GNU-NEXT: addq $40, %rsp
; GNU-NEXT: retq ; GNU-NEXT: retq
; ;
; WIN-LABEL: pow_f80: ; WIN-LABEL: pow_f80:
; WIN: # %bb.0: ; WIN: # %bb.0:
; WIN-NEXT: subq $72, %rsp ; WIN-NEXT: pushq %rsi
; WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; WIN-NEXT: subq $80, %rsp
; WIN-NEXT: movq %rcx, %rsi
; WIN-NEXT: fldt (%rdx)
; WIN-NEXT: fld %st(0) ; WIN-NEXT: fld %st(0)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt {{[0-9]+}}(%rsp) ; WIN-NEXT: fstpt {{[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: callq powl
; WIN-NEXT: addq $72, %rsp ; WIN-NEXT: fldt {{[0-9]+}}(%rsp)
; WIN-NEXT: fstpt (%rsi)
; WIN-NEXT: movq %rsi, %rax
; WIN-NEXT: addq $80, %rsp
; WIN-NEXT: popq %rsi
; WIN-NEXT: retq ; WIN-NEXT: retq
; ;
; MAC-LABEL: pow_f80: ; MAC-LABEL: pow_f80:
; MAC: ## %bb.0: ; MAC: ## %bb.0:
; MAC-NEXT: subq $40, %rsp ; MAC-NEXT: subq $40, %rsp
; MAC-NEXT: fldt {{[0-9]+}}(%rsp) ; MAC-NEXT: fldt {{[0-9]+}}(%rsp)
; MAC-NEXT: fld %st(0) ; MAC-NEXT: fld %st(0)
; MAC-NEXT: fstpt {{[0-9]+}}(%rsp) ; MAC-NEXT: fstpt {{[0-9]+}}(%rsp)
Show All 35 Lines

llvm/trunk/test/CodeGen/X86/scalar-fp-to-i64.ll

Show First 20 Lines • Show All 912 Lines • ▼ Show 20 Lines
; AVX512_32_LIN-NEXT: xorl {{[0-9]+}}(%esp), %edx ; AVX512_32_LIN-NEXT: xorl {{[0-9]+}}(%esp), %edx
; AVX512_32_LIN-NEXT: movl (%esp), %eax ; AVX512_32_LIN-NEXT: movl (%esp), %eax
; AVX512_32_LIN-NEXT: addl $12, %esp ; AVX512_32_LIN-NEXT: addl $12, %esp
; AVX512_32_LIN-NEXT: retl ; AVX512_32_LIN-NEXT: retl
; ;
; AVX512_64_WIN-LABEL: x_to_u64: ; AVX512_64_WIN-LABEL: x_to_u64:
; AVX512_64_WIN: # %bb.0: ; AVX512_64_WIN: # %bb.0:
; AVX512_64_WIN-NEXT: pushq %rax ; AVX512_64_WIN-NEXT: pushq %rax
; AVX512_64_WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; AVX512_64_WIN-NEXT: fldt (%rcx)
; AVX512_64_WIN-NEXT: flds __real@{{.*}}(%rip) ; AVX512_64_WIN-NEXT: flds __real@{{.*}}(%rip)
; AVX512_64_WIN-NEXT: fld %st(1) ; AVX512_64_WIN-NEXT: fld %st(1)
; AVX512_64_WIN-NEXT: fsub %st(1) ; AVX512_64_WIN-NEXT: fsub %st(1)
; AVX512_64_WIN-NEXT: xorl %ecx, %ecx ; AVX512_64_WIN-NEXT: xorl %ecx, %ecx
; AVX512_64_WIN-NEXT: fxch %st(1) ; AVX512_64_WIN-NEXT: fxch %st(1)
; AVX512_64_WIN-NEXT: fucompi %st(2) ; AVX512_64_WIN-NEXT: fucompi %st(2)
; AVX512_64_WIN-NEXT: fcmovnbe %st(1), %st(0) ; AVX512_64_WIN-NEXT: fcmovnbe %st(1), %st(0)
; AVX512_64_WIN-NEXT: fstp %st(1) ; AVX512_64_WIN-NEXT: fstp %st(1)
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
; SSE3_32_LIN-NEXT: shll $31, %edx ; SSE3_32_LIN-NEXT: shll $31, %edx
; SSE3_32_LIN-NEXT: xorl {{[0-9]+}}(%esp), %edx ; SSE3_32_LIN-NEXT: xorl {{[0-9]+}}(%esp), %edx
; SSE3_32_LIN-NEXT: movl (%esp), %eax ; SSE3_32_LIN-NEXT: movl (%esp), %eax
; SSE3_32_LIN-NEXT: addl $12, %esp ; SSE3_32_LIN-NEXT: addl $12, %esp
; SSE3_32_LIN-NEXT: retl ; SSE3_32_LIN-NEXT: retl
; ;
; SSE3_64_WIN-LABEL: x_to_u64: ; SSE3_64_WIN-LABEL: x_to_u64:
; SSE3_64_WIN: # %bb.0: ; SSE3_64_WIN: # %bb.0:
; SSE3_64_WIN-NEXT: subq $24, %rsp ; SSE3_64_WIN-NEXT: subq $16, %rsp
; SSE3_64_WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE3_64_WIN-NEXT: fldt (%rcx)
; SSE3_64_WIN-NEXT: flds __real@{{.*}}(%rip) ; SSE3_64_WIN-NEXT: flds __real@{{.*}}(%rip)
; SSE3_64_WIN-NEXT: fld %st(1) ; SSE3_64_WIN-NEXT: fld %st(1)
; SSE3_64_WIN-NEXT: fsub %st(1) ; SSE3_64_WIN-NEXT: fsub %st(1)
; SSE3_64_WIN-NEXT: fisttpll {{[0-9]+}}(%rsp) ; SSE3_64_WIN-NEXT: fisttpll {{[0-9]+}}(%rsp)
; SSE3_64_WIN-NEXT: fld %st(1) ; SSE3_64_WIN-NEXT: fld %st(1)
; SSE3_64_WIN-NEXT: fisttpll {{[0-9]+}}(%rsp) ; SSE3_64_WIN-NEXT: fisttpll (%rsp)
; SSE3_64_WIN-NEXT: fucompi %st(1) ; SSE3_64_WIN-NEXT: fucompi %st(1)
; SSE3_64_WIN-NEXT: fstp %st(0) ; SSE3_64_WIN-NEXT: fstp %st(0)
; SSE3_64_WIN-NEXT: jbe .LBB4_1 ; SSE3_64_WIN-NEXT: jbe .LBB4_1
; SSE3_64_WIN-NEXT: # %bb.2: ; SSE3_64_WIN-NEXT: # %bb.2:
; SSE3_64_WIN-NEXT: movq {{[0-9]+}}(%rsp), %rax ; SSE3_64_WIN-NEXT: movq (%rsp), %rax
; SSE3_64_WIN-NEXT: addq $24, %rsp ; SSE3_64_WIN-NEXT: addq $16, %rsp
; SSE3_64_WIN-NEXT: retq ; SSE3_64_WIN-NEXT: retq
; SSE3_64_WIN-NEXT: .LBB4_1: ; SSE3_64_WIN-NEXT: .LBB4_1:
; SSE3_64_WIN-NEXT: movabsq $-9223372036854775808, %rax # imm = 0x8000000000000000 ; SSE3_64_WIN-NEXT: movabsq $-9223372036854775808, %rax # imm = 0x8000000000000000
; SSE3_64_WIN-NEXT: xorq {{[0-9]+}}(%rsp), %rax ; SSE3_64_WIN-NEXT: xorq {{[0-9]+}}(%rsp), %rax
; SSE3_64_WIN-NEXT: addq $24, %rsp ; SSE3_64_WIN-NEXT: addq $16, %rsp
; SSE3_64_WIN-NEXT: retq ; SSE3_64_WIN-NEXT: retq
; ;
; SSE3_64_LIN-LABEL: x_to_u64: ; SSE3_64_LIN-LABEL: x_to_u64:
; SSE3_64_LIN: # %bb.0: ; SSE3_64_LIN: # %bb.0:
; SSE3_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE3_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp)
; SSE3_64_LIN-NEXT: flds {{.*}}(%rip) ; SSE3_64_LIN-NEXT: flds {{.*}}(%rip)
; SSE3_64_LIN-NEXT: fld %st(1) ; SSE3_64_LIN-NEXT: fld %st(1)
; SSE3_64_LIN-NEXT: fsub %st(1) ; SSE3_64_LIN-NEXT: fsub %st(1)
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
; SSE2_32_LIN-NEXT: xorl {{[0-9]+}}(%esp), %edx ; SSE2_32_LIN-NEXT: xorl {{[0-9]+}}(%esp), %edx
; SSE2_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %eax ; SSE2_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %eax
; SSE2_32_LIN-NEXT: addl $20, %esp ; SSE2_32_LIN-NEXT: addl $20, %esp
; SSE2_32_LIN-NEXT: retl ; SSE2_32_LIN-NEXT: retl
; ;
; SSE2_64_WIN-LABEL: x_to_u64: ; SSE2_64_WIN-LABEL: x_to_u64:
; SSE2_64_WIN: # %bb.0: ; SSE2_64_WIN: # %bb.0:
; SSE2_64_WIN-NEXT: subq $24, %rsp ; SSE2_64_WIN-NEXT: subq $24, %rsp
; SSE2_64_WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fldt (%rcx)
; SSE2_64_WIN-NEXT: flds __real@{{.*}}(%rip) ; SSE2_64_WIN-NEXT: flds __real@{{.*}}(%rip)
; SSE2_64_WIN-NEXT: fld %st(1) ; SSE2_64_WIN-NEXT: fld %st(1)
; SSE2_64_WIN-NEXT: fsub %st(1) ; SSE2_64_WIN-NEXT: fsub %st(1)
; SSE2_64_WIN-NEXT: fnstcw {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fnstcw {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: movzwl {{[0-9]+}}(%rsp), %eax ; SSE2_64_WIN-NEXT: movzwl {{[0-9]+}}(%rsp), %eax
; SSE2_64_WIN-NEXT: movw $3199, {{[0-9]+}}(%rsp) # imm = 0xC7F ; SSE2_64_WIN-NEXT: movw $3199, {{[0-9]+}}(%rsp) # imm = 0xC7F
; SSE2_64_WIN-NEXT: fldcw {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fldcw {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: movw %ax, {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: movw %ax, {{[0-9]+}}(%rsp)
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Lines
; AVX512_32_LIN-NEXT: movl (%esp), %eax ; AVX512_32_LIN-NEXT: movl (%esp), %eax
; AVX512_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %edx ; AVX512_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %edx
; AVX512_32_LIN-NEXT: addl $12, %esp ; AVX512_32_LIN-NEXT: addl $12, %esp
; AVX512_32_LIN-NEXT: retl ; AVX512_32_LIN-NEXT: retl
; ;
; AVX512_64_WIN-LABEL: x_to_s64: ; AVX512_64_WIN-LABEL: x_to_s64:
; AVX512_64_WIN: # %bb.0: ; AVX512_64_WIN: # %bb.0:
; AVX512_64_WIN-NEXT: pushq %rax ; AVX512_64_WIN-NEXT: pushq %rax
; AVX512_64_WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; AVX512_64_WIN-NEXT: fldt (%rcx)
; AVX512_64_WIN-NEXT: fisttpll (%rsp) ; AVX512_64_WIN-NEXT: fisttpll (%rsp)
; AVX512_64_WIN-NEXT: movq (%rsp), %rax ; AVX512_64_WIN-NEXT: movq (%rsp), %rax
; AVX512_64_WIN-NEXT: popq %rcx ; AVX512_64_WIN-NEXT: popq %rcx
; AVX512_64_WIN-NEXT: retq ; AVX512_64_WIN-NEXT: retq
; ;
; AVX512_64_LIN-LABEL: x_to_s64: ; AVX512_64_LIN-LABEL: x_to_s64:
; AVX512_64_LIN: # %bb.0: ; AVX512_64_LIN: # %bb.0:
; AVX512_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp) ; AVX512_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp)
Show All 23 Lines
; SSE3_32_LIN-NEXT: movl (%esp), %eax ; SSE3_32_LIN-NEXT: movl (%esp), %eax
; SSE3_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %edx ; SSE3_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %edx
; SSE3_32_LIN-NEXT: addl $12, %esp ; SSE3_32_LIN-NEXT: addl $12, %esp
; SSE3_32_LIN-NEXT: retl ; SSE3_32_LIN-NEXT: retl
; ;
; SSE3_64_WIN-LABEL: x_to_s64: ; SSE3_64_WIN-LABEL: x_to_s64:
; SSE3_64_WIN: # %bb.0: ; SSE3_64_WIN: # %bb.0:
; SSE3_64_WIN-NEXT: pushq %rax ; SSE3_64_WIN-NEXT: pushq %rax
; SSE3_64_WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE3_64_WIN-NEXT: fldt (%rcx)
; SSE3_64_WIN-NEXT: fisttpll (%rsp) ; SSE3_64_WIN-NEXT: fisttpll (%rsp)
; SSE3_64_WIN-NEXT: movq (%rsp), %rax ; SSE3_64_WIN-NEXT: movq (%rsp), %rax
; SSE3_64_WIN-NEXT: popq %rcx ; SSE3_64_WIN-NEXT: popq %rcx
; SSE3_64_WIN-NEXT: retq ; SSE3_64_WIN-NEXT: retq
; ;
; SSE3_64_LIN-LABEL: x_to_s64: ; SSE3_64_LIN-LABEL: x_to_s64:
; SSE3_64_LIN: # %bb.0: ; SSE3_64_LIN: # %bb.0:
; SSE3_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE3_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp)
Show All 34 Lines
; SSE2_32_LIN-NEXT: fldcw {{[0-9]+}}(%esp) ; SSE2_32_LIN-NEXT: fldcw {{[0-9]+}}(%esp)
; SSE2_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %eax ; SSE2_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %eax
; SSE2_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %edx ; SSE2_32_LIN-NEXT: movl {{[0-9]+}}(%esp), %edx
; SSE2_32_LIN-NEXT: addl $20, %esp ; SSE2_32_LIN-NEXT: addl $20, %esp
; SSE2_32_LIN-NEXT: retl ; SSE2_32_LIN-NEXT: retl
; ;
; SSE2_64_WIN-LABEL: x_to_s64: ; SSE2_64_WIN-LABEL: x_to_s64:
; SSE2_64_WIN: # %bb.0: ; SSE2_64_WIN: # %bb.0:
; SSE2_64_WIN-NEXT: subq $24, %rsp ; SSE2_64_WIN-NEXT: subq $16, %rsp
; SSE2_64_WIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fldt (%rcx)
; SSE2_64_WIN-NEXT: fnstcw {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fnstcw {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: movzwl {{[0-9]+}}(%rsp), %eax ; SSE2_64_WIN-NEXT: movzwl {{[0-9]+}}(%rsp), %eax
; SSE2_64_WIN-NEXT: movw $3199, {{[0-9]+}}(%rsp) # imm = 0xC7F ; SSE2_64_WIN-NEXT: movw $3199, {{[0-9]+}}(%rsp) # imm = 0xC7F
; SSE2_64_WIN-NEXT: fldcw {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fldcw {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: movw %ax, {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: movw %ax, {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: fistpll {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fistpll {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: fldcw {{[0-9]+}}(%rsp) ; SSE2_64_WIN-NEXT: fldcw {{[0-9]+}}(%rsp)
; SSE2_64_WIN-NEXT: movq {{[0-9]+}}(%rsp), %rax ; SSE2_64_WIN-NEXT: movq {{[0-9]+}}(%rsp), %rax
; SSE2_64_WIN-NEXT: addq $24, %rsp ; SSE2_64_WIN-NEXT: addq $16, %rsp
; SSE2_64_WIN-NEXT: retq ; SSE2_64_WIN-NEXT: retq
; ;
; SSE2_64_LIN-LABEL: x_to_s64: ; SSE2_64_LIN-LABEL: x_to_s64:
; SSE2_64_LIN: # %bb.0: ; SSE2_64_LIN: # %bb.0:
; SSE2_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp) ; SSE2_64_LIN-NEXT: fldt {{[0-9]+}}(%rsp)
; SSE2_64_LIN-NEXT: fnstcw -{{[0-9]+}}(%rsp) ; SSE2_64_LIN-NEXT: fnstcw -{{[0-9]+}}(%rsp)
; SSE2_64_LIN-NEXT: movzwl -{{[0-9]+}}(%rsp), %eax ; SSE2_64_LIN-NEXT: movzwl -{{[0-9]+}}(%rsp), %eax
; SSE2_64_LIN-NEXT: movw $3199, -{{[0-9]+}}(%rsp) # imm = 0xC7F ; SSE2_64_LIN-NEXT: movw $3199, -{{[0-9]+}}(%rsp) # imm = 0xC7F
▲ Show 20 Lines • Show All 299 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/X86/win64-long-double.ll

; RUN: llc -mtriple x86_64-w64-mingw32 %s -o - | FileCheck %s
@glob = common dso_local local_unnamed_addr global x86_fp80 0xK00000000000000000000, align 16
define dso_local void @call() {
entry:
%0 = load x86_fp80, x86_fp80* @glob, align 16
%1 = tail call x86_fp80 @floorl(x86_fp80 %0)
store x86_fp80 %1, x86_fp80* @glob, align 16
ret void
}
declare x86_fp80 @floorl(x86_fp80)
; CHECK-LABEL: call
; CHECK: fldt glob(%rip)
; CHECK: fstpt [[ARGOFF:[0-9]+]](%rsp)
; CHECK: leaq [[RETOFF:[0-9]+]](%rsp), %rcx
; CHECK: leaq [[ARGOFF]](%rsp), %rdx
; CHECK: callq floorl
; CHECK: fldt [[RETOFF]](%rsp)
; CHECK: fstpt glob(%rip)