js/src/ctypes/libffi/src/x86/darwin64.S

   1 /* -----------------------------------------------------------------------
   2    darwin64.S - Copyright (c) 2006 Free Software Foundation, Inc.
   3                 Copyright (c) 2008 Red Hat, Inc.
   4    derived from unix64.S
   5
   6    x86-64 Foreign Function Interface for Darwin.
   7
   8    Permission is hereby granted, free of charge, to any person obtaining
   9    a copy of this software and associated documentation files (the
  10    ``Software''), to deal in the Software without restriction, including
  11    without limitation the rights to use, copy, modify, merge, publish,
  12    distribute, sublicense, and/or sell copies of the Software, and to
  13    permit persons to whom the Software is furnished to do so, subject to
  14    the following conditions:
  15
  16    The above copyright notice and this permission notice shall be included
  17    in all copies or substantial portions of the Software.
  18
  19    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  22    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25    OTHER DEALINGS IN THE SOFTWARE.
  26    ----------------------------------------------------------------------- */
  27
  28 #ifdef __x86_64__
  29 #define LIBFFI_ASM
  30 #include <fficonfig.h>
  31 #include <ffi.h>
  32
  33         .file "darwin64.S"
  34 .text
  35
  36 /* ffi_call_unix64 (void *args, unsigned long bytes, unsigned flags,
  37                     void *raddr, void (*fnaddr)(void));
  38
  39    Bit o trickiness here -- ARGS+BYTES is the base of the stack frame
  40    for this function.  This has been allocated by ffi_call.  We also
  41    deallocate some of the stack that has been alloca'd.  */
  42
  43         .align  3
  44         .globl  _ffi_call_unix64
  45
  46 _ffi_call_unix64:
  47 LUW0:
  48         movq    (%rsp), %r10            /* Load return address.  */
  49         leaq    (%rdi, %rsi), %rax      /* Find local stack base.  */
  50         movq    %rdx, (%rax)            /* Save flags.  */
  51         movq    %rcx, 8(%rax)           /* Save raddr.  */
  52         movq    %rbp, 16(%rax)          /* Save old frame pointer.  */
  53         movq    %r10, 24(%rax)          /* Relocate return address.  */
  54         movq    %rax, %rbp              /* Finalize local stack frame.  */
  55 LUW1:
  56         movq    %rdi, %r10              /* Save a copy of the register area. */
  57         movq    %r8, %r11               /* Save a copy of the target fn.  */
  58         movl    %r9d, %eax              /* Set number of SSE registers.  */
  59
  60         /* Load up all argument registers.  */
  61         movq    (%r10), %rdi
  62         movq    8(%r10), %rsi
  63         movq    16(%r10), %rdx
  64         movq    24(%r10), %rcx
  65         movq    32(%r10), %r8
  66         movq    40(%r10), %r9
  67         testl   %eax, %eax
  68         jnz     Lload_sse
  69 Lret_from_load_sse:
  70
  71         /* Deallocate the reg arg area.  */
  72         leaq    176(%r10), %rsp
  73
  74         /* Call the user function.  */
  75         call    *%r11
  76
  77         /* Deallocate stack arg area; local stack frame in redzone.  */
  78         leaq    24(%rbp), %rsp
  79
  80         movq    0(%rbp), %rcx           /* Reload flags.  */
  81         movq    8(%rbp), %rdi           /* Reload raddr.  */
  82         movq    16(%rbp), %rbp          /* Reload old frame pointer.  */
  83 LUW2:
  84
  85         /* The first byte of the flags contains the FFI_TYPE.  */
  86         movzbl  %cl, %r10d
  87         leaq    Lstore_table(%rip), %r11
  88         movslq  (%r11, %r10, 4), %r10
  89         addq    %r11, %r10
  90         jmp     *%r10
  91
  92 Lstore_table:
  93         .long   Lst_void-Lstore_table           /* FFI_TYPE_VOID */
  94         .long   Lst_sint32-Lstore_table         /* FFI_TYPE_INT */
  95         .long   Lst_float-Lstore_table          /* FFI_TYPE_FLOAT */
  96         .long   Lst_double-Lstore_table         /* FFI_TYPE_DOUBLE */
  97         .long   Lst_ldouble-Lstore_table        /* FFI_TYPE_LONGDOUBLE */
  98         .long   Lst_uint8-Lstore_table          /* FFI_TYPE_UINT8 */
  99         .long   Lst_sint8-Lstore_table          /* FFI_TYPE_SINT8 */
 100         .long   Lst_uint16-Lstore_table         /* FFI_TYPE_UINT16 */
 101         .long   Lst_sint16-Lstore_table         /* FFI_TYPE_SINT16 */
 102         .long   Lst_uint32-Lstore_table         /* FFI_TYPE_UINT32 */
 103         .long   Lst_sint32-Lstore_table         /* FFI_TYPE_SINT32 */
 104         .long   Lst_int64-Lstore_table          /* FFI_TYPE_UINT64 */
 105         .long   Lst_int64-Lstore_table          /* FFI_TYPE_SINT64 */
 106         .long   Lst_struct-Lstore_table         /* FFI_TYPE_STRUCT */
 107         .long   Lst_int64-Lstore_table          /* FFI_TYPE_POINTER */
 108
 109         .text
 110         .align  3
 111 Lst_void:
 112         ret
 113         .align  3
 114 Lst_uint8:
 115         movzbq  %al, %rax
 116         movq    %rax, (%rdi)
 117         ret
 118         .align  3
 119 Lst_sint8:
 120         movsbq  %al, %rax
 121         movq    %rax, (%rdi)
 122         ret
 123         .align  3
 124 Lst_uint16:
 125         movzwq  %ax, %rax
 126         movq    %rax, (%rdi)
 127         .align  3
 128 Lst_sint16:
 129         movswq  %ax, %rax
 130         movq    %rax, (%rdi)
 131         ret
 132         .align  3
 133 Lst_uint32:
 134         movl    %eax, %eax
 135         movq    %rax, (%rdi)
 136         .align  3
 137 Lst_sint32:
 138         cltq
 139         movq    %rax, (%rdi)
 140         ret
 141         .align  3
 142 Lst_int64:
 143         movq    %rax, (%rdi)
 144         ret
 145         .align  3
 146 Lst_float:
 147         movss   %xmm0, (%rdi)
 148         ret
 149         .align  3
 150 Lst_double:
 151         movsd   %xmm0, (%rdi)
 152         ret
 153 Lst_ldouble:
 154         fstpt   (%rdi)
 155         ret
 156         .align  3
 157 Lst_struct:
 158         leaq    -20(%rsp), %rsi         /* Scratch area in redzone.  */
 159
 160         /* We have to locate the values now, and since we don't want to
 161            write too much data into the user's return value, we spill the
 162            value to a 16 byte scratch area first.  Bits 8, 9, and 10
 163            control where the values are located.  Only one of the three
 164            bits will be set; see ffi_prep_cif_machdep for the pattern.  */
 165         movd    %xmm0, %r10
 166         movd    %xmm1, %r11
 167         testl   $0x100, %ecx
 168         cmovnz  %rax, %rdx
 169         cmovnz  %r10, %rax
 170         testl   $0x200, %ecx
 171         cmovnz  %r10, %rdx
 172         testl   $0x400, %ecx
 173         cmovnz  %r10, %rax
 174         cmovnz  %r11, %rdx
 175         movq    %rax, (%rsi)
 176         movq    %rdx, 8(%rsi)
 177
 178         /* Bits 12-31 contain the true size of the structure.  Copy from
 179            the scratch area to the true destination.  */
 180         shrl    $12, %ecx
 181         rep movsb
 182         ret
 183
 184         /* Many times we can avoid loading any SSE registers at all.
 185            It's not worth an indirect jump to load the exact set of
 186            SSE registers needed; zero or all is a good compromise.  */
 187         .align  3
 188 LUW3:
 189 Lload_sse:
 190         movdqa  48(%r10), %xmm0
 191         movdqa  64(%r10), %xmm1
 192         movdqa  80(%r10), %xmm2
 193         movdqa  96(%r10), %xmm3
 194         movdqa  112(%r10), %xmm4
 195         movdqa  128(%r10), %xmm5
 196         movdqa  144(%r10), %xmm6
 197         movdqa  160(%r10), %xmm7
 198         jmp     Lret_from_load_sse
 199
 200 LUW4:
 201         .align  3
 202         .globl  _ffi_closure_unix64
 203
 204 _ffi_closure_unix64:
 205 LUW5:
 206         /* The carry flag is set by the trampoline iff SSE registers
 207            are used.  Don't clobber it before the branch instruction.  */
 208         leaq    -200(%rsp), %rsp
 209 LUW6:
 210         movq    %rdi, (%rsp)
 211         movq    %rsi, 8(%rsp)
 212         movq    %rdx, 16(%rsp)
 213         movq    %rcx, 24(%rsp)
 214         movq    %r8, 32(%rsp)
 215         movq    %r9, 40(%rsp)
 216         jc      Lsave_sse
 217 Lret_from_save_sse:
 218
 219         movq    %r10, %rdi
 220         leaq    176(%rsp), %rsi
 221         movq    %rsp, %rdx
 222         leaq    208(%rsp), %rcx
 223         call    _ffi_closure_unix64_inner
 224
 225         /* Deallocate stack frame early; return value is now in redzone.  */
 226         addq    $200, %rsp
 227 LUW7:
 228
 229         /* The first byte of the return value contains the FFI_TYPE.  */
 230         movzbl  %al, %r10d
 231         leaq    Lload_table(%rip), %r11
 232         movslq  (%r11, %r10, 4), %r10
 233         addq    %r11, %r10
 234         jmp     *%r10
 235
 236 Lload_table:
 237         .long   Lld_void-Lload_table            /* FFI_TYPE_VOID */
 238         .long   Lld_int32-Lload_table           /* FFI_TYPE_INT */
 239         .long   Lld_float-Lload_table           /* FFI_TYPE_FLOAT */
 240         .long   Lld_double-Lload_table          /* FFI_TYPE_DOUBLE */
 241         .long   Lld_ldouble-Lload_table         /* FFI_TYPE_LONGDOUBLE */
 242         .long   Lld_int8-Lload_table            /* FFI_TYPE_UINT8 */
 243         .long   Lld_int8-Lload_table            /* FFI_TYPE_SINT8 */
 244         .long   Lld_int16-Lload_table           /* FFI_TYPE_UINT16 */
 245         .long   Lld_int16-Lload_table           /* FFI_TYPE_SINT16 */
 246         .long   Lld_int32-Lload_table           /* FFI_TYPE_UINT32 */
 247         .long   Lld_int32-Lload_table           /* FFI_TYPE_SINT32 */
 248         .long   Lld_int64-Lload_table           /* FFI_TYPE_UINT64 */
 249         .long   Lld_int64-Lload_table           /* FFI_TYPE_SINT64 */
 250         .long   Lld_struct-Lload_table          /* FFI_TYPE_STRUCT */
 251         .long   Lld_int64-Lload_table           /* FFI_TYPE_POINTER */
 252
 253         .text
 254         .align  3
 255 Lld_void:
 256         ret
 257         .align  3
 258 Lld_int8:
 259         movzbl  -24(%rsp), %eax
 260         ret
 261         .align  3
 262 Lld_int16:
 263         movzwl  -24(%rsp), %eax
 264         ret
 265         .align  3
 266 Lld_int32:
 267         movl    -24(%rsp), %eax
 268         ret
 269         .align  3
 270 Lld_int64:
 271         movq    -24(%rsp), %rax
 272         ret
 273         .align  3
 274 Lld_float:
 275         movss   -24(%rsp), %xmm0
 276         ret
 277         .align  3
 278 Lld_double:
 279         movsd   -24(%rsp), %xmm0
 280         ret
 281         .align  3
 282 Lld_ldouble:
 283         fldt    -24(%rsp)
 284         ret
 285         .align  3
 286 Lld_struct:
 287         /* There are four possibilities here, %rax/%rdx, %xmm0/%rax,
 288            %rax/%xmm0, %xmm0/%xmm1.  We collapse two by always loading
 289            both rdx and xmm1 with the second word.  For the remaining,
 290            bit 8 set means xmm0 gets the second word, and bit 9 means
 291            that rax gets the second word.  */
 292         movq    -24(%rsp), %rcx
 293         movq    -16(%rsp), %rdx
 294         movq    -16(%rsp), %xmm1
 295         testl   $0x100, %eax
 296         cmovnz  %rdx, %rcx
 297         movd    %rcx, %xmm0
 298         testl   $0x200, %eax
 299         movq    -24(%rsp), %rax
 300         cmovnz  %rdx, %rax
 301         ret
 302
 303         /* See the comment above Lload_sse; the same logic applies here.  */
 304         .align  3
 305 LUW8:
 306 Lsave_sse:
 307         movdqa  %xmm0, 48(%rsp)
 308         movdqa  %xmm1, 64(%rsp)
 309         movdqa  %xmm2, 80(%rsp)
 310         movdqa  %xmm3, 96(%rsp)
 311         movdqa  %xmm4, 112(%rsp)
 312         movdqa  %xmm5, 128(%rsp)
 313         movdqa  %xmm6, 144(%rsp)
 314         movdqa  %xmm7, 160(%rsp)
 315         jmp     Lret_from_save_sse
 316
 317 LUW9:
 318 .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
 319 EH_frame1:
 320         .set    L$set$0,LECIE1-LSCIE1           /* CIE Length */
 321         .long   L$set$0
 322 LSCIE1:
 323         .long   0x0             /* CIE Identifier Tag */
 324         .byte   0x1             /* CIE Version */
 325         .ascii  "zR\0"          /* CIE Augmentation */
 326         .byte   0x1             /* uleb128 0x1; CIE Code Alignment Factor */
 327         .byte   0x78            /* sleb128 -8; CIE Data Alignment Factor */
 328         .byte   0x10            /* CIE RA Column */
 329         .byte   0x1             /* uleb128 0x1; Augmentation size */
 330         .byte   0x10            /* FDE Encoding (pcrel sdata4) */
 331         .byte   0xc             /* DW_CFA_def_cfa, %rsp offset 8 */
 332         .byte   0x7             /* uleb128 0x7 */
 333         .byte   0x8             /* uleb128 0x8 */
 334         .byte   0x90            /* DW_CFA_offset, column 0x10 */
 335         .byte   0x1
 336         .align  3
 337 LECIE1:
 338         .globl _ffi_call_unix64.eh
 339 _ffi_call_unix64.eh:
 340 LSFDE1:
 341         .set    L$set$1,LEFDE1-LASFDE1  /* FDE Length */
 342         .long   L$set$1
 343 LASFDE1:
 344         .long   LASFDE1-EH_frame1       /* FDE CIE offset */
 345         .quad   LUW0-.                  /* FDE initial location */
 346         .set    L$set$2,LUW4-LUW0       /* FDE address range */
 347         .quad   L$set$2
 348         .byte   0x0                     /* Augmentation size */
 349         .byte   0x4                     /* DW_CFA_advance_loc4 */
 350         .set    L$set$3,LUW1-LUW0
 351         .long   L$set$3
 352
 353         /* New stack frame based off rbp.  This is a itty bit of unwind
 354            trickery in that the CFA *has* changed.  There is no easy way
 355            to describe it correctly on entry to the function.  Fortunately,
 356            it doesn't matter too much since at all points we can correctly
 357            unwind back to ffi_call.  Note that the location to which we
 358            moved the return address is (the new) CFA-8, so from the
 359            perspective of the unwind info, it hasn't moved.  */
 360         .byte   0xc                     /* DW_CFA_def_cfa, %rbp offset 32 */
 361         .byte   0x6
 362         .byte   0x20
 363         .byte   0x80+6                  /* DW_CFA_offset, %rbp offset 2*-8 */
 364         .byte   0x2
 365         .byte   0xa                     /* DW_CFA_remember_state */
 366
 367         .byte   0x4                     /* DW_CFA_advance_loc4 */
 368         .set    L$set$4,LUW2-LUW1
 369         .long   L$set$4
 370         .byte   0xc                     /* DW_CFA_def_cfa, %rsp offset 8 */
 371         .byte   0x7
 372         .byte   0x8
 373         .byte   0xc0+6                  /* DW_CFA_restore, %rbp */
 374
 375         .byte   0x4                     /* DW_CFA_advance_loc4 */
 376         .set    L$set$5,LUW3-LUW2
 377         .long   L$set$5
 378         .byte   0xb                     /* DW_CFA_restore_state */
 379
 380         .align  3
 381 LEFDE1:
 382         .globl _ffi_closure_unix64.eh
 383 _ffi_closure_unix64.eh:
 384 LSFDE3:
 385         .set    L$set$6,LEFDE3-LASFDE3  /* FDE Length */
 386         .long   L$set$6
 387 LASFDE3:
 388         .long   LASFDE3-EH_frame1       /* FDE CIE offset */
 389         .quad   LUW5-.                  /* FDE initial location */
 390         .set    L$set$7,LUW9-LUW5       /* FDE address range */
 391         .quad   L$set$7
 392         .byte   0x0                     /* Augmentation size */
 393
 394         .byte   0x4                     /* DW_CFA_advance_loc4 */
 395         .set    L$set$8,LUW6-LUW5
 396         .long   L$set$8
 397         .byte   0xe                     /* DW_CFA_def_cfa_offset */
 398         .byte   208,1                   /* uleb128 208 */
 399         .byte   0xa                     /* DW_CFA_remember_state */
 400
 401         .byte   0x4                     /* DW_CFA_advance_loc4 */
 402         .set    L$set$9,LUW7-LUW6
 403         .long   L$set$9
 404         .byte   0xe                     /* DW_CFA_def_cfa_offset */
 405         .byte   0x8
 406
 407         .byte   0x4                     /* DW_CFA_advance_loc4 */
 408         .set    L$set$10,LUW8-LUW7
 409         .long   L$set$10
 410         .byte   0xb                     /* DW_CFA_restore_state */
 411
 412         .align  3
 413 LEFDE3:
 414         .subsections_via_symbols
 415
 416 #endif /* __x86_64__ */