libffi/src/x86/win64_intel.S

   1 #define LIBFFI_ASM
   2 #include <fficonfig.h>
   3 #include <ffi.h>
   4 #include <ffi_cfi.h>
   5 #include "asmnames.h"
   6
   7 #if defined(HAVE_AS_CFI_PSEUDO_OP)
   8         .cfi_sections   .debug_frame
   9 #endif
  10
  11 #ifdef X86_WIN64
  12 #define SEH(...) __VA_ARGS__
  13 #define arg0    rcx
  14 #define arg1    rdx
  15 #define arg2    r8
  16 #define arg3    r9
  17 #else
  18 #define SEH(...)
  19 #define arg0    rdi
  20 #define arg1    rsi
  21 #define arg2    rdx
  22 #define arg3    rcx
  23 #endif
  24
  25 /* This macro allows the safe creation of jump tables without an
  26    actual table.  The entry points into the table are all 8 bytes.
  27    The use of ORG asserts that we're at the correct location.  */
  28 /* ??? The clang assembler doesn't handle .org with symbolic expressions.  */
  29 #if defined(__clang__) || defined(__APPLE__) || (defined (__sun__) && defined(__svr4__))
  30 # define E(BASE, X)     ALIGN 8
  31 #else
  32 # define E(BASE, X)     ALIGN 8; ORG BASE + (X) * 8
  33 #endif
  34
  35         .CODE
  36         extern PLT(C(abort)):near
  37         extern C(ffi_closure_win64_inner):near
  38
  39 /* ffi_call_win64 (void *stack, struct win64_call_frame *frame, void *r10)
  40
  41    Bit o trickiness here -- FRAME is the base of the stack frame
  42    for this function.  This has been allocated by ffi_call.  We also
  43    deallocate some of the stack that has been alloca'd.  */
  44
  45         ALIGN   8
  46         PUBLIC  C(ffi_call_win64)
  47
  48         ; SEH(.safesh ffi_call_win64)
  49 C(ffi_call_win64) proc SEH(frame)
  50         cfi_startproc
  51         /* Set up the local stack frame and install it in rbp/rsp.  */
  52         mov     RAX, [RSP] ;    movq    (%rsp), %rax
  53         mov [arg1], RBP ; movq  %rbp, (arg1)
  54         mov [arg1 + 8], RAX;    movq    %rax, 8(arg1)
  55         mov      RBP, arg1; movq        arg1, %rbp
  56         cfi_def_cfa(rbp, 16)
  57         cfi_rel_offset(rbp, 0)
  58         SEH(.pushreg rbp)
  59         SEH(.setframe rbp, 0)
  60         SEH(.endprolog)
  61         mov     RSP, arg0 ;     movq    arg0, %rsp
  62
  63         mov     R10, arg2 ; movq        arg2, %r10
  64
  65         /* Load all slots into both general and xmm registers.  */
  66         mov     RCX, [RSP] ;    movq    (%rsp), %rcx
  67         movsd XMM0, qword ptr [RSP] ; movsd     (%rsp), %xmm0
  68         mov     RDX, [RSP + 8] ;movq    8(%rsp), %rdx
  69         movsd XMM1, qword ptr [RSP + 8];        movsd   8(%rsp), %xmm1
  70         mov R8, [RSP + 16] ; movq       16(%rsp), %r8
  71         movsd   XMM2, qword ptr [RSP + 16] ; movsd      16(%rsp), %xmm2
  72         mov     R9, [RSP + 24] ; movq   24(%rsp), %r9
  73         movsd   XMM3, qword ptr [RSP + 24] ;movsd       24(%rsp), %xmm3
  74
  75         CALL qword ptr [RBP + 16] ; call        *16(%rbp)
  76
  77         mov      ECX, [RBP + 24] ; movl 24(%rbp), %ecx
  78         mov     R8, [RBP + 32] ; movq   32(%rbp), %r8
  79         LEA     R10, ffi_call_win64_tab ; leaq  0f(%rip), %r10
  80         CMP     ECX, FFI_TYPE_SMALL_STRUCT_4B ; cmpl    $FFI_TYPE_SMALL_STRUCT_4B, %ecx
  81         LEA     R10, [R10 + RCX*8] ; leaq       (%r10, %rcx, 8), %r10
  82         JA      L99 ; ja        99f
  83         JMP     R10 ; jmp       *%r10
  84
  85 /* Below, we're space constrained most of the time.  Thus we eschew the
  86    modern "mov, pop, ret" sequence (5 bytes) for "leave, ret" (2 bytes).  */
  87 epilogue macro
  88         LEAVE
  89         cfi_remember_state
  90         cfi_def_cfa(rsp, 8)
  91         cfi_restore(rbp)
  92         RET
  93         cfi_restore_state
  94 endm
  95
  96         ALIGN 8
  97 ffi_call_win64_tab LABEL NEAR
  98 E(0b, FFI_TYPE_VOID)
  99         epilogue
 100 E(0b, FFI_TYPE_INT)
 101         movsxd rax, eax ; movslq        %eax, %rax
 102         mov qword ptr [r8], rax; movq   %rax, (%r8)
 103         epilogue
 104 E(0b, FFI_TYPE_FLOAT)
 105         movss dword ptr [r8], xmm0 ; movss      %xmm0, (%r8)
 106         epilogue
 107 E(0b, FFI_TYPE_DOUBLE)
 108         movsd qword ptr[r8], xmm0; movsd        %xmm0, (%r8)
 109         epilogue
 110 // FFI_TYPE_LONGDOUBLE may be FFI_TYPE_DOUBLE but we need a different value here.
 111 E(0b, FFI_TYPE_DOUBLE + 1)
 112         call    PLT(C(abort))
 113 E(0b, FFI_TYPE_UINT8)
 114         movzx eax, al ;movzbl   %al, %eax
 115         mov qword ptr[r8], rax; movq    %rax, (%r8)
 116         epilogue
 117 E(0b, FFI_TYPE_SINT8)
 118         movsx rax, al ; movsbq  %al, %rax
 119         jmp     L98
 120 E(0b, FFI_TYPE_UINT16)
 121         movzx eax, ax ; movzwl  %ax, %eax
 122         mov qword ptr[r8], rax; movq    %rax, (%r8)
 123         epilogue
 124 E(0b, FFI_TYPE_SINT16)
 125         movsx rax, ax; movswq   %ax, %rax
 126         jmp     L98
 127 E(0b, FFI_TYPE_UINT32)
 128         mov eax, eax; movl      %eax, %eax
 129         mov qword ptr[r8], rax ; movq   %rax, (%r8)
 130         epilogue
 131 E(0b, FFI_TYPE_SINT32)
 132         movsxd rax, eax; movslq %eax, %rax
 133         mov qword ptr [r8], rax; movq   %rax, (%r8)
 134         epilogue
 135 E(0b, FFI_TYPE_UINT64)
 136 L98 LABEL near
 137         mov qword ptr [r8], rax ; movq  %rax, (%r8)
 138         epilogue
 139 E(0b, FFI_TYPE_SINT64)
 140         mov qword ptr [r8], rax;movq    %rax, (%r8)
 141         epilogue
 142 E(0b, FFI_TYPE_STRUCT)
 143         epilogue
 144 E(0b, FFI_TYPE_POINTER)
 145         mov qword ptr [r8], rax ;movq   %rax, (%r8)
 146         epilogue
 147 E(0b, FFI_TYPE_COMPLEX)
 148         call    PLT(C(abort))
 149 E(0b, FFI_TYPE_SMALL_STRUCT_1B)
 150         mov byte ptr [r8], al ; movb    %al, (%r8)
 151         epilogue
 152 E(0b, FFI_TYPE_SMALL_STRUCT_2B)
 153         mov word ptr [r8], ax ; movw    %ax, (%r8)
 154         epilogue
 155 E(0b, FFI_TYPE_SMALL_STRUCT_4B)
 156         mov dword ptr [r8], eax ; movl  %eax, (%r8)
 157         epilogue
 158
 159         align   8
 160 L99 LABEL near
 161         call    PLT(C(abort))
 162
 163         epilogue
 164
 165         cfi_endproc
 166         C(ffi_call_win64) endp
 167
 168
 169 /* 32 bytes of outgoing register stack space, 8 bytes of alignment,
 170    16 bytes of result, 32 bytes of xmm registers.  */
 171 #define ffi_clo_FS      (32+8+16+32)
 172 #define ffi_clo_OFF_R   (32+8)
 173 #define ffi_clo_OFF_X   (32+8+16)
 174
 175         align   8
 176         PUBLIC  C(ffi_go_closure_win64)
 177
 178 C(ffi_go_closure_win64) proc
 179         cfi_startproc
 180         /* Save all integer arguments into the incoming reg stack space.  */
 181         mov qword ptr [rsp + 8], rcx; movq      %rcx, 8(%rsp)
 182         mov qword ptr [rsp + 16], rdx; movq     %rdx, 16(%rsp)
 183         mov qword ptr [rsp + 24], r8; movq      %r8, 24(%rsp)
 184         mov qword ptr [rsp + 32], r9 ;movq      %r9, 32(%rsp)
 185
 186         mov rcx, qword ptr [r10 + 8]; movq      8(%r10), %rcx                   /* load cif */
 187         mov rdx, qword ptr [r10 + 16];  movq    16(%r10), %rdx                  /* load fun */
 188         mov r8, r10 ; movq      %r10, %r8                       /* closure is user_data */
 189         jmp     ffi_closure_win64_2
 190         cfi_endproc
 191         C(ffi_go_closure_win64) endp
 192
 193         align   8
 194
 195 PUBLIC C(ffi_closure_win64)
 196 C(ffi_closure_win64) PROC FRAME
 197         cfi_startproc
 198         /* Save all integer arguments into the incoming reg stack space.  */
 199         mov qword ptr [rsp + 8], rcx; movq      %rcx, 8(%rsp)
 200         mov qword ptr [rsp + 16], rdx;  movq    %rdx, 16(%rsp)
 201         mov qword ptr [rsp + 24], r8;   movq    %r8, 24(%rsp)
 202         mov qword ptr [rsp + 32], r9;   movq    %r9, 32(%rsp)
 203
 204         mov rcx, qword ptr [FFI_TRAMPOLINE_SIZE + r10]  ;movq   FFI_TRAMPOLINE_SIZE(%r10), %rcx         /* load cif */
 205         mov rdx, qword ptr [FFI_TRAMPOLINE_SIZE + 8 + r10] ;    movq    FFI_TRAMPOLINE_SIZE+8(%r10), %rdx       /* load fun */
 206         mov r8, qword ptr [FFI_TRAMPOLINE_SIZE+16+r10] ;movq    FFI_TRAMPOLINE_SIZE+16(%r10), %r8       /* load user_data */
 207 ffi_closure_win64_2 LABEL near
 208         sub rsp, ffi_clo_FS ;subq       $ffi_clo_FS, %rsp
 209         cfi_adjust_cfa_offset(ffi_clo_FS)
 210         SEH(.allocstack ffi_clo_FS)
 211         SEH(.endprolog)
 212
 213         /* Save all sse arguments into the stack frame.  */
 214         movsd qword ptr [ffi_clo_OFF_X + rsp], xmm0     ; movsd %xmm0, ffi_clo_OFF_X(%rsp)
 215         movsd qword ptr [ffi_clo_OFF_X+8+rsp], xmm1 ; movsd     %xmm1, ffi_clo_OFF_X+8(%rsp)
 216         movsd qword ptr [ffi_clo_OFF_X+16+rsp], xmm2 ; movsd %xmm2, ffi_clo_OFF_X+16(%rsp)
 217         movsd qword ptr [ffi_clo_OFF_X+24+rsp], xmm3 ; movsd %xmm3, ffi_clo_OFF_X+24(%rsp)
 218
 219         lea     r9, [ffi_clo_OFF_R + rsp] ; leaq        ffi_clo_OFF_R(%rsp), %r9
 220         call C(ffi_closure_win64_inner)
 221
 222         /* Load the result into both possible result registers.  */
 223
 224         mov rax, qword ptr [ffi_clo_OFF_R + rsp] ;movq    ffi_clo_OFF_R(%rsp), %rax
 225         movsd xmm0, qword ptr [rsp + ffi_clo_OFF_R] ;movsd   ffi_clo_OFF_R(%rsp), %xmm0
 226
 227         add rsp, ffi_clo_FS ;addq       $ffi_clo_FS, %rsp
 228         cfi_adjust_cfa_offset(-ffi_clo_FS)
 229         ret
 230
 231         cfi_endproc
 232         C(ffi_closure_win64) endp
 233
 234 #if defined __ELF__ && defined __linux__
 235         .section        .note.GNU-stack,"",@progbits
 236 #endif
 237 _text ends
 238 end