/* -----------------------------------------------------------------------
sysv.S - Copyright (c) 2017, 2022 Anthony Green
- 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__
#ifdef _MSC_VER
#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)
#define L(X) C1(L, X)
# define ENDF(X) X ENDP
/* 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. */
/* ??? The clang assembler doesn't handle .org with symbolic expressions. */
#if defined(__clang__) || defined(__APPLE__) || (defined (__sun__) && defined(__svr4__))
# define E(BASE, X) ALIGN 8
#else
# define E(BASE, X) ALIGN 8; ORG BASE + X * 8
#endif
.686P
.MODEL FLAT
EXTRN @ffi_closure_inner@8:PROC
_TEXT SEGMENT
/* 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
*/
ALIGN 16
PUBLIC @ffi_call_i386@8
@ffi_call_i386@8 PROC
L(UW0):
cfi_startproc
#if !HAVE_FASTCALL
mov ecx, [esp+4]
mov edx, [esp+8]
#endif
mov eax, [esp] /* move the return address */
mov [ecx], ebp /* store ebp into local frame */
mov [ecx+4], eax /* 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. */
mov ebp, ecx
L(UW1):
/* cfi_def_cfa(%ebp, 8) */
/* cfi_rel_offset(%ebp, 0) */
mov esp, edx /* set outgoing argument stack */
mov eax, [20+R_EAX*4+ebp] /* set register arguments */
mov edx, [20+R_EDX*4+ebp]
mov ecx, [20+R_ECX*4+ebp]
call dword ptr [ebp+8]
mov ecx, [12+ebp] /* load return type code */
mov [ebp+8], ebx /* preserve %ebx */
L(UW2):
/* cfi_rel_offset(%ebx, 8) */
and ecx, X86_RET_TYPE_MASK
lea ebx, [L(store_table) + ecx * 8]
mov ecx, [ebp+16] /* load result address */
jmp ebx
ALIGN 8
L(store_table):
E(L(store_table), X86_RET_FLOAT)
fstp DWORD PTR [ecx]
jmp L(e1)
E(L(store_table), X86_RET_DOUBLE)
fstp QWORD PTR [ecx]
jmp L(e1)
E(L(store_table), X86_RET_LDOUBLE)
fstp QWORD PTR [ecx]
jmp L(e1)
E(L(store_table), X86_RET_SINT8)
movsx eax, al
mov [ecx], eax
jmp L(e1)
E(L(store_table), X86_RET_SINT16)
movsx eax, ax
mov [ecx], eax
jmp L(e1)
E(L(store_table), X86_RET_UINT8)
movzx eax, al
mov [ecx], eax
jmp L(e1)
E(L(store_table), X86_RET_UINT16)
movzx eax, ax
mov [ecx], eax
jmp L(e1)
E(L(store_table), X86_RET_INT64)
mov [ecx+4], edx
/* fallthru */
E(L(store_table), X86_RET_int 32)
mov [ecx], eax
/* fallthru */
E(L(store_table), X86_RET_VOID)
L(e1):
mov ebx, [ebp+8]
mov esp, ebp
pop ebp
L(UW3):
/* cfi_remember_state */
/* cfi_def_cfa(%esp, 4) */
/* cfi_restore(%ebx) */
/* cfi_restore(%ebp) */
ret
L(UW4):
/* cfi_restore_state */
E(L(store_table), X86_RET_STRUCTPOP)
jmp L(e1)
E(L(store_table), X86_RET_STRUCTARG)
jmp L(e1)
E(L(store_table), X86_RET_STRUCT_1B)
mov [ecx], al
jmp L(e1)
E(L(store_table), X86_RET_STRUCT_2B)
mov [ecx], ax
jmp L(e1)
/* Fill out the table so that bad values are predictable. */
E(L(store_table), X86_RET_UNUSED14)
int 3
E(L(store_table), X86_RET_UNUSED15)
int 3
L(UW5):
/* cfi_endproc */
ENDF(@ffi_call_i386@8)
/* 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. */
#if HAVE_FASTCALL
# define closure_FS (40 + 4)
# define closure_CF 0
#else
# define closure_FS (8 + 40 + 12)
# define closure_CF 8
#endif
FFI_CLOSURE_SAVE_REGS MACRO
mov [esp + closure_CF+16+R_EAX*4], eax
mov [esp + closure_CF+16+R_EDX*4], edx
mov [esp + closure_CF+16+R_ECX*4], ecx
ENDM
FFI_CLOSURE_COPY_TRAMP_DATA MACRO
mov edx, [eax+FFI_TRAMPOLINE_SIZE] /* copy cif */
mov ecx, [eax+FFI_TRAMPOLINE_SIZE+4] /* copy fun */
mov eax, [eax+FFI_TRAMPOLINE_SIZE+8]; /* copy user_data */
mov [esp+closure_CF+28], edx
mov [esp+closure_CF+32], ecx
mov [esp+closure_CF+36], eax
ENDM
#if HAVE_FASTCALL
FFI_CLOSURE_PREP_CALL MACRO
mov ecx, esp /* load closure_data */
lea edx, [esp+closure_FS+4] /* load incoming stack */
ENDM
#else
FFI_CLOSURE_PREP_CALL MACRO
lea ecx, [esp+closure_CF] /* load closure_data */
lea edx, [esp+closure_FS+4] /* load incoming stack */
mov [esp], ecx
mov [esp+4], edx
ENDM
#endif
FFI_CLOSURE_CALL_INNER MACRO UWN
call @ffi_closure_inner@8
ENDM
FFI_CLOSURE_MASK_AND_JUMP MACRO LABEL
and eax, X86_RET_TYPE_MASK
lea edx, [LABEL+eax*8]
mov eax, [esp+closure_CF] /* optimiztic load */
jmp edx
ENDM
ALIGN 16
PUBLIC ffi_go_closure_EAX
ffi_go_closure_EAX PROC C
L(UW6):
/* cfi_startproc */
sub esp, closure_FS
L(UW7):
/* cfi_def_cfa_offset(closure_FS + 4) */
FFI_CLOSURE_SAVE_REGS
mov edx, [eax+4] /* copy cif */
mov ecx, [eax +8] /* copy fun */
mov [esp+closure_CF+28], edx
mov [esp+closure_CF+32], ecx
mov [esp+closure_CF+36], eax /* closure is user_data */
jmp L(do_closure_i386)
L(UW8):
/* cfi_endproc */
ENDF(ffi_go_closure_EAX)
ALIGN 16
PUBLIC ffi_go_closure_ECX
ffi_go_closure_ECX PROC C
L(UW9):
/* cfi_startproc */
sub esp, closure_FS
L(UW10):
/* cfi_def_cfa_offset(closure_FS + 4) */
FFI_CLOSURE_SAVE_REGS
mov edx, [ecx+4] /* copy cif */
mov eax, [ecx+8] /* copy fun */
mov [esp+closure_CF+28], edx
mov [esp+closure_CF+32], eax
mov [esp+closure_CF+36], ecx /* closure is user_data */
jmp L(do_closure_i386)
L(UW11):
/* cfi_endproc */
ENDF(ffi_go_closure_ECX)
/* The closure entry points are reached from the ffi_closure trampoline.
On entry, %eax contains the address of the ffi_closure. */
ALIGN 16
PUBLIC ffi_closure_i386
ffi_closure_i386 PROC C
L(UW12):
/* cfi_startproc */
sub esp, closure_FS
L(UW13):
/* cfi_def_cfa_offset(closure_FS + 4) */
FFI_CLOSURE_SAVE_REGS
FFI_CLOSURE_COPY_TRAMP_DATA
/* Entry point from preceeding Go closures. */
L(do_closure_i386)::
FFI_CLOSURE_PREP_CALL
FFI_CLOSURE_CALL_INNER(14)
FFI_CLOSURE_MASK_AND_JUMP L(C1(load_table,2))
ALIGN 8
L(load_table2):
E(L(load_table2), X86_RET_FLOAT)
fld dword ptr [esp+closure_CF]
jmp L(e2)
E(L(load_table2), X86_RET_DOUBLE)
fld qword ptr [esp+closure_CF]
jmp L(e2)
E(L(load_table2), X86_RET_LDOUBLE)
fld qword ptr [esp+closure_CF]
jmp L(e2)
E(L(load_table2), X86_RET_SINT8)
movsx eax, al
jmp L(e2)
E(L(load_table2), X86_RET_SINT16)
movsx eax, ax
jmp L(e2)
E(L(load_table2), X86_RET_UINT8)
movzx eax, al
jmp L(e2)
E(L(load_table2), X86_RET_UINT16)
movzx eax, ax
jmp L(e2)
E(L(load_table2), X86_RET_INT64)
mov edx, [esp+closure_CF+4]
jmp L(e2)
E(L(load_table2), X86_RET_INT32)
nop
/* fallthru */
E(L(load_table2), X86_RET_VOID)
L(e2):
add esp, closure_FS
L(UW16):
/* cfi_adjust_cfa_offset(-closure_FS) */
ret
L(UW17):
/* cfi_adjust_cfa_offset(closure_FS) */
E(L(load_table2), X86_RET_STRUCTPOP)
add esp, closure_FS
L(UW18):
/* cfi_adjust_cfa_offset(-closure_FS) */
ret 4
L(UW19):
/* cfi_adjust_cfa_offset(closure_FS) */
E(L(load_table2), X86_RET_STRUCTARG)
jmp L(e2)
E(L(load_table2), X86_RET_STRUCT_1B)
movzx eax, al
jmp L(e2)
E(L(load_table2), X86_RET_STRUCT_2B)
movzx eax, ax
jmp L(e2)
/* Fill out the table so that bad values are predictable. */
E(L(load_table2), X86_RET_UNUSED14)
int 3
E(L(load_table2), X86_RET_UNUSED15)
int 3
L(UW20):
/* cfi_endproc */
ENDF(ffi_closure_i386)
ALIGN 16
PUBLIC ffi_go_closure_STDCALL
ffi_go_closure_STDCALL PROC C
L(UW21):
/* cfi_startproc */
sub esp, closure_FS
L(UW22):
/* cfi_def_cfa_offset(closure_FS + 4) */
FFI_CLOSURE_SAVE_REGS
mov edx, [ecx+4] /* copy cif */
mov eax, [ecx+8] /* copy fun */
mov [esp+closure_CF+28], edx
mov [esp+closure_CF+32], eax
mov [esp+closure_CF+36], ecx /* closure is user_data */
jmp L(do_closure_STDCALL)
L(UW23):
/* cfi_endproc */
ENDF(ffi_go_closure_STDCALL)
/* For REGISTER, we have no available parameter registers, and so we
enter here having pushed the closure onto the stack. */
ALIGN 16
PUBLIC ffi_closure_REGISTER
ffi_closure_REGISTER PROC C
L(UW24):
/* cfi_startproc */
/* cfi_def_cfa(%esp, 8) */
/* cfi_offset(%eip, -8) */
sub esp, closure_FS-4
L(UW25):
/* cfi_def_cfa_offset(closure_FS + 4) */
FFI_CLOSURE_SAVE_REGS
mov ecx, [esp+closure_FS-4] /* load retaddr */
mov eax, [esp+closure_FS] /* load closure */
mov [esp+closure_FS], ecx /* move retaddr */
jmp L(do_closure_REGISTER)
L(UW26):
/* cfi_endproc */
ENDF(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
PUBLIC ffi_closure_STDCALL
ffi_closure_STDCALL PROC C
L(UW27):
/* cfi_startproc */
sub esp, closure_FS
L(UW28):
/* cfi_def_cfa_offset(closure_FS + 4) */
FFI_CLOSURE_SAVE_REGS
/* Entry point from ffi_closure_REGISTER. */
L(do_closure_REGISTER)::
FFI_CLOSURE_COPY_TRAMP_DATA
/* Entry point from preceeding Go closure. */
L(do_closure_STDCALL)::
FFI_CLOSURE_PREP_CALL
FFI_CLOSURE_CALL_INNER(29)
mov ecx, eax
shr ecx, X86_RET_POP_SHIFT /* isolate pop count */
lea ecx, [esp+closure_FS+ecx] /* compute popped esp */
mov edx, [esp+closure_FS] /* move return address */
mov [ecx], edx
/* From this point on, the value of %esp upon return is %ecx+4,
and we've copied the return address to %ecx to make return easy.
There's no point in representing this in the unwind info, as
there is always a window between the mov and the ret which
will be wrong from one point of view or another. */
FFI_CLOSURE_MASK_AND_JUMP L(C1(load_table,3))
ALIGN 8
L(load_table3):
E(L(load_table3), X86_RET_FLOAT)
fld DWORD PTR [esp+closure_CF]
mov esp, ecx
ret
E(L(load_table3), X86_RET_DOUBLE)
fld QWORD PTR [esp+closure_CF]
mov esp, ecx
ret
E(L(load_table3), X86_RET_LDOUBLE)
fld QWORD PTR [esp+closure_CF]
mov esp, ecx
ret
E(L(load_table3), X86_RET_SINT8)
movsx eax, al
mov esp, ecx
ret
E(L(load_table3), X86_RET_SINT16)
movsx eax, ax
mov esp, ecx
ret
E(L(load_table3), X86_RET_UINT8)
movzx eax, al
mov esp, ecx
ret
E(L(load_table3), X86_RET_UINT16)
movzx eax, ax
mov esp, ecx
ret
E(L(load_table3), X86_RET_INT64)
mov edx, [esp+closure_CF+4]
mov esp, ecx
ret
E(L(load_table3), X86_RET_int 32)
mov esp, ecx
ret
E(L(load_table3), X86_RET_VOID)
mov esp, ecx
ret
E(L(load_table3), X86_RET_STRUCTPOP)
mov esp, ecx
ret
E(L(load_table3), X86_RET_STRUCTARG)
mov esp, ecx
ret
E(L(load_table3), X86_RET_STRUCT_1B)
movzx eax, al
mov esp, ecx
ret
E(L(load_table3), X86_RET_STRUCT_2B)
movzx eax, ax
mov esp, ecx
ret
/* Fill out the table so that bad values are predictable. */
E(L(load_table3), X86_RET_UNUSED14)
int 3
E(L(load_table3), X86_RET_UNUSED15)
int 3
L(UW31):
/* cfi_endproc */
ENDF(ffi_closure_STDCALL)
#if !FFI_NO_RAW_API
#define raw_closure_S_FS (16+16+12)
ALIGN 16
PUBLIC ffi_closure_raw_SYSV
ffi_closure_raw_SYSV PROC C
L(UW32):
/* cfi_startproc */
sub esp, raw_closure_S_FS
L(UW33):
/* cfi_def_cfa_offset(raw_closure_S_FS + 4) */
mov [esp+raw_closure_S_FS-4], ebx
L(UW34):
/* cfi_rel_offset(%ebx, raw_closure_S_FS-4) */
mov edx, [eax+FFI_TRAMPOLINE_SIZE+8] /* load cl->user_data */
mov [esp+12], edx
lea edx, [esp+raw_closure_S_FS+4] /* load raw_args */
mov [esp+8], edx
lea edx, [esp+16] /* load &res */
mov [esp+4], edx
mov ebx, [eax+FFI_TRAMPOLINE_SIZE] /* load cl->cif */
mov [esp], ebx
call DWORD PTR [eax+FFI_TRAMPOLINE_SIZE+4] /* call cl->fun */
mov eax, [ebx+20] /* load cif->flags */
and eax, X86_RET_TYPE_MASK
/* #ifdef __PIC__ */
/* call __x86.get_pc_thunk.bx */
/* L(pc4): */
/* lea ecx, L(load_table4)-L(pc4)(%ebx, %eax, 8), %ecx */
/* #else */
lea ecx, [L(load_table4)+eax+8]
/* #endif */
mov ebx, [esp+raw_closure_S_FS-4]
L(UW35):
/* cfi_restore(%ebx) */
mov eax, [esp+16] /* Optimistic load */
jmp dword ptr [ecx]
ALIGN 8
L(load_table4):
E(L(load_table4), X86_RET_FLOAT)
fld DWORD PTR [esp +16]
jmp L(e4)
E(L(load_table4), X86_RET_DOUBLE)
fld QWORD PTR [esp +16]
jmp L(e4)
E(L(load_table4), X86_RET_LDOUBLE)
fld QWORD PTR [esp +16]
jmp L(e4)
E(L(load_table4), X86_RET_SINT8)
movsx eax, al
jmp L(e4)
E(L(load_table4), X86_RET_SINT16)
movsx eax, ax
jmp L(e4)
E(L(load_table4), X86_RET_UINT8)
movzx eax, al
jmp L(e4)
E(L(load_table4), X86_RET_UINT16)
movzx eax, ax
jmp L(e4)
E(L(load_table4), X86_RET_INT64)
mov edx, [esp+16+4]
jmp L(e4)
E(L(load_table4), X86_RET_int 32)
nop
/* fallthru */
E(L(load_table4), X86_RET_VOID)
L(e4):
add esp, raw_closure_S_FS
L(UW36):
/* cfi_adjust_cfa_offset(-raw_closure_S_FS) */
ret
L(UW37):
/* cfi_adjust_cfa_offset(raw_closure_S_FS) */
E(L(load_table4), X86_RET_STRUCTPOP)
add esp, raw_closure_S_FS
L(UW38):
/* cfi_adjust_cfa_offset(-raw_closure_S_FS) */
ret 4
L(UW39):
/* cfi_adjust_cfa_offset(raw_closure_S_FS) */
E(L(load_table4), X86_RET_STRUCTARG)
jmp L(e4)
E(L(load_table4), X86_RET_STRUCT_1B)
movzx eax, al
jmp L(e4)
E(L(load_table4), X86_RET_STRUCT_2B)
movzx eax, ax
jmp L(e4)
/* Fill out the table so that bad values are predictable. */
E(L(load_table4), X86_RET_UNUSED14)
int 3
E(L(load_table4), X86_RET_UNUSED15)
int 3
L(UW40):
/* cfi_endproc */
ENDF(ffi_closure_raw_SYSV)
#define raw_closure_T_FS (16+16+8)
ALIGN 16
PUBLIC ffi_closure_raw_THISCALL
ffi_closure_raw_THISCALL PROC C
L(UW41):
/* cfi_startproc */
/* Rearrange the stack such that %ecx is the first argument.
This means moving the return address. */
pop edx
L(UW42):
/* cfi_def_cfa_offset(0) */
/* cfi_register(%eip, %edx) */
push ecx
L(UW43):
/* cfi_adjust_cfa_offset(4) */
push edx
L(UW44):
/* cfi_adjust_cfa_offset(4) */
/* cfi_rel_offset(%eip, 0) */
sub esp, raw_closure_T_FS
L(UW45):
/* cfi_adjust_cfa_offset(raw_closure_T_FS) */
mov [esp+raw_closure_T_FS-4], ebx
L(UW46):
/* cfi_rel_offset(%ebx, raw_closure_T_FS-4) */
mov edx, [eax+FFI_TRAMPOLINE_SIZE+8] /* load cl->user_data */
mov [esp+12], edx
lea edx, [esp+raw_closure_T_FS+4] /* load raw_args */
mov [esp+8], edx
lea edx, [esp+16] /* load &res */
mov [esp+4], edx
mov ebx, [eax+FFI_TRAMPOLINE_SIZE] /* load cl->cif */
mov [esp], ebx
call DWORD PTR [eax+FFI_TRAMPOLINE_SIZE+4] /* call cl->fun */
mov eax, [ebx+20] /* load cif->flags */
and eax, X86_RET_TYPE_MASK
/* #ifdef __PIC__ */
/* call __x86.get_pc_thunk.bx */
/* L(pc5): */
/* leal L(load_table5)-L(pc5)(%ebx, %eax, 8), %ecx */
/* #else */
lea ecx, [L(load_table5)+eax*8]
/*#endif */
mov ebx, [esp+raw_closure_T_FS-4]
L(UW47):
/* cfi_restore(%ebx) */
mov eax, [esp+16] /* Optimistic load */
jmp DWORD PTR [ecx]
AlIGN 4
L(load_table5):
E(L(load_table5), X86_RET_FLOAT)
fld DWORD PTR [esp +16]
jmp L(e5)
E(L(load_table5), X86_RET_DOUBLE)
fld QWORD PTR [esp +16]
jmp L(e5)
E(L(load_table5), X86_RET_LDOUBLE)
fld QWORD PTR [esp+16]
jmp L(e5)
E(L(load_table5), X86_RET_SINT8)
movsx eax, al
jmp L(e5)
E(L(load_table5), X86_RET_SINT16)
movsx eax, ax
jmp L(e5)
E(L(load_table5), X86_RET_UINT8)
movzx eax, al
jmp L(e5)
E(L(load_table5), X86_RET_UINT16)
movzx eax, ax
jmp L(e5)
E(L(load_table5), X86_RET_INT64)
mov edx, [esp+16+4]
jmp L(e5)
E(L(load_table5), X86_RET_int 32)
nop
/* fallthru */
E(L(load_table5), X86_RET_VOID)
L(e5):
add esp, raw_closure_T_FS
L(UW48):
/* cfi_adjust_cfa_offset(-raw_closure_T_FS) */
/* Remove the extra %ecx argument we pushed. */
ret 4
L(UW49):
/* cfi_adjust_cfa_offset(raw_closure_T_FS) */
E(L(load_table5), X86_RET_STRUCTPOP)
add esp, raw_closure_T_FS
L(UW50):
/* cfi_adjust_cfa_offset(-raw_closure_T_FS) */
ret 8
L(UW51):
/* cfi_adjust_cfa_offset(raw_closure_T_FS) */
E(L(load_table5), X86_RET_STRUCTARG)
jmp L(e5)
E(L(load_table5), X86_RET_STRUCT_1B)
movzx eax, al
jmp L(e5)
E(L(load_table5), X86_RET_STRUCT_2B)
movzx eax, ax
jmp L(e5)
/* Fill out the table so that bad values are predictable. */
E(L(load_table5), X86_RET_UNUSED14)
int 3
E(L(load_table5), X86_RET_UNUSED15)
int 3
L(UW52):
/* cfi_endproc */
ENDF(ffi_closure_raw_THISCALL)
#endif /* !FFI_NO_RAW_API */
#ifdef X86_DARWIN
# define COMDAT(X) \
.section __TEXT,__text,coalesced,pure_instructions; \
.weak_definition X; \
FFI_HIDDEN(X)
#elif defined __ELF__ && !(defined(__sun__) && defined(__svr4__))
# define COMDAT(X) \
.section .text.X,"axG",@progbits,X,comdat; \
PUBLIC X; \
FFI_HIDDEN(X)
#else
# define COMDAT(X)
#endif
/* #if defined(__PIC__) */
/* COMDAT(C(__x86.get_pc_thunk.bx)) */
/* C(__x86.get_pc_thunk.bx): */
/* movl (%esp), %ebx */
/* ret */
/* ENDF(C(__x86.get_pc_thunk.bx)) */
/* # if defined X86_DARWIN || defined HAVE_HIDDEN_VISIBILITY_ATTRIBUTE */
/* COMDAT(C(__x86.get_pc_thunk.dx)) */
/* C(__x86.get_pc_thunk.dx): */
/* movl (%esp), %edx */
/* ret */
/* ENDF(C(__x86.get_pc_thunk.dx)) */
/* #endif /* DARWIN || HIDDEN */ */
/* #endif /* __PIC__ */ */
#if 0
/* Sadly, OSX cctools-as doesn't understand .cfi directives at all. */
#ifdef __APPLE__
.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
EHFrame0:
#elif defined(X86_WIN32)
.section .eh_frame,"r"
#elif defined(HAVE_AS_X86_64_UNWIND_SECTION_TYPE)
.section .eh_frame,EH_FRAME_FLAGS,@unwind
#else
.section .eh_frame,EH_FRAME_FLAGS,@progbits
#endif
#ifdef HAVE_AS_X86_PCREL
# define PCREL(X) X - .
#else
# define PCREL(X) X@rel
#endif
/* Simplify advancing between labels. Assume DW_CFA_advance_loc1 fits. */
#define ADV(N, P) .byte 2, L(N)-L(P)
.balign 4
L(CIE):
.set L(set0),L(ECIE)-L(SCIE)
.long L(set0) /* CIE Length */
L(SCIE):
.long 0 /* CIE Identifier Tag */
.byte 1 /* CIE Version */
.ascii "zR\0" /* CIE Augmentation */
.byte 1 /* CIE Code Alignment Factor */
.byte 0x7c /* CIE Data Alignment Factor */
.byte 0x8 /* CIE RA Column */
.byte 1 /* Augmentation size */
.byte 0x1b /* FDE Encoding (pcrel sdata4) */
.byte 0xc, 4, 4 /* DW_CFA_def_cfa, %esp offset 4 */
.byte 0x80+8, 1 /* DW_CFA_offset, %eip offset 1*-4 */
.balign 4
L(ECIE):
.set L(set1),L(EFDE1)-L(SFDE1)
.long L(set1) /* FDE Length */
L(SFDE1):
.long L(SFDE1)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW0)) /* Initial location */
.long L(UW5)-L(UW0) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW1, UW0)
.byte 0xc, 5, 8 /* DW_CFA_def_cfa, %ebp 8 */
.byte 0x80+5, 2 /* DW_CFA_offset, %ebp 2*-4 */
ADV(UW2, UW1)
.byte 0x80+3, 0 /* DW_CFA_offset, %ebx 0*-4 */
ADV(UW3, UW2)
.byte 0xa /* DW_CFA_remember_state */
.byte 0xc, 4, 4 /* DW_CFA_def_cfa, %esp 4 */
.byte 0xc0+3 /* DW_CFA_restore, %ebx */
.byte 0xc0+5 /* DW_CFA_restore, %ebp */
ADV(UW4, UW3)
.byte 0xb /* DW_CFA_restore_state */
.balign 4
L(EFDE1):
.set L(set2),L(EFDE2)-L(SFDE2)
.long L(set2) /* FDE Length */
L(SFDE2):
.long L(SFDE2)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW6)) /* Initial location */
.long L(UW8)-L(UW6) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW7, UW6)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE2):
.set L(set3),L(EFDE3)-L(SFDE3)
.long L(set3) /* FDE Length */
L(SFDE3):
.long L(SFDE3)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW9)) /* Initial location */
.long L(UW11)-L(UW9) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW10, UW9)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE3):
.set L(set4),L(EFDE4)-L(SFDE4)
.long L(set4) /* FDE Length */
L(SFDE4):
.long L(SFDE4)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW12)) /* Initial location */
.long L(UW20)-L(UW12) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW13, UW12)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
#ifdef FFI_CLOSURE_CALL_INNER_SAVE_EBX
ADV(UW14, UW13)
.byte 0x80+3, (40-(closure_FS+4))/-4 /* DW_CFA_offset %ebx */
ADV(UW15, UW14)
.byte 0xc0+3 /* DW_CFA_restore %ebx */
ADV(UW16, UW15)
#else
ADV(UW16, UW13)
#endif
.byte 0xe, 4 /* DW_CFA_def_cfa_offset */
ADV(UW17, UW16)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
ADV(UW18, UW17)
.byte 0xe, 4 /* DW_CFA_def_cfa_offset */
ADV(UW19, UW18)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE4):
.set L(set5),L(EFDE5)-L(SFDE5)
.long L(set5) /* FDE Length */
L(SFDE5):
.long L(SFDE5)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW21)) /* Initial location */
.long L(UW23)-L(UW21) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW22, UW21)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE5):
.set L(set6),L(EFDE6)-L(SFDE6)
.long L(set6) /* FDE Length */
L(SFDE6):
.long L(SFDE6)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW24)) /* Initial location */
.long L(UW26)-L(UW24) /* Address range */
.byte 0 /* Augmentation size */
.byte 0xe, 8 /* DW_CFA_def_cfa_offset */
.byte 0x80+8, 2 /* DW_CFA_offset %eip, 2*-4 */
ADV(UW25, UW24)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE6):
.set L(set7),L(EFDE7)-L(SFDE7)
.long L(set7) /* FDE Length */
L(SFDE7):
.long L(SFDE7)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW27)) /* Initial location */
.long L(UW31)-L(UW27) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW28, UW27)
.byte 0xe, closure_FS+4 /* DW_CFA_def_cfa_offset */
#ifdef FFI_CLOSURE_CALL_INNER_SAVE_EBX
ADV(UW29, UW28)
.byte 0x80+3, (40-(closure_FS+4))/-4 /* DW_CFA_offset %ebx */
ADV(UW30, UW29)
.byte 0xc0+3 /* DW_CFA_restore %ebx */
#endif
.balign 4
L(EFDE7):
#if !FFI_NO_RAW_API
.set L(set8),L(EFDE8)-L(SFDE8)
.long L(set8) /* FDE Length */
L(SFDE8):
.long L(SFDE8)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW32)) /* Initial location */
.long L(UW40)-L(UW32) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW33, UW32)
.byte 0xe, raw_closure_S_FS+4 /* DW_CFA_def_cfa_offset */
ADV(UW34, UW33)
.byte 0x80+3, 2 /* DW_CFA_offset %ebx 2*-4 */
ADV(UW35, UW34)
.byte 0xc0+3 /* DW_CFA_restore %ebx */
ADV(UW36, UW35)
.byte 0xe, 4 /* DW_CFA_def_cfa_offset */
ADV(UW37, UW36)
.byte 0xe, raw_closure_S_FS+4 /* DW_CFA_def_cfa_offset */
ADV(UW38, UW37)
.byte 0xe, 4 /* DW_CFA_def_cfa_offset */
ADV(UW39, UW38)
.byte 0xe, raw_closure_S_FS+4 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE8):
.set L(set9),L(EFDE9)-L(SFDE9)
.long L(set9) /* FDE Length */
L(SFDE9):
.long L(SFDE9)-L(CIE) /* FDE CIE offset */
.long PCREL(L(UW41)) /* Initial location */
.long L(UW52)-L(UW41) /* Address range */
.byte 0 /* Augmentation size */
ADV(UW42, UW41)
.byte 0xe, 0 /* DW_CFA_def_cfa_offset */
.byte 0x9, 8, 2 /* DW_CFA_register %eip, %edx */
ADV(UW43, UW42)
.byte 0xe, 4 /* DW_CFA_def_cfa_offset */
ADV(UW44, UW43)
.byte 0xe, 8 /* DW_CFA_def_cfa_offset */
.byte 0x80+8, 2 /* DW_CFA_offset %eip 2*-4 */
ADV(UW45, UW44)
.byte 0xe, raw_closure_T_FS+8 /* DW_CFA_def_cfa_offset */
ADV(UW46, UW45)
.byte 0x80+3, 3 /* DW_CFA_offset %ebx 3*-4 */
ADV(UW47, UW46)
.byte 0xc0+3 /* DW_CFA_restore %ebx */
ADV(UW48, UW47)
.byte 0xe, 8 /* DW_CFA_def_cfa_offset */
ADV(UW49, UW48)
.byte 0xe, raw_closure_T_FS+8 /* DW_CFA_def_cfa_offset */
ADV(UW50, UW49)
.byte 0xe, 8 /* DW_CFA_def_cfa_offset */
ADV(UW51, UW50)
.byte 0xe, raw_closure_T_FS+8 /* DW_CFA_def_cfa_offset */
.balign 4
L(EFDE9):
#endif /* !FFI_NO_RAW_API */
#ifdef _WIN32
.def @feat.00;
.scl 3;
.type 0;
.endef
PUBLIC @feat.00
@feat.00 = 1
#endif
#endif /* ifndef _MSC_VER */
#endif /* ifndef __x86_64__ */
#if defined __ELF__ && defined __linux__
.section .note.GNU-stack,"",@progbits
#endif
#endif
END
