[Win64] Handle FP arguments more gracefully under -mno-sse

[rnk]

Summary

Pass small FP values in GPRs or stack memory according the the normal
convention. This is what gcc -mno-sse does on Win64.

[aemerson]

Is a compiler abort not preferable to generating non-ABI conforming code?

[rnk]

Well, specifically for the MSVC side of things, they don't implement a -mno-sse mode:
https://social.msdn.microsoft.com/Forums/vstudio/en-US/da46257b-4d92-402f-b320-b727341f6d30/disabling-ssesse2-code-generation-in-64bit-builds?forum=vcgeneral
So, we have to make up our own rules anway.

I suppose we might as well follow GCC, then. I see they pass in GPRs in this case. Let's do that.

[aemerson]

Adding @craig.topper and @RKSimon to weigh in.

[craig.topper]

Isn't this passing by memory not by X87?

[efriedma]

I'm not opposed to supporting a soft-float ABI. But I don't think -mno-sse is a strong enough signal that the user actually understands what they're asking for, as opposed to being an accidental leftover from a 32-bit project. I'd prefer to print an error.

[rnk]

• follow GCC

[rnk]

In D70465#1752671, @efriedma wrote:

I'm not opposed to supporting a soft-float ABI. But I don't think -mno-sse is a strong enough signal that the user actually understands what they're asking for, as opposed to being an accidental leftover from a 32-bit project. I'd prefer to print an error.

Well, -mno-sse seems to be enough to get GCC to do a soft-floatish thing, so I'm really just trying to follow them here. I think what we're finding in practice is that simply implementing the functionality we didn't intend to support is actually easier than nailing down the corner cases under which we should emit an error and recovering correctly.

In D70465#1752668, @craig.topper wrote:

Isn't this passing by memory not by X87?

You're right, it was. Now it converts to i32/i64, which goes via RCX/RDX/etc then stack memory.

[rnk]

• rebase

[rnk]

Any thoughts on this?

[aemerson]

In D70465#1776252, @rnk wrote:

Any thoughts on this?

I'm ok with this approach if that's what GCC does. Anyone else disagree?

[rnk]

• rebase over e898ba2d151d621dcfc35828aad6fcded5a554e8

[merge_guards_bot]

Unit tests: pass. 61176 tests passed, 0 failed and 729 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[aemerson]

No objections for a week, LGTM.

[aemerson]

Ping.

[rnk]

Thanks, I'll rebase it and land it today. I was out skiing last week.

llvm/lib/Target/X86/X86CallingConv.td

def CC_X86_Win64_C : CallingConv<[
   CCIfSwiftError<CCIfType<[i64], CCAssignToReg<[R12]>>>,
 
   // The 'CFGuardTarget' parameter, if any, is passed in RAX.
   CCIfCFGuardTarget<CCAssignToReg<[RAX]>>,
 
   // 128 bit vectors are passed by pointer
   CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], CCPassIndirect<i64>>,
 
-
   // 256 bit vectors are passed by pointer
   CCIfType<[v32i8, v16i16, v8i32, v4i64, v8f32, v4f64], CCPassIndirect<i64>>,
 
   // 512 bit vectors are passed by pointer
   CCIfType<[v64i8, v32i16, v16i32, v16f32, v8f64, v8i64], CCPassIndirect<i64>>,
 
   // Long doubles are passed by pointer
   CCIfType<[f80], CCPassIndirect<i64>>,
def CC_X86_Win64_C : CallingConv<[
   CCIfCC<"CallingConv::X86_ThisCall",
     CCIfSRet<CCIfType<[i64], CCAssignToRegWithShadow<[RDX , R8  , R9  ],
                                                      [XMM1, XMM2, XMM3]>>>>,
 
   CCIfType<[i64], CCAssignToRegWithShadow<[RCX , RDX , R8  , R9  ],
                                           [XMM0, XMM1, XMM2, XMM3]>>,
 
   // The first 4 FP/Vector arguments are passed in XMM registers.
-  CCIfType<[f32, f64, v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
+  CCIfType<[f32, f64],
+           CCIfSubtarget<"hasSSE1()",
              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
   // 8-byte aligned if there are no more registers to hold them.
   CCIfType<[i8, i16, i32, i64, f32, f64], CCAssignToStack<8, 8>>
 ]>;
 
 def CC_X86_Win64_VectorCall : CallingConv<[
   CCCustom<"CC_X86_64_VectorCall">,

llvm/test/CodeGen/X86/no-sse-win64.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s -check-prefix=SSE
+; RUN: llc -mtriple=x86_64-windows-msvc < %s -mattr=-sse | FileCheck %s -check-prefix=NOSSE
+
+define void @pass_double(double %v, double* %p) {
+; SSE-LABEL: pass_double:
+; SSE:       # %bb.0:
+; SSE-NEXT:    movsd %xmm0, (%rdx)
+; SSE-NEXT:    retq
+;
+; NOSSE-LABEL: pass_double:
+; NOSSE:       # %bb.0:
+; NOSSE-NEXT:    fldl {{[0-9]+}}(%rsp)
+; NOSSE-NEXT:    fstpl (%rcx)
+; NOSSE-NEXT:    retq
+  store double %v, double* %p
+  ret void
+}
+
+define void @pass_float(float %v, float* %p) {
+; SSE-LABEL: pass_float:
+; SSE:       # %bb.0:
+; SSE-NEXT:    movss %xmm0, (%rdx)
+; SSE-NEXT:    retq
+;
+; NOSSE-LABEL: pass_float:
+; NOSSE:       # %bb.0:
+; NOSSE-NEXT:    flds {{[0-9]+}}(%rsp)
+; NOSSE-NEXT:    fstps (%rcx)
+; NOSSE-NEXT:    retq
+  store float %v, float* %p
+  ret void
+}