The X86-64 calling convention (annoyingly) specifies that "struct x { float
a,b,c,d; }" is passed or returned in the low 2 elements of two separate XMM
registers. For example, returning that would return "a,b" in the low
elements of XMM0 and "c,d" in the low elements of XMM1. Both llvm-gcc
and clang currently generate atrocious IR for these structs, which you can see
if you compile this:
struct x { float a,b,c,d; };
struct x foo(struct x *P) { return *P; };
The machine code generated by llvm-gcc[*] for this is:
_foo:
movl (%rdi), %eax
movl 4(%rdi), %ecx
shlq $32, %rcx
addq %rax, %rcx
movd %rcx, %xmm0
movl 8(%rdi), %eax
movl 12(%rdi), %ecx
shlq $32, %rcx
addq %rax, %rcx
movd %rcx, %xmm1
ret
when we really just want:
_foo:
movq (%rdi), %xmm0
movq 8(%rdi), %xmm1
ret
I'm looking at having clang generate IR for this by passing and returning
the two halfs as v2f32 values, which they are, and doing insert/extracts in the
caller/callee. However, at the moment, the x86 backend is passing each element
of the v2f32 as an f32, instead of promoting the type and passing the v2f32 as
the low two elements of the v4f32. In the example above, this means it returns
each element in XMM0,XMM1,XMM2,XMM3 instead of just XMM0/1.
We already do this sort of vector promotion for operators in type legalization.
Is there any reason not to do it for the calling convention case? Is there
anyone interested in working on this? :)
-Chris
[*] Clang happens to generate good machine code for this case, but the IR is
still awful and it falls down hard on other similar cases.
