| /* ----------------------------------------------------------------------- |
| darwin64.S - Copyright (c) 2006 Free Software Foundation, Inc. |
| Copyright (c) 2008 Red Hat, Inc. |
| derived from unix64.S |
| |
| x86-64 Foreign Function Interface for Darwin. |
| |
| Permission is hereby granted, free of charge, to any person obtaining |
| a copy of this software and associated documentation files (the |
| ``Software''), to deal in the Software without restriction, including |
| without limitation the rights to use, copy, modify, merge, publish, |
| distribute, sublicense, and/or sell copies of the Software, and to |
| permit persons to whom the Software is furnished to do so, subject to |
| the following conditions: |
| |
| The above copyright notice and this permission notice shall be included |
| in all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| OTHER DEALINGS IN THE SOFTWARE. |
| ----------------------------------------------------------------------- */ |
| |
| #ifdef __x86_64__ |
| #define LIBFFI_ASM |
| #include <fficonfig.h> |
| #include <ffi.h> |
| |
| .file "darwin64.S" |
| .text |
| |
| /* ffi_call_unix64 (void *args, unsigned long bytes, unsigned flags, |
| void *raddr, void (*fnaddr)(void)); |
| |
| Bit o trickiness here -- ARGS+BYTES is the base of the stack frame |
| for this function. This has been allocated by ffi_call. We also |
| deallocate some of the stack that has been alloca'd. */ |
| |
| .align 3 |
| .globl _ffi_call_unix64 |
| |
| _ffi_call_unix64: |
| LUW0: |
| movq (%rsp), %r10 /* Load return address. */ |
| leaq (%rdi, %rsi), %rax /* Find local stack base. */ |
| movq %rdx, (%rax) /* Save flags. */ |
| movq %rcx, 8(%rax) /* Save raddr. */ |
| movq %rbp, 16(%rax) /* Save old frame pointer. */ |
| movq %r10, 24(%rax) /* Relocate return address. */ |
| movq %rax, %rbp /* Finalize local stack frame. */ |
| LUW1: |
| movq %rdi, %r10 /* Save a copy of the register area. */ |
| movq %r8, %r11 /* Save a copy of the target fn. */ |
| movl %r9d, %eax /* Set number of SSE registers. */ |
| |
| /* Load up all argument registers. */ |
| movq (%r10), %rdi |
| movq 8(%r10), %rsi |
| movq 16(%r10), %rdx |
| movq 24(%r10), %rcx |
| movq 32(%r10), %r8 |
| movq 40(%r10), %r9 |
| testl %eax, %eax |
| jnz Lload_sse |
| Lret_from_load_sse: |
| |
| /* Deallocate the reg arg area. */ |
| leaq 176(%r10), %rsp |
| |
| /* Call the user function. */ |
| call *%r11 |
| |
| /* Deallocate stack arg area; local stack frame in redzone. */ |
| leaq 24(%rbp), %rsp |
| |
| movq 0(%rbp), %rcx /* Reload flags. */ |
| movq 8(%rbp), %rdi /* Reload raddr. */ |
| movq 16(%rbp), %rbp /* Reload old frame pointer. */ |
| LUW2: |
| |
| /* The first byte of the flags contains the FFI_TYPE. */ |
| movzbl %cl, %r10d |
| leaq Lstore_table(%rip), %r11 |
| movslq (%r11, %r10, 4), %r10 |
| addq %r11, %r10 |
| jmp *%r10 |
| |
| Lstore_table: |
| .long Lst_void-Lstore_table /* FFI_TYPE_VOID */ |
| .long Lst_sint32-Lstore_table /* FFI_TYPE_INT */ |
| .long Lst_float-Lstore_table /* FFI_TYPE_FLOAT */ |
| .long Lst_double-Lstore_table /* FFI_TYPE_DOUBLE */ |
| .long Lst_ldouble-Lstore_table /* FFI_TYPE_LONGDOUBLE */ |
| .long Lst_uint8-Lstore_table /* FFI_TYPE_UINT8 */ |
| .long Lst_sint8-Lstore_table /* FFI_TYPE_SINT8 */ |
| .long Lst_uint16-Lstore_table /* FFI_TYPE_UINT16 */ |
| .long Lst_sint16-Lstore_table /* FFI_TYPE_SINT16 */ |
| .long Lst_uint32-Lstore_table /* FFI_TYPE_UINT32 */ |
| .long Lst_sint32-Lstore_table /* FFI_TYPE_SINT32 */ |
| .long Lst_int64-Lstore_table /* FFI_TYPE_UINT64 */ |
| .long Lst_int64-Lstore_table /* FFI_TYPE_SINT64 */ |
| .long Lst_struct-Lstore_table /* FFI_TYPE_STRUCT */ |
| .long Lst_int64-Lstore_table /* FFI_TYPE_POINTER */ |
| |
| .text |
| .align 3 |
| Lst_void: |
| ret |
| .align 3 |
| Lst_uint8: |
| movzbq %al, %rax |
| movq %rax, (%rdi) |
| ret |
| .align 3 |
| Lst_sint8: |
| movsbq %al, %rax |
| movq %rax, (%rdi) |
| ret |
| .align 3 |
| Lst_uint16: |
| movzwq %ax, %rax |
| movq %rax, (%rdi) |
| .align 3 |
| Lst_sint16: |
| movswq %ax, %rax |
| movq %rax, (%rdi) |
| ret |
| .align 3 |
| Lst_uint32: |
| movl %eax, %eax |
| movq %rax, (%rdi) |
| .align 3 |
| Lst_sint32: |
| cltq |
| movq %rax, (%rdi) |
| ret |
| .align 3 |
| Lst_int64: |
| movq %rax, (%rdi) |
| ret |
| .align 3 |
| Lst_float: |
| movss %xmm0, (%rdi) |
| ret |
| .align 3 |
| Lst_double: |
| movsd %xmm0, (%rdi) |
| ret |
| Lst_ldouble: |
| fstpt (%rdi) |
| ret |
| .align 3 |
| Lst_struct: |
| leaq -20(%rsp), %rsi /* Scratch area in redzone. */ |
| |
| /* We have to locate the values now, and since we don't want to |
| write too much data into the user's return value, we spill the |
| value to a 16 byte scratch area first. Bits 8, 9, and 10 |
| control where the values are located. Only one of the three |
| bits will be set; see ffi_prep_cif_machdep for the pattern. */ |
| movd %xmm0, %r10 |
| movd %xmm1, %r11 |
| testl $0x100, %ecx |
| cmovnz %rax, %rdx |
| cmovnz %r10, %rax |
| testl $0x200, %ecx |
| cmovnz %r10, %rdx |
| testl $0x400, %ecx |
| cmovnz %r10, %rax |
| cmovnz %r11, %rdx |
| movq %rax, (%rsi) |
| movq %rdx, 8(%rsi) |
| |
| /* Bits 12-31 contain the true size of the structure. Copy from |
| the scratch area to the true destination. */ |
| shrl $12, %ecx |
| rep movsb |
| ret |
| |
| /* Many times we can avoid loading any SSE registers at all. |
| It's not worth an indirect jump to load the exact set of |
| SSE registers needed; zero or all is a good compromise. */ |
| .align 3 |
| LUW3: |
| Lload_sse: |
| movdqa 48(%r10), %xmm0 |
| movdqa 64(%r10), %xmm1 |
| movdqa 80(%r10), %xmm2 |
| movdqa 96(%r10), %xmm3 |
| movdqa 112(%r10), %xmm4 |
| movdqa 128(%r10), %xmm5 |
| movdqa 144(%r10), %xmm6 |
| movdqa 160(%r10), %xmm7 |
| jmp Lret_from_load_sse |
| |
| LUW4: |
| .align 3 |
| .globl _ffi_closure_unix64 |
| |
| _ffi_closure_unix64: |
| LUW5: |
| /* The carry flag is set by the trampoline iff SSE registers |
| are used. Don't clobber it before the branch instruction. */ |
| leaq -200(%rsp), %rsp |
| LUW6: |
| movq %rdi, (%rsp) |
| movq %rsi, 8(%rsp) |
| movq %rdx, 16(%rsp) |
| movq %rcx, 24(%rsp) |
| movq %r8, 32(%rsp) |
| movq %r9, 40(%rsp) |
| jc Lsave_sse |
| Lret_from_save_sse: |
| |
| movq %r10, %rdi |
| leaq 176(%rsp), %rsi |
| movq %rsp, %rdx |
| leaq 208(%rsp), %rcx |
| call _ffi_closure_unix64_inner |
| |
| /* Deallocate stack frame early; return value is now in redzone. */ |
| addq $200, %rsp |
| LUW7: |
| |
| /* The first byte of the return value contains the FFI_TYPE. */ |
| movzbl %al, %r10d |
| leaq Lload_table(%rip), %r11 |
| movslq (%r11, %r10, 4), %r10 |
| addq %r11, %r10 |
| jmp *%r10 |
| |
| Lload_table: |
| .long Lld_void-Lload_table /* FFI_TYPE_VOID */ |
| .long Lld_int32-Lload_table /* FFI_TYPE_INT */ |
| .long Lld_float-Lload_table /* FFI_TYPE_FLOAT */ |
| .long Lld_double-Lload_table /* FFI_TYPE_DOUBLE */ |
| .long Lld_ldouble-Lload_table /* FFI_TYPE_LONGDOUBLE */ |
| .long Lld_int8-Lload_table /* FFI_TYPE_UINT8 */ |
| .long Lld_int8-Lload_table /* FFI_TYPE_SINT8 */ |
| .long Lld_int16-Lload_table /* FFI_TYPE_UINT16 */ |
| .long Lld_int16-Lload_table /* FFI_TYPE_SINT16 */ |
| .long Lld_int32-Lload_table /* FFI_TYPE_UINT32 */ |
| .long Lld_int32-Lload_table /* FFI_TYPE_SINT32 */ |
| .long Lld_int64-Lload_table /* FFI_TYPE_UINT64 */ |
| .long Lld_int64-Lload_table /* FFI_TYPE_SINT64 */ |
| .long Lld_struct-Lload_table /* FFI_TYPE_STRUCT */ |
| .long Lld_int64-Lload_table /* FFI_TYPE_POINTER */ |
| |
| .text |
| .align 3 |
| Lld_void: |
| ret |
| .align 3 |
| Lld_int8: |
| movzbl -24(%rsp), %eax |
| ret |
| .align 3 |
| Lld_int16: |
| movzwl -24(%rsp), %eax |
| ret |
| .align 3 |
| Lld_int32: |
| movl -24(%rsp), %eax |
| ret |
| .align 3 |
| Lld_int64: |
| movq -24(%rsp), %rax |
| ret |
| .align 3 |
| Lld_float: |
| movss -24(%rsp), %xmm0 |
| ret |
| .align 3 |
| Lld_double: |
| movsd -24(%rsp), %xmm0 |
| ret |
| .align 3 |
| Lld_ldouble: |
| fldt -24(%rsp) |
| ret |
| .align 3 |
| Lld_struct: |
| /* There are four possibilities here, %rax/%rdx, %xmm0/%rax, |
| %rax/%xmm0, %xmm0/%xmm1. We collapse two by always loading |
| both rdx and xmm1 with the second word. For the remaining, |
| bit 8 set means xmm0 gets the second word, and bit 9 means |
| that rax gets the second word. */ |
| movq -24(%rsp), %rcx |
| movq -16(%rsp), %rdx |
| movq -16(%rsp), %xmm1 |
| testl $0x100, %eax |
| cmovnz %rdx, %rcx |
| movd %rcx, %xmm0 |
| testl $0x200, %eax |
| movq -24(%rsp), %rax |
| cmovnz %rdx, %rax |
| ret |
| |
| /* See the comment above Lload_sse; the same logic applies here. */ |
| .align 3 |
| LUW8: |
| Lsave_sse: |
| movdqa %xmm0, 48(%rsp) |
| movdqa %xmm1, 64(%rsp) |
| movdqa %xmm2, 80(%rsp) |
| movdqa %xmm3, 96(%rsp) |
| movdqa %xmm4, 112(%rsp) |
| movdqa %xmm5, 128(%rsp) |
| movdqa %xmm6, 144(%rsp) |
| movdqa %xmm7, 160(%rsp) |
| jmp Lret_from_save_sse |
| |
| LUW9: |
| .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support |
| EH_frame1: |
| .set L$set$0,LECIE1-LSCIE1 /* CIE Length */ |
| .long L$set$0 |
| LSCIE1: |
| .long 0x0 /* CIE Identifier Tag */ |
| .byte 0x1 /* CIE Version */ |
| .ascii "zR\0" /* CIE Augmentation */ |
| .byte 0x1 /* uleb128 0x1; CIE Code Alignment Factor */ |
| .byte 0x78 /* sleb128 -8; CIE Data Alignment Factor */ |
| .byte 0x10 /* CIE RA Column */ |
| .byte 0x1 /* uleb128 0x1; Augmentation size */ |
| .byte 0x10 /* FDE Encoding (pcrel sdata4) */ |
| .byte 0xc /* DW_CFA_def_cfa, %rsp offset 8 */ |
| .byte 0x7 /* uleb128 0x7 */ |
| .byte 0x8 /* uleb128 0x8 */ |
| .byte 0x90 /* DW_CFA_offset, column 0x10 */ |
| .byte 0x1 |
| .align 3 |
| LECIE1: |
| .globl _ffi_call_unix64.eh |
| _ffi_call_unix64.eh: |
| LSFDE1: |
| .set L$set$1,LEFDE1-LASFDE1 /* FDE Length */ |
| .long L$set$1 |
| LASFDE1: |
| .long LASFDE1-EH_frame1 /* FDE CIE offset */ |
| .quad LUW0-. /* FDE initial location */ |
| .set L$set$2,LUW4-LUW0 /* FDE address range */ |
| .quad L$set$2 |
| .byte 0x0 /* Augmentation size */ |
| .byte 0x4 /* DW_CFA_advance_loc4 */ |
| .set L$set$3,LUW1-LUW0 |
| .long L$set$3 |
| |
| /* New stack frame based off rbp. This is a itty bit of unwind |
| trickery in that the CFA *has* changed. There is no easy way |
| to describe it correctly on entry to the function. Fortunately, |
| it doesn't matter too much since at all points we can correctly |
| unwind back to ffi_call. Note that the location to which we |
| moved the return address is (the new) CFA-8, so from the |
| perspective of the unwind info, it hasn't moved. */ |
| .byte 0xc /* DW_CFA_def_cfa, %rbp offset 32 */ |
| .byte 0x6 |
| .byte 0x20 |
| .byte 0x80+6 /* DW_CFA_offset, %rbp offset 2*-8 */ |
| .byte 0x2 |
| .byte 0xa /* DW_CFA_remember_state */ |
| |
| .byte 0x4 /* DW_CFA_advance_loc4 */ |
| .set L$set$4,LUW2-LUW1 |
| .long L$set$4 |
| .byte 0xc /* DW_CFA_def_cfa, %rsp offset 8 */ |
| .byte 0x7 |
| .byte 0x8 |
| .byte 0xc0+6 /* DW_CFA_restore, %rbp */ |
| |
| .byte 0x4 /* DW_CFA_advance_loc4 */ |
| .set L$set$5,LUW3-LUW2 |
| .long L$set$5 |
| .byte 0xb /* DW_CFA_restore_state */ |
| |
| .align 3 |
| LEFDE1: |
| .globl _ffi_closure_unix64.eh |
| _ffi_closure_unix64.eh: |
| LSFDE3: |
| .set L$set$6,LEFDE3-LASFDE3 /* FDE Length */ |
| .long L$set$6 |
| LASFDE3: |
| .long LASFDE3-EH_frame1 /* FDE CIE offset */ |
| .quad LUW5-. /* FDE initial location */ |
| .set L$set$7,LUW9-LUW5 /* FDE address range */ |
| .quad L$set$7 |
| .byte 0x0 /* Augmentation size */ |
| |
| .byte 0x4 /* DW_CFA_advance_loc4 */ |
| .set L$set$8,LUW6-LUW5 |
| .long L$set$8 |
| .byte 0xe /* DW_CFA_def_cfa_offset */ |
| .byte 208,1 /* uleb128 208 */ |
| .byte 0xa /* DW_CFA_remember_state */ |
| |
| .byte 0x4 /* DW_CFA_advance_loc4 */ |
| .set L$set$9,LUW7-LUW6 |
| .long L$set$9 |
| .byte 0xe /* DW_CFA_def_cfa_offset */ |
| .byte 0x8 |
| |
| .byte 0x4 /* DW_CFA_advance_loc4 */ |
| .set L$set$10,LUW8-LUW7 |
| .long L$set$10 |
| .byte 0xb /* DW_CFA_restore_state */ |
| |
| .align 3 |
| LEFDE3: |
| .subsections_via_symbols |
| |
| #endif /* __x86_64__ */ |
