mirror of
https://github.com/partic2/libffi
synced 2026-11-10 01:57:19 +00:00
Richard Henderson
b21ec1ce78
Move everything into sysv.S, removing win32.S and freebsd.S. Handle all abis with a single ffi_closure_inner function. Move complexity of the raw THISCALL trampoline into assembly instead of the trampoline itself. Only push the context for the REGISTER abi; let the rest receive it in a register.
649 lines
14 KiB
ArmAsm
649 lines
14 KiB
ArmAsm
/* -----------------------------------------------------------------------
|
|
sysv.S - Copyright (c) 2013 The Written Word, Inc.
|
|
- Copyright (c) 1996,1998,2001-2003,2005,2008,2010 Red Hat, Inc.
|
|
|
|
X86 Foreign Function Interface
|
|
|
|
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 AUTHORS OR COPYRIGHT
|
|
HOLDERS 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.
|
|
----------------------------------------------------------------------- */
|
|
|
|
#ifndef __x86_64__
|
|
|
|
#define LIBFFI_ASM
|
|
#include <fficonfig.h>
|
|
#include <ffi.h>
|
|
#include <ffi_cfi.h>
|
|
#include "internal.h"
|
|
|
|
#define C2(X, Y) X ## Y
|
|
#define C1(X, Y) C2(X, Y)
|
|
#ifdef __USER_LABEL_PREFIX__
|
|
# define C(X) C1(__USER_LABEL_PREFIX__, X)
|
|
#else
|
|
# define C(X) X
|
|
#endif
|
|
|
|
#ifdef __ELF__
|
|
# define ENDF(X) .type X,@function; .size X, . - X
|
|
#else
|
|
# define ENDF(X)
|
|
#endif
|
|
|
|
/* This macro allows the safe creation of jump tables without an
|
|
actual table. The entry points into the table are all 8 bytes.
|
|
The use of ORG asserts that we're at the correct location. */
|
|
#define E(X) .align 8; .org 0b + X * 8
|
|
|
|
.text
|
|
.align 16
|
|
.globl C(ffi_call_i386)
|
|
FFI_HIDDEN(C(ffi_call_i386))
|
|
|
|
/* This is declared as
|
|
|
|
void ffi_call_i386(struct call_frame *frame, char *argp)
|
|
__attribute__((fastcall));
|
|
|
|
Thus the arguments are present in
|
|
|
|
ecx: frame
|
|
edx: argp
|
|
*/
|
|
|
|
C(ffi_call_i386):
|
|
cfi_startproc
|
|
movl (%esp), %eax /* move the return address */
|
|
movl %ebp, (%ecx) /* store %ebp into local frame */
|
|
movl %eax, 4(%ecx) /* store retaddr into local frame */
|
|
|
|
/* New stack frame based off ebp. 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-4, so from the
|
|
perspective of the unwind info, it hasn't moved. */
|
|
movl %ecx, %ebp
|
|
cfi_def_cfa(%ebp, 8)
|
|
cfi_rel_offset(%ebp, 0)
|
|
|
|
movl %edx, %esp /* set outgoing argument stack */
|
|
movl 20+R_EAX*4(%ebp), %eax /* set register arguments */
|
|
movl 20+R_EDX*4(%ebp), %edx
|
|
movl 20+R_ECX*4(%ebp), %ecx
|
|
|
|
call *8(%ebp)
|
|
|
|
movl 12(%ebp), %ecx /* load return type code */
|
|
movl %ebx, 8(%ebp) /* preserve %ebx */
|
|
cfi_rel_offset(%ebp, 8)
|
|
|
|
andl $X86_RET_TYPE_MASK, %ecx
|
|
#ifdef __PIC__
|
|
call __x86.get_pc_thunk.bx
|
|
1: leal 0f-1b(%ebx, %ecx, 8), %ebx
|
|
#else
|
|
leal 0f(,%ecx, 8), %ebx
|
|
#endif
|
|
movl 16(%ebp), %ecx /* load result address */
|
|
jmp *%ebx
|
|
|
|
.align 8
|
|
0:
|
|
E(X86_RET_FLOAT)
|
|
fstps (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_DOUBLE)
|
|
fstpl (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_LDOUBLE)
|
|
fstpt (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_SINT8)
|
|
movsbl %al, %eax
|
|
mov %eax, (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_SINT16)
|
|
movswl %ax, %eax
|
|
mov %eax, (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_UINT8)
|
|
movzbl %al, %eax
|
|
mov %eax, (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_UINT16)
|
|
movzwl %ax, %eax
|
|
mov %eax, (%ecx)
|
|
jmp 9f
|
|
E(X86_RET_INT64)
|
|
movl %edx, 4(%ecx)
|
|
/* fallthru */
|
|
E(X86_RET_INT32)
|
|
movl %eax, (%ecx)
|
|
/* fallthru */
|
|
E(X86_RET_VOID)
|
|
9: movl 8(%ebp), %ebx
|
|
movl %ebp, %esp
|
|
popl %ebp
|
|
cfi_remember_state
|
|
cfi_def_cfa(%esp, 4)
|
|
cfi_restore(%ebx)
|
|
cfi_restore(%ebp)
|
|
ret
|
|
cfi_restore_state
|
|
|
|
E(X86_RET_STRUCTPOP)
|
|
jmp 9b
|
|
E(X86_RET_STRUCTARG)
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_1B)
|
|
movb %al, (%ecx)
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_2B)
|
|
movw %ax, (%ecx)
|
|
jmp 9b
|
|
|
|
/* Fill out the table so that bad values are predictable. */
|
|
E(X86_RET_UNUSED14)
|
|
ud2
|
|
E(X86_RET_UNUSED15)
|
|
ud2
|
|
|
|
cfi_endproc
|
|
ENDF(C(ffi_call_i386))
|
|
|
|
/* The inner helper is declared as
|
|
|
|
void ffi_closure_inner(struct closure_frame *frame, char *argp)
|
|
__attribute_((fastcall))
|
|
|
|
Thus the arguments are placed in
|
|
|
|
ecx: frame
|
|
edx: argp
|
|
*/
|
|
|
|
/* Macros to help setting up the closure_data structure. */
|
|
|
|
#define closure_FS (16 + 3*4 + 3*4 + 4)
|
|
|
|
.macro FFI_CLOSURE_SAVE_REGS
|
|
movl %eax, 16+R_EAX*4(%esp)
|
|
movl %edx, 16+R_EDX*4(%esp)
|
|
movl %ecx, 16+R_ECX*4(%esp)
|
|
.endm
|
|
|
|
.macro FFI_CLOSURE_COPY_TRAMP_DATA chain
|
|
movl FFI_TRAMPOLINE_SIZE(%eax), %edx /* copy cif */
|
|
movl FFI_TRAMPOLINE_SIZE+4(%eax), %ecx /* copy fun */
|
|
movl FFI_TRAMPOLINE_SIZE+8(%eax), %eax /* copy user_data */
|
|
movl %edx, 28(%esp)
|
|
movl %ecx, 32(%esp)
|
|
movl %eax, 36(%esp)
|
|
.endm
|
|
|
|
.macro FFI_CLOSURE_CALL_INNER
|
|
movl %esp, %ecx /* load closure_data */
|
|
leal closure_FS+4(%esp), %edx /* load incoming stack */
|
|
#ifdef __PIC__
|
|
movl %ebx, 40(%esp) /* save ebx */
|
|
cfi_rel_offset(%ebx, 40)
|
|
call __x86.get_pc_thunk.bx /* load got register */
|
|
addl $C(_GLOBAL_OFFSET_TABLE_), %ebx
|
|
#endif
|
|
#if defined HAVE_HIDDEN_VISIBILITY_ATTRIBUTE || !defined __PIC__
|
|
call C(ffi_closure_inner)
|
|
#else
|
|
call C(ffi_closure_inner)@PLT
|
|
#endif
|
|
.endm
|
|
|
|
.macro FFI_CLOSURE_MASK_AND_JUMP
|
|
andl $X86_RET_TYPE_MASK, %eax
|
|
#ifdef __PIC__
|
|
leal 0f@GOTOFF(%ebx, %eax, 8), %eax
|
|
movl 40(%esp), %ebx /* restore ebx */
|
|
cfi_restore(%ebx)
|
|
#else
|
|
leal 0f(, %eax, 8), %eax
|
|
#endif
|
|
jmp *%eax
|
|
.endm
|
|
|
|
/* The closure entry points are reached from the ffi_closure trampoline.
|
|
On entry, %eax contains the address of the ffi_closure. */
|
|
|
|
.align 16
|
|
.globl C(ffi_closure_i386)
|
|
FFI_HIDDEN(C(ffi_closure_i386))
|
|
|
|
C(ffi_closure_i386):
|
|
cfi_startproc
|
|
subl $closure_FS, %esp
|
|
cfi_adjust_cfa_offset(closure_FS)
|
|
|
|
FFI_CLOSURE_SAVE_REGS
|
|
FFI_CLOSURE_COPY_TRAMP_DATA
|
|
FFI_CLOSURE_CALL_INNER
|
|
FFI_CLOSURE_MASK_AND_JUMP
|
|
|
|
.align 8
|
|
0:
|
|
E(X86_RET_FLOAT)
|
|
flds (%esp)
|
|
jmp 9f
|
|
E(X86_RET_DOUBLE)
|
|
fldl (%esp)
|
|
jmp 9f
|
|
E(X86_RET_LDOUBLE)
|
|
fldt (%esp)
|
|
jmp 9f
|
|
E(X86_RET_SINT8)
|
|
movsbl (%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_SINT16)
|
|
movswl (%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_UINT8)
|
|
movzbl (%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_UINT16)
|
|
movzwl (%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_INT64)
|
|
movl 4(%esp), %edx
|
|
/* fallthru */
|
|
E(X86_RET_INT32)
|
|
movl (%esp), %eax
|
|
/* fallthru */
|
|
E(X86_RET_VOID)
|
|
9: addl $closure_FS, %esp
|
|
cfi_adjust_cfa_offset(-closure_FS)
|
|
ret
|
|
cfi_adjust_cfa_offset(closure_FS)
|
|
E(X86_RET_STRUCTPOP)
|
|
addl $closure_FS, %esp
|
|
cfi_adjust_cfa_offset(-closure_FS)
|
|
ret $4
|
|
cfi_adjust_cfa_offset(closure_FS)
|
|
E(X86_RET_STRUCTARG)
|
|
movl (%esp), %eax
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_1B)
|
|
movzbl (%esp), %eax
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_2B)
|
|
movzwl (%esp), %eax
|
|
jmp 9b
|
|
|
|
/* Fill out the table so that bad values are predictable. */
|
|
E(X86_RET_UNUSED14)
|
|
ud2
|
|
E(X86_RET_UNUSED15)
|
|
ud2
|
|
|
|
cfi_endproc
|
|
ENDF(C(ffi_closure_i386))
|
|
|
|
/* For REGISTER, we have no available parameter registers, and so we
|
|
enter here having pushed the closure onto the stack. */
|
|
|
|
.align 16
|
|
.globl C(ffi_closure_REGISTER)
|
|
FFI_HIDDEN(C(ffi_closure_REGISTER))
|
|
C(ffi_closure_REGISTER):
|
|
cfi_startproc
|
|
cfi_def_cfa(%esp, 8)
|
|
cfi_offset(%eip, -8)
|
|
subl $closure_FS-4, %esp
|
|
cfi_adjust_cfa_offset(closure_FS-4)
|
|
|
|
FFI_CLOSURE_SAVE_REGS
|
|
|
|
movl closure_FS-4(%esp), %ecx /* load retaddr */
|
|
movl closure_FS(%esp), %eax /* load closure */
|
|
movl %ecx, closure_FS(%esp) /* move retaddr */
|
|
jmp 0f
|
|
|
|
cfi_endproc
|
|
ENDF(C(ffi_closure_REGISTER))
|
|
|
|
/* For STDCALL (and others), we need to pop N bytes of arguments off
|
|
the stack following the closure. The amount needing to be popped
|
|
is returned to us from ffi_closure_inner. */
|
|
|
|
.align 16
|
|
.globl C(ffi_closure_STDCALL)
|
|
FFI_HIDDEN(C(ffi_closure_STDCALL))
|
|
C(ffi_closure_STDCALL):
|
|
cfi_startproc
|
|
subl $closure_FS, %esp
|
|
cfi_adjust_cfa_offset(closure_FS)
|
|
|
|
FFI_CLOSURE_SAVE_REGS
|
|
0:
|
|
FFI_CLOSURE_COPY_TRAMP_DATA
|
|
FFI_CLOSURE_CALL_INNER
|
|
|
|
movl %eax, %ecx
|
|
shrl $X86_RET_POP_SHIFT, %ecx /* isolate pop count */
|
|
leal closure_FS(%esp, %ecx), %ecx /* compute popped esp */
|
|
movl closure_FS(%esp), %edx /* move return address */
|
|
movl %edx, (%ecx)
|
|
|
|
/* New pseudo-stack frame based off ecx. This is unwind trickery
|
|
in that the CFA *has* changed, to the proper popped stack address.
|
|
Note that the location to which we moved the return address
|
|
is the new CFA-4, so that's unchanged. */
|
|
cfi_def_cfa(%ecx, 4)
|
|
/* Normally esp is unwound to CFA + the caller's ARGS_SIZE.
|
|
We've just set the CFA to that final value. Tell the unwinder
|
|
to restore esp from CFA without the ARGS_SIZE:
|
|
DW_CFA_val_expression %esp, DW_OP_call_frame_cfa. */
|
|
cfi_escape(0x16, 4, 1, 0x9c)
|
|
|
|
FFI_CLOSURE_MASK_AND_JUMP
|
|
|
|
.align 8
|
|
0:
|
|
E(X86_RET_FLOAT)
|
|
flds (%esp)
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_DOUBLE)
|
|
fldl (%esp)
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_LDOUBLE)
|
|
fldt (%esp)
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_SINT8)
|
|
movsbl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_SINT16)
|
|
movswl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_UINT8)
|
|
movzbl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_UINT16)
|
|
movzwl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_INT64)
|
|
popl %eax
|
|
popl %edx
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_INT32)
|
|
movl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_VOID)
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_STRUCTPOP)
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_STRUCTARG)
|
|
movl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_STRUCT_1B)
|
|
movzbl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
E(X86_RET_STRUCT_2B)
|
|
movzwl (%esp), %eax
|
|
movl %ecx, %esp
|
|
ret
|
|
|
|
/* Fill out the table so that bad values are predictable. */
|
|
E(X86_RET_UNUSED14)
|
|
ud2
|
|
E(X86_RET_UNUSED15)
|
|
ud2
|
|
|
|
cfi_endproc
|
|
ENDF(C(ffi_closure_STDCALL))
|
|
|
|
#if !FFI_NO_RAW_API
|
|
|
|
#define raw_closure_S_FS (16+16+12)
|
|
|
|
.align 16
|
|
.globl C(ffi_closure_raw_SYSV)
|
|
FFI_HIDDEN(C(ffi_closure_raw_SYSV))
|
|
C(ffi_closure_raw_SYSV):
|
|
cfi_startproc
|
|
subl $raw_closure_S_FS, %esp
|
|
cfi_adjust_cfa_offset(raw_closure_S_FS)
|
|
movl %ebx, raw_closure_S_FS-4(%esp)
|
|
cfi_rel_offset(%ebx, raw_closure_S_FS-4)
|
|
|
|
movl FFI_TRAMPOLINE_SIZE+8(%eax), %edx /* load cl->user_data */
|
|
movl %edx, 12(%esp)
|
|
leal raw_closure_S_FS+4(%esp), %edx /* load raw_args */
|
|
movl %edx, 8(%esp)
|
|
leal 16(%esp), %edx /* load &res */
|
|
movl %edx, 4(%esp)
|
|
movl FFI_TRAMPOLINE_SIZE(%eax), %ebx /* load cl->cif */
|
|
movl %ebx, (%esp)
|
|
call *FFI_TRAMPOLINE_SIZE+4(%eax) /* call cl->fun */
|
|
|
|
movl 20(%ebx), %eax /* load cif->flags */
|
|
andl $X86_RET_TYPE_MASK, %eax
|
|
#ifdef __PIC__
|
|
call __x86.get_pc_thunk.bx
|
|
1: leal 0f-1b(%ebx, %eax, 8), %eax
|
|
#else
|
|
leal 0f(,%eax, 8), %eax
|
|
#endif
|
|
movl raw_closure_S_FS-4(%esp), %ebx
|
|
cfi_restore(%ebx)
|
|
jmp *%eax
|
|
|
|
.align 8
|
|
0:
|
|
E(X86_RET_FLOAT)
|
|
flds 16(%esp)
|
|
jmp 9f
|
|
E(X86_RET_DOUBLE)
|
|
fldl 16(%esp)
|
|
jmp 9f
|
|
E(X86_RET_LDOUBLE)
|
|
fldt 16(%esp)
|
|
jmp 9f
|
|
E(X86_RET_SINT8)
|
|
movsbl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_SINT16)
|
|
movswl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_UINT8)
|
|
movzbl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_UINT16)
|
|
movzwl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_INT64)
|
|
movl 16+4(%esp), %edx
|
|
/* fallthru */
|
|
E(X86_RET_INT32)
|
|
movl 16(%esp), %eax
|
|
/* fallthru */
|
|
E(X86_RET_VOID)
|
|
9: addl $raw_closure_S_FS, %esp
|
|
cfi_adjust_cfa_offset(-raw_closure_S_FS)
|
|
ret
|
|
cfi_adjust_cfa_offset(raw_closure_S_FS)
|
|
E(X86_RET_STRUCTPOP)
|
|
addl $raw_closure_S_FS, %esp
|
|
cfi_adjust_cfa_offset(-raw_closure_S_FS)
|
|
ret $4
|
|
cfi_adjust_cfa_offset(raw_closure_S_FS)
|
|
E(X86_RET_STRUCTARG)
|
|
movl 16(%esp), %eax
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_1B)
|
|
movzbl 16(%esp), %eax
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_2B)
|
|
movzwl 16(%esp), %eax
|
|
jmp 9b
|
|
|
|
/* Fill out the table so that bad values are predictable. */
|
|
E(X86_RET_UNUSED14)
|
|
ud2
|
|
E(X86_RET_UNUSED15)
|
|
ud2
|
|
|
|
cfi_endproc
|
|
ENDF(C(ffi_closure_raw_SYSV))
|
|
|
|
#undef raw_closure_S_FS
|
|
#define raw_closure_T_FS (16+16+8)
|
|
|
|
.align 16
|
|
.globl C(ffi_closure_raw_THISCALL)
|
|
FFI_HIDDEN(C(ffi_closure_raw_THISCALL))
|
|
C(ffi_closure_raw_THISCALL):
|
|
cfi_startproc
|
|
/* Rearrange the stack such that %ecx is the first argument.
|
|
This means moving the return address. */
|
|
popl %edx
|
|
cfi_adjust_cfa_offset(-4)
|
|
cfi_register(%eip, %edx)
|
|
pushl %ecx
|
|
cfi_adjust_cfa_offset(4)
|
|
pushl %edx
|
|
cfi_adjust_cfa_offset(4)
|
|
cfi_rel_offset(%eip, 0)
|
|
subl $raw_closure_T_FS, %esp
|
|
cfi_adjust_cfa_offset(raw_closure_T_FS)
|
|
movl %ebx, raw_closure_T_FS-4(%esp)
|
|
cfi_offset(%ebx, raw_closure_T_FS-4)
|
|
|
|
movl FFI_TRAMPOLINE_SIZE+8(%eax), %edx /* load cl->user_data */
|
|
movl %edx, 12(%esp)
|
|
leal raw_closure_T_FS+4(%esp), %edx /* load raw_args */
|
|
movl %edx, 8(%esp)
|
|
leal 16(%esp), %edx /* load &res */
|
|
movl %edx, 4(%esp)
|
|
movl FFI_TRAMPOLINE_SIZE(%eax), %ebx /* load cl->cif */
|
|
movl %ebx, (%esp)
|
|
call *FFI_TRAMPOLINE_SIZE+4(%eax) /* call cl->fun */
|
|
|
|
movl 20(%ebx), %eax /* load cif->flags */
|
|
andl $X86_RET_TYPE_MASK, %eax
|
|
#ifdef __PIC__
|
|
call __x86.get_pc_thunk.bx
|
|
1: leal 0f-1b(%ebx, %eax, 8), %eax
|
|
#else
|
|
leal 0f(,%eax, 8), %eax
|
|
#endif
|
|
movl raw_closure_T_FS-4(%esp), %ebx
|
|
cfi_restore(%ebx)
|
|
jmp *%eax
|
|
|
|
.align 8
|
|
0:
|
|
E(X86_RET_FLOAT)
|
|
flds 16(%esp)
|
|
jmp 9f
|
|
E(X86_RET_DOUBLE)
|
|
fldl 16(%esp)
|
|
jmp 9f
|
|
E(X86_RET_LDOUBLE)
|
|
fldt 16(%esp)
|
|
jmp 9f
|
|
E(X86_RET_SINT8)
|
|
movsbl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_SINT16)
|
|
movswl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_UINT8)
|
|
movzbl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_UINT16)
|
|
movzwl 16(%esp), %eax
|
|
jmp 9f
|
|
E(X86_RET_INT64)
|
|
movl 16+4(%esp), %edx
|
|
/* fallthru */
|
|
E(X86_RET_INT32)
|
|
movl 16(%esp), %eax
|
|
/* fallthru */
|
|
E(X86_RET_VOID)
|
|
9: addl $raw_closure_T_FS, %esp
|
|
cfi_adjust_cfa_offset(-raw_closure_T_FS)
|
|
/* Remove the extra %ecx argument we pushed. */
|
|
ret $4
|
|
cfi_adjust_cfa_offset(raw_closure_T_FS)
|
|
E(X86_RET_STRUCTPOP)
|
|
addl $raw_closure_T_FS, %esp
|
|
cfi_adjust_cfa_offset(-raw_closure_T_FS)
|
|
ret $8
|
|
cfi_adjust_cfa_offset(raw_closure_T_FS)
|
|
E(X86_RET_STRUCTARG)
|
|
movl 16(%esp), %eax
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_1B)
|
|
movzbl 16(%esp), %eax
|
|
jmp 9b
|
|
E(X86_RET_STRUCT_2B)
|
|
movzwl 16(%esp), %eax
|
|
jmp 9b
|
|
|
|
/* Fill out the table so that bad values are predictable. */
|
|
E(X86_RET_UNUSED14)
|
|
ud2
|
|
E(X86_RET_UNUSED15)
|
|
ud2
|
|
|
|
cfi_endproc
|
|
ENDF(C(ffi_closure_raw_THISCALL))
|
|
|
|
#endif /* !FFI_NO_RAW_API */
|
|
|
|
#if defined(__PIC__)
|
|
.section .text.__x86.get_pc_thunk.bx,"axG",@progbits,__x86.get_pc_thunk.bx,comdat
|
|
.globl __x86.get_pc_thunk.bx
|
|
.hidden __x86.get_pc_thunk.bx
|
|
.type __x86.get_pc_thunk.bx,@function
|
|
__x86.get_pc_thunk.bx:
|
|
cfi_startproc
|
|
movl (%esp), %ebx
|
|
ret
|
|
cfi_endproc
|
|
.size __x86.get_pc_thunk.bx, . - __x86.get_pc_thunk.bx
|
|
#endif /* __PIC__ */
|
|
|
|
#endif /* ifndef __x86_64__ */
|
|
#if defined __ELF__ && defined __linux__
|
|
.section .note.GNU-stack,"",@progbits
|
|
#endif
|