Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

1 files changed, 995 insertions, 995 deletions

diff --git a/contrib/restricted/libffi/src/x86/sysv_intel.S b/contrib/restricted/libffi/src/x86/sysv_intel.S
index 3cafd71ce1..5fc9ff21fa 100644
--- a/contrib/restricted/libffi/src/x86/sysv_intel.S
+++ b/contrib/restricted/libffi/src/x86/sysv_intel.S
@@ -1,995 +1,995 @@
-/* -----------------------------------------------------------------------
-   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
\ No newline at end of file
+/* ----------------------------------------------------------------------- 
+   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 
\ No newline at end of file