[LLVMdev] Passing structures as pointers, MSVC x64 style

[Carl Norum]

The MS x64 ABI calling convention (http://msdn.microsoft.com/en-us/library/ms235286(VS.80).aspx) says:

    Any argument that doesn’t fit in 8 bytes, or is not 1, 2, 4, or 8 bytes, must be passed by reference.

Clang isn't doing that for us when passing our triple, x86_64-pc-win32-macho.  

Here's a simple example program:

    struct Guid {
      unsigned int    Data1;
      unsigned short  Data2;
      unsigned short  Data3;
      unsigned char   Data4[8];
    };

    struct Guid g = { 0x8faf43c9, 0x85e9, 0x41f9, { 0xbe, 0x42, 0x99, 0x96, 0x4, 0xe0, 0x85, 0xb3 } };

    void v(int, ...);

    void byValue(void)
    {
      v(1, g);
    }

    void byReference(void)
    {
      v(1, &g);
    }

And the disassembled output:

    _byValue:
    0000000000000000	pushq	%rbp
    0000000000000001	movq	%rsp,%rbp
    0000000000000004	subq	$0x30,%rsp
    0000000000000008	movq	0x00000008(%rip),%rax
    000000000000000f	movq	%rax,0xf8(%rbp)
    0000000000000013	movq	0x00000000(%rip),%rax
    000000000000001a	movq	%rax,0xf0(%rbp)
    000000000000001e	movq	0xf0(%rbp),%rdx
    0000000000000022	movq	0xf8(%rbp),%r8
    0000000000000026	movl	$0x00000001,%ecx
    000000000000002b	callq	0x00000030
    0000000000000030	addq	$0x30,%rsp
    0000000000000034	popq	%rbp
    0000000000000035	ret

    _byReference:
    0000000000000040	pushq	%rbp
    0000000000000041	movq	%rsp,%rbp
    0000000000000044	subq	$0x20,%rsp
    0000000000000048	movl	$0x00000001,%ecx
    000000000000004d	leaq	0x00000000(%rip),%rdx
    0000000000000054	callq	0x00000059
    0000000000000059	addq	$0x20,%rsp
    000000000000005d	popq	%rbp
    000000000000005e	ret

The same program's output from MSVC:

    0000000000000000 <byValue>:
       0:   48 56                   rex.W push   %rsi
       2:   57                      push   %rdi
       3:   48 83 ec 38             sub    $0x38,%rsp
       7:   48 8d 44 24 20          lea    0x20(%rsp),%rax
       c:   48 8d 0d 00 00 00 00    lea    0x0(%rip),%rcx        # 13 <byValue+0x13>
      13:   48 8b f8                mov    %rax,%rdi
      16:   48 8b f1                mov    %rcx,%rsi
      19:   b9 10 00 00 00          mov    $0x10,%ecx
      1e:   f3 a4                   rep movsb %ds:(%rsi),%es:(%rdi)
      20:   48 8d 54 24 20          lea    0x20(%rsp),%rdx
      25:   b9 01 00 00 00          mov    $0x1,%ecx
      2a:   e8 00 00 00 00          callq  2f <byValue+0x2f>
      2f:   48 83 c4 38             add    $0x38,%rsp
      33:   5f                      pop    %rdi
      34:   5e                      pop    %rsi

    0000000000000040 <byReference>:
      40:   48 83 ec 28             sub    $0x28,%rsp
      44:   48 8d 15 00 00 00 00    lea    0x0(%rip),%rdx        # 4b <byReference+0xb>
      4b:   b9 01 00 00 00          mov    $0x1,%ecx
      50:   e8 00 00 00 00          callq  55 <byReference+0x15>
      55:   48 83 c4 28             add    $0x28,%rsp
      59:   c3                      retq   

As you can see, MSVC is making a copy of the structure and then passing a pointer to it in the byValue() call, whereas clang is actually stuffing the whole structure into the parameter transfer registers and spilling over onto the stack.  Does clang support the MSVC style calling convention?  Did I miss something when submitting our earlier patches?

Background information - we have a printf-like function in EFI that has a "%g" format string for printing GUIDs.  It looks like there's some sloppy code around that calls that print function with GUIDs, rather than with pointers to GUIDs as the print function expects.  On MSVC, because of this calling convention detail, it works fine - clang-built ROMs crash spectacularly.

Thanks for any suggestions or ideas!  I'll happily try to come up with a patch if someone can point me in the right general direction in the source tree!

-- Carl