/* -----------------------------------------------------------------------
   sysv.S - Copyright (c) 2017  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