kc3-lang/libffi/src/x86/win32.S

• Show log

  Commit

• Hash : 5d6340ef
  Author :
  Date : 2014-08-25T17:29:44
  

  Determine whether register arguments (THISCALL/FASTCALL/REGISTER) are really passed via register to closures. Use stack if not.

Download

• src/x86/win32.S

• /* -----------------------------------------------------------------------
     win32.S - Copyright (c) 2014  Anthony Green
               Copyright (c) 1996, 1998, 2001, 2002, 2009  Red Hat, Inc.
               Copyright (c) 2001  John Beniton
               Copyright (c) 2002  Ranjit Mathew
               Copyright (c) 2009  Daniel Witte
  
  
     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.
     -----------------------------------------------------------------------
     */
   
  #define LIBFFI_ASM
  #include <fficonfig.h>
  #include <ffi.h>
  
  #define CIF_BYTES_OFFSET 16
  #define CIF_FLAGS_OFFSET 20
  
  #ifdef _MSC_VER
  
  #define CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) AND NOT 3)
  
  .386
  .MODEL FLAT, C
  
  EXTRN ffi_closure_SYSV_inner:NEAR
  EXTRN ffi_closure_WIN32_inner:NEAR
  
  _TEXT SEGMENT
  
  ffi_call_win32 PROC NEAR,
      ffi_prep_args : NEAR PTR DWORD,
      ecif          : NEAR PTR DWORD,
      cif_abi       : DWORD,
      cif_bytes     : DWORD,
      cif_flags     : DWORD,
      rvalue        : NEAR PTR DWORD,
      fn            : NEAR PTR DWORD
  
          ;; Make room for all of the new args.
          mov  ecx, cif_bytes
          sub  esp, ecx
  
          mov  eax, esp
  
          ;; Call ffi_prep_args
          push ecif
          push eax
          call ffi_prep_args
          add  esp, 8
  
          ;; Prepare registers
          ;; EAX stores the number of register arguments
          cmp  eax, 0
          je   fun
          cmp  eax, 3
          jl   prepr_two_cmp
          
          mov  ecx, esp
          add  esp, 12
          mov  eax, DWORD PTR [ecx+8]
          jmp  prepr_two
  prepr_two_cmp:
          cmp  eax, 2
          jl   prepr_one_prep
          mov  ecx, esp
          add  esp, 8
  prepr_two:
          mov  edx, DWORD PTR [ecx+4]
          jmp  prepr_one
  prepr_one_prep:
          mov  ecx, esp
          add  esp, 4
  prepr_one:
          mov  ecx, DWORD PTR [ecx]
          cmp  cif_abi, 7 ;; FFI_REGISTER
          jne  fun
  
          xchg ecx, eax
  
  fun:
          ;; Call function
          call fn
  
          ;; Load ecx with the return type code
          mov  ecx, cif_flags
  
          ;; If the return value pointer is NULL, assume no return value.
          cmp  rvalue, 0
          jne  ca_jumptable
  
          ;; Even if there is no space for the return value, we are
          ;; obliged to handle floating-point values.
          cmp  ecx, FFI_TYPE_FLOAT
          jne  ca_epilogue
          fstp st(0)
  
          jmp  ca_epilogue
  
  ca_jumptable:
          jmp  [ca_jumpdata + 4 * ecx]
  ca_jumpdata:
          ;; Do not insert anything here between label and jump table.
          dd offset ca_epilogue       ;; FFI_TYPE_VOID
          dd offset ca_retint         ;; FFI_TYPE_INT
          dd offset ca_retfloat       ;; FFI_TYPE_FLOAT
          dd offset ca_retdouble      ;; FFI_TYPE_DOUBLE
          dd offset ca_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
          dd offset ca_retuint8       ;; FFI_TYPE_UINT8
          dd offset ca_retsint8       ;; FFI_TYPE_SINT8
          dd offset ca_retuint16      ;; FFI_TYPE_UINT16
          dd offset ca_retsint16      ;; FFI_TYPE_SINT16
          dd offset ca_retint         ;; FFI_TYPE_UINT32
          dd offset ca_retint         ;; FFI_TYPE_SINT32
          dd offset ca_retint64       ;; FFI_TYPE_UINT64
          dd offset ca_retint64       ;; FFI_TYPE_SINT64
          dd offset ca_epilogue       ;; FFI_TYPE_STRUCT
          dd offset ca_retint         ;; FFI_TYPE_POINTER
          dd offset ca_retstruct1b    ;; FFI_TYPE_SMALL_STRUCT_1B
          dd offset ca_retstruct2b    ;; FFI_TYPE_SMALL_STRUCT_2B
          dd offset ca_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
          dd offset ca_epilogue       ;; FFI_TYPE_MS_STRUCT
  
          /* Sign/zero extend as appropriate.  */
  ca_retuint8:
          movzx eax, al
          jmp   ca_retint
  
  ca_retsint8:
          movsx eax, al
          jmp   ca_retint
  
  ca_retuint16:
          movzx eax, ax
          jmp   ca_retint
  
  ca_retsint16:
          movsx eax, ax
          jmp   ca_retint
  
  ca_retint:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          mov   [ecx + 0], eax
          jmp   ca_epilogue
  
  ca_retint64:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          mov   [ecx + 0], eax
          mov   [ecx + 4], edx
          jmp   ca_epilogue
  
  ca_retfloat:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          fstp  DWORD PTR [ecx]
          jmp   ca_epilogue
  
  ca_retdouble:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          fstp  QWORD PTR [ecx]
          jmp   ca_epilogue
  
  ca_retlongdouble:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          fstp  TBYTE PTR [ecx]
          jmp   ca_epilogue
  
  ca_retstruct1b:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          mov   [ecx + 0], al
          jmp   ca_epilogue
  
  ca_retstruct2b:
          ;; Load %ecx with the pointer to storage for the return value
          mov   ecx, rvalue
          mov   [ecx + 0], ax
          jmp   ca_epilogue
  
  ca_epilogue:
          ;; Epilogue code is autogenerated.
          ret
  ffi_call_win32 ENDP
  
  ffi_closure_THISCALL PROC NEAR
          ;; Insert the register argument on the stack as the first argument
          xchg	DWORD PTR [esp+4], ecx
          xchg	DWORD PTR [esp], ecx
          push	ecx
          jmp	ffi_closure_STDCALL
  ffi_closure_THISCALL ENDP
  
  ffi_closure_FASTCALL PROC NEAR
          ;; Insert the 2 register arguments on the stack as the first argument
          xchg	DWORD PTR [esp+4], edx
          xchg	DWORD PTR [esp], ecx
          push	edx
          push	ecx
          jmp	ffi_closure_STDCALL
  ffi_closure_FASTCALL ENDP
  
  ffi_closure_REGISTER PROC NEAR
          ;; Insert the 3 register arguments on the stack as the first argument
          push	eax
          xchg	DWORD PTR [esp+8], ecx
          xchg	DWORD PTR [esp+4], edx
          push	ecx
          push	edx
          jmp	ffi_closure_STDCALL
  ffi_closure_FASTCALL ENDP
  
  ffi_closure_SYSV PROC NEAR FORCEFRAME
      ;; the ffi_closure ctx is passed in eax by the trampoline.
  
          sub  esp, 40
          lea  edx, [ebp - 24]
          mov  [ebp - 12], edx         ;; resp
          lea  edx, [ebp + 8]
  stub::
          mov  [esp + 8], edx          ;; args
          lea  edx, [ebp - 12]
          mov  [esp + 4], edx          ;; &resp
          mov  [esp], eax              ;; closure
          call ffi_closure_SYSV_inner
          mov  ecx, [ebp - 12]
  
  cs_jumptable:
          jmp  [cs_jumpdata + 4 * eax]
  cs_jumpdata:
          ;; Do not insert anything here between the label and jump table.
          dd offset cs_epilogue       ;; FFI_TYPE_VOID
          dd offset cs_retint         ;; FFI_TYPE_INT
          dd offset cs_retfloat       ;; FFI_TYPE_FLOAT
          dd offset cs_retdouble      ;; FFI_TYPE_DOUBLE
          dd offset cs_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
          dd offset cs_retuint8       ;; FFI_TYPE_UINT8
          dd offset cs_retsint8       ;; FFI_TYPE_SINT8
          dd offset cs_retuint16      ;; FFI_TYPE_UINT16
          dd offset cs_retsint16      ;; FFI_TYPE_SINT16
          dd offset cs_retint         ;; FFI_TYPE_UINT32
          dd offset cs_retint         ;; FFI_TYPE_SINT32
          dd offset cs_retint64       ;; FFI_TYPE_UINT64
          dd offset cs_retint64       ;; FFI_TYPE_SINT64
          dd offset cs_retstruct      ;; FFI_TYPE_STRUCT
          dd offset cs_retint         ;; FFI_TYPE_POINTER
          dd offset cs_retsint8       ;; FFI_TYPE_SMALL_STRUCT_1B
          dd offset cs_retsint16      ;; FFI_TYPE_SMALL_STRUCT_2B
          dd offset cs_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
          dd offset cs_retmsstruct    ;; FFI_TYPE_MS_STRUCT
  
  cs_retuint8:
          movzx eax, BYTE PTR [ecx]
          jmp   cs_epilogue
  
  cs_retsint8:
          movsx eax, BYTE PTR [ecx]
          jmp   cs_epilogue
  
  cs_retuint16:
          movzx eax, WORD PTR [ecx]
          jmp   cs_epilogue
  
  cs_retsint16:
          movsx eax, WORD PTR [ecx]
          jmp   cs_epilogue
  
  cs_retint:
          mov   eax, [ecx]
          jmp   cs_epilogue
  
  cs_retint64:
          mov   eax, [ecx + 0]
          mov   edx, [ecx + 4]
          jmp   cs_epilogue
  
  cs_retfloat:
          fld   DWORD PTR [ecx]
          jmp   cs_epilogue
  
  cs_retdouble:
          fld   QWORD PTR [ecx]
          jmp   cs_epilogue
  
  cs_retlongdouble:
          fld   TBYTE PTR [ecx]
          jmp   cs_epilogue
  
  cs_retstruct:
          ;; Caller expects us to pop struct return value pointer hidden arg.
          ;; Epilogue code is autogenerated.
          ret	4
  
  cs_retmsstruct:
          ;; Caller expects us to return a pointer to the real return value.
          mov   eax, ecx
          ;; Caller doesn't expects us to pop struct return value pointer hidden arg.
          jmp   cs_epilogue
  
  cs_epilogue:
          ;; Epilogue code is autogenerated.
          ret
  ffi_closure_SYSV ENDP
  
  #if !FFI_NO_RAW_API
  
  #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) AND NOT 3)
  #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
  #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
  
  ffi_closure_raw_THISCALL PROC NEAR USES esi FORCEFRAME
          sub esp, 36
          mov  esi, [eax + RAW_CLOSURE_CIF_OFFSET]        ;; closure->cif
          mov  edx, [eax + RAW_CLOSURE_USER_DATA_OFFSET]  ;; closure->user_data
          mov [esp + 12], edx
          lea edx, [ebp + 12]
          jmp stubraw
  ffi_closure_raw_THISCALL ENDP
  
  ffi_closure_raw_SYSV PROC NEAR USES esi FORCEFRAME
      ;; the ffi_closure ctx is passed in eax by the trampoline.
  
          sub  esp, 40
          mov  esi, [eax + RAW_CLOSURE_CIF_OFFSET]        ;; closure->cif
          mov  edx, [eax + RAW_CLOSURE_USER_DATA_OFFSET]  ;; closure->user_data
          mov  [esp + 12], edx                            ;; user_data
          lea  edx, [ebp + 8]
  stubraw::
          mov  [esp + 8], edx                             ;; raw_args
          lea  edx, [ebp - 24]
          mov  [esp + 4], edx                             ;; &res
          mov  [esp], esi                                 ;; cif
          call DWORD PTR [eax + RAW_CLOSURE_FUN_OFFSET]   ;; closure->fun
          mov  eax, [esi + CIF_FLAGS_OFFSET]              ;; cif->flags
          lea  ecx, [ebp - 24]
  
  cr_jumptable:
          jmp  [cr_jumpdata + 4 * eax]
  cr_jumpdata:
          ;; Do not insert anything here between the label and jump table.
          dd offset cr_epilogue       ;; FFI_TYPE_VOID
          dd offset cr_retint         ;; FFI_TYPE_INT
          dd offset cr_retfloat       ;; FFI_TYPE_FLOAT
          dd offset cr_retdouble      ;; FFI_TYPE_DOUBLE
          dd offset cr_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
          dd offset cr_retuint8       ;; FFI_TYPE_UINT8
          dd offset cr_retsint8       ;; FFI_TYPE_SINT8
          dd offset cr_retuint16      ;; FFI_TYPE_UINT16
          dd offset cr_retsint16      ;; FFI_TYPE_SINT16
          dd offset cr_retint         ;; FFI_TYPE_UINT32
          dd offset cr_retint         ;; FFI_TYPE_SINT32
          dd offset cr_retint64       ;; FFI_TYPE_UINT64
          dd offset cr_retint64       ;; FFI_TYPE_SINT64
          dd offset cr_epilogue       ;; FFI_TYPE_STRUCT
          dd offset cr_retint         ;; FFI_TYPE_POINTER
          dd offset cr_retsint8       ;; FFI_TYPE_SMALL_STRUCT_1B
          dd offset cr_retsint16      ;; FFI_TYPE_SMALL_STRUCT_2B
          dd offset cr_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
          dd offset cr_epilogue       ;; FFI_TYPE_MS_STRUCT
  
  cr_retuint8:
          movzx eax, BYTE PTR [ecx]
          jmp   cr_epilogue
  
  cr_retsint8:
          movsx eax, BYTE PTR [ecx]
          jmp   cr_epilogue
  
  cr_retuint16:
          movzx eax, WORD PTR [ecx]
          jmp   cr_epilogue
  
  cr_retsint16:
          movsx eax, WORD PTR [ecx]
          jmp   cr_epilogue
  
  cr_retint:
          mov   eax, [ecx]
          jmp   cr_epilogue
  
  cr_retint64:
          mov   eax, [ecx + 0]
          mov   edx, [ecx + 4]
          jmp   cr_epilogue
  
  cr_retfloat:
          fld   DWORD PTR [ecx]
          jmp   cr_epilogue
  
  cr_retdouble:
          fld   QWORD PTR [ecx]
          jmp   cr_epilogue
  
  cr_retlongdouble:
          fld   TBYTE PTR [ecx]
          jmp   cr_epilogue
  
  cr_epilogue:
          ;; Epilogue code is autogenerated.
          ret
  ffi_closure_raw_SYSV ENDP
  
  #endif /* !FFI_NO_RAW_API */
  
  ffi_closure_STDCALL PROC NEAR FORCEFRAME
          mov  eax, [esp] ;; the ffi_closure ctx passed by the trampoline.
  
          sub  esp, 40
          lea  edx, [ebp - 24]
          mov  [ebp - 12], edx         ;; resp
          lea  edx, [ebp + 12]         ;; account for stub return address on stack
          mov  [esp + 8], edx          ;; args
          lea  edx, [ebp - 12]
          mov  [esp + 4], edx          ;; &resp
          mov  [esp], eax              ;; closure
          call ffi_closure_WIN32_inner
          mov  ecx, [ebp - 12]
  
          xchg [ebp + 4], eax          ;;xchg size of stack parameters and ffi_closure ctx
          mov  eax, DWORD PTR [eax + CLOSURE_CIF_OFFSET]
          mov  eax, DWORD PTR [eax + CIF_FLAGS_OFFSET]
  
  cd_jumptable:
          jmp  [cd_jumpdata + 4 * eax]
  cd_jumpdata:
          ;; Do not insert anything here between the label and jump table.
          dd offset cd_epilogue       ;; FFI_TYPE_VOID
          dd offset cd_retint         ;; FFI_TYPE_INT
          dd offset cd_retfloat       ;; FFI_TYPE_FLOAT
          dd offset cd_retdouble      ;; FFI_TYPE_DOUBLE
          dd offset cd_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
          dd offset cd_retuint8       ;; FFI_TYPE_UINT8
          dd offset cd_retsint8       ;; FFI_TYPE_SINT8
          dd offset cd_retuint16      ;; FFI_TYPE_UINT16
          dd offset cd_retsint16      ;; FFI_TYPE_SINT16
          dd offset cd_retint         ;; FFI_TYPE_UINT32
          dd offset cd_retint         ;; FFI_TYPE_SINT32
          dd offset cd_retint64       ;; FFI_TYPE_UINT64
          dd offset cd_retint64       ;; FFI_TYPE_SINT64
          dd offset cd_epilogue       ;; FFI_TYPE_STRUCT
          dd offset cd_retint         ;; FFI_TYPE_POINTER
          dd offset cd_retsint8       ;; FFI_TYPE_SMALL_STRUCT_1B
          dd offset cd_retsint16      ;; FFI_TYPE_SMALL_STRUCT_2B
          dd offset cd_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
  
  cd_retuint8:
          movzx eax, BYTE PTR [ecx]
          jmp   cd_epilogue
  
  cd_retsint8:
          movsx eax, BYTE PTR [ecx]
          jmp   cd_epilogue
  
  cd_retuint16:
          movzx eax, WORD PTR [ecx]
          jmp   cd_epilogue
  
  cd_retsint16:
          movsx eax, WORD PTR [ecx]
          jmp   cd_epilogue
  
  cd_retint:
          mov   eax, [ecx]
          jmp   cd_epilogue
  
  cd_retint64:
          mov   eax, [ecx + 0]
          mov   edx, [ecx + 4]
          jmp   cd_epilogue
  
  cd_retfloat:
          fld   DWORD PTR [ecx]
          jmp   cd_epilogue
  
  cd_retdouble:
          fld   QWORD PTR [ecx]
          jmp   cd_epilogue
  
  cd_retlongdouble:
          fld   TBYTE PTR [ecx]
          jmp   cd_epilogue
  
  cd_epilogue:
          mov   esp, ebp
          pop   ebp
          mov   ecx, [esp + 4]  ;; Return address
          add   esp, [esp]      ;; Parameters stack size
          add   esp, 8
          jmp   ecx
  ffi_closure_STDCALL ENDP
  
  _TEXT ENDS
  END
  
  #else
  
  #define CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
  
  #if defined(SYMBOL_UNDERSCORE)
  #define USCORE_SYMBOL(x) _##x
  #else
  #define USCORE_SYMBOL(x) x
  #endif
          .text
   
          # This assumes we are using gas.
          .balign 16
  FFI_HIDDEN(ffi_call_win32)
          .globl	USCORE_SYMBOL(ffi_call_win32)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_call_win32;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_call_win32):
  .LFB1:
          pushl %ebp
  .LCFI0:
          movl  %esp,%ebp
  .LCFI1:
          # Make room for all of the new args.
          movl  20(%ebp),%ecx                                                     
          subl  %ecx,%esp
   
          movl  %esp,%eax
   
          # Call ffi_prep_args
          pushl 12(%ebp)
          pushl %eax
          call  *8(%ebp)
          addl  $8,%esp
  
          # Prepare registers
          # EAX stores the number of register arguments
          cmpl  $0, %eax
          je    .fun
          cmpl  $3, %eax
          jl    .prepr_two_cmp
          
          movl  %esp, %ecx
          addl  $12, %esp
          movl  8(%ecx), %eax
          jmp   .prepr_two
  .prepr_two_cmp:
          cmpl  $2, %eax
          jl    .prepr_one_prep
          movl  %esp, %ecx
          addl  $8, %esp
  .prepr_two:
          movl  4(%ecx), %edx
          jmp   .prepr_one
  .prepr_one_prep:
          movl  %esp, %ecx
          addl  $4, %esp
  .prepr_one:
          movl  (%ecx), %ecx
          cmpl  $7, 16(%ebp) # FFI_REGISTER
          jne   .fun
  
          xchgl %eax, %ecx
          
  .fun:
          # FIXME: Align the stack to a 128-bit boundary to avoid
          # potential performance hits.
  
          # Call function
          call  *32(%ebp)
   
          # stdcall functions pop arguments off the stack themselves
  
          # Load %ecx with the return type code
          movl  24(%ebp),%ecx
   
          # If the return value pointer is NULL, assume no return value.
          cmpl  $0,28(%ebp)
          jne   0f
   
          # Even if there is no space for the return value, we are
          # obliged to handle floating-point values.
          cmpl  $FFI_TYPE_FLOAT,%ecx
          jne   .Lnoretval
          fstp  %st(0)
   
          jmp   .Lepilogue
  
  0:
          call 1f
          # Do not insert anything here between the call and the jump table.
  .Lstore_table:
          .long	.Lnoretval-.Lstore_table	/* FFI_TYPE_VOID */
          .long	.Lretint-.Lstore_table		/* FFI_TYPE_INT */
          .long	.Lretfloat-.Lstore_table	/* FFI_TYPE_FLOAT */
          .long	.Lretdouble-.Lstore_table	/* FFI_TYPE_DOUBLE */
          .long	.Lretlongdouble-.Lstore_table	/* FFI_TYPE_LONGDOUBLE */
          .long	.Lretuint8-.Lstore_table	/* FFI_TYPE_UINT8 */
          .long	.Lretsint8-.Lstore_table	/* FFI_TYPE_SINT8 */
          .long	.Lretuint16-.Lstore_table	/* FFI_TYPE_UINT16 */
          .long	.Lretsint16-.Lstore_table	/* FFI_TYPE_SINT16 */
          .long	.Lretint-.Lstore_table		/* FFI_TYPE_UINT32 */
          .long	.Lretint-.Lstore_table		/* FFI_TYPE_SINT32 */
          .long	.Lretint64-.Lstore_table	/* FFI_TYPE_UINT64 */
          .long	.Lretint64-.Lstore_table	/* FFI_TYPE_SINT64 */
          .long	.Lretstruct-.Lstore_table	/* FFI_TYPE_STRUCT */
          .long	.Lretint-.Lstore_table		/* FFI_TYPE_POINTER */
          .long	.Lretstruct1b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_1B */
          .long	.Lretstruct2b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_2B */
          .long	.Lretstruct4b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_4B */
          .long	.Lretstruct-.Lstore_table	/* FFI_TYPE_MS_STRUCT */
  1:
          shl	$2, %ecx
          add	(%esp),%ecx
          mov	(%ecx),%ecx
          add	(%esp),%ecx
          add	$4, %esp
          jmp	*%ecx
  
          /* Sign/zero extend as appropriate.  */
  .Lretsint8:
          movsbl	%al, %eax
          jmp	.Lretint
  
  .Lretsint16:
          movswl	%ax, %eax
          jmp	.Lretint
  
  .Lretuint8:
          movzbl	%al, %eax
          jmp	.Lretint
  
  .Lretuint16:
          movzwl	%ax, %eax
          jmp	.Lretint
  
  .Lretint:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          movl  %eax,0(%ecx)
          jmp   .Lepilogue
   
  .Lretfloat:
           # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          fstps (%ecx)
          jmp   .Lepilogue
   
  .Lretdouble:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          fstpl (%ecx)
          jmp   .Lepilogue
   
  .Lretlongdouble:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          fstpt (%ecx)
          jmp   .Lepilogue
   
  .Lretint64:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          movl  %eax,0(%ecx)
          movl  %edx,4(%ecx)
          jmp   .Lepilogue
  
  .Lretstruct1b:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          movb  %al,0(%ecx)
          jmp   .Lepilogue
   
  .Lretstruct2b:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          movw  %ax,0(%ecx)
          jmp   .Lepilogue
  
  .Lretstruct4b:
          # Load %ecx with the pointer to storage for the return value
          movl  28(%ebp),%ecx
          movl  %eax,0(%ecx)
          jmp   .Lepilogue
  
  .Lretstruct:
          # Nothing to do!
   
  .Lnoretval:
  .Lepilogue:
          movl %ebp,%esp
          popl %ebp
          ret
  .ffi_call_win32_end:
          .balign 16
  FFI_HIDDEN(ffi_closure_THISCALL)
          .globl	USCORE_SYMBOL(ffi_closure_THISCALL)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_THISCALL;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_THISCALL):
          /* Insert the register argument on the stack as the first argument */
          xchg	%ecx, 4(%esp)
          xchg	%ecx, (%esp)
          push	%ecx
          jmp	.ffi_closure_STDCALL_internal
  
          .balign 16
  FFI_HIDDEN(ffi_closure_FASTCALL)
          .globl	USCORE_SYMBOL(ffi_closure_FASTCALL)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_FASTCALL;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_FASTCALL):
          /* Insert the 2 register arguments on the stack as the first two arguments */
          xchg	%edx, 4(%esp)
          xchg	%ecx, (%esp)
          push	%edx
          push	%ecx
          jmp	.ffi_closure_STDCALL_internal
  FFI_HIDDEN(ffi_closure_REGISTER)
          .globl	USCORE_SYMBOL(ffi_closure_REGISTER)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_REGISTER;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_REGISTER):
          /* Insert the 3 register arguments on the stack as the first two arguments */
          push	%eax
          xchg	%ecx, 8(%esp)
          xchg	%edx, 4(%esp)
          push	%ecx
          push	%edx
          jmp	.ffi_closure_STDCALL_internal
  
  .LFE1:
          # This assumes we are using gas.
          .balign 16
  FFI_HIDDEN(ffi_closure_SYSV)
  #if defined(X86_WIN32)
          .globl	USCORE_SYMBOL(ffi_closure_SYSV)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_SYSV;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_SYSV):
  #endif
  .LFB3:
          pushl	%ebp
  .LCFI4:
          movl	%esp, %ebp
  .LCFI5:
          subl	$40, %esp
          leal	-24(%ebp), %edx
          movl	%edx, -12(%ebp)	/* resp */
          leal	8(%ebp), %edx
          movl	%edx, 4(%esp)	/* args = __builtin_dwarf_cfa () */
          leal	-12(%ebp), %edx
          movl	%edx, (%esp)	/* &resp */
  #if defined(HAVE_HIDDEN_VISIBILITY_ATTRIBUTE) || !defined(__PIC__)
          call	USCORE_SYMBOL(ffi_closure_SYSV_inner)
  #elif defined(X86_DARWIN)
          calll	L_ffi_closure_SYSV_inner$stub
  #else
          movl	%ebx, 8(%esp)
          call	1f
  1:      popl	%ebx
          addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
          call	ffi_closure_SYSV_inner@PLT
          movl	8(%esp), %ebx
  #endif
          movl	-12(%ebp), %ecx
  
  0:
          call	1f
          # Do not insert anything here between the call and the jump table.
  .Lcls_store_table:
          .long	.Lcls_noretval-.Lcls_store_table	/* FFI_TYPE_VOID */
          .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_INT */
          .long	.Lcls_retfloat-.Lcls_store_table	/* FFI_TYPE_FLOAT */
          .long	.Lcls_retdouble-.Lcls_store_table	/* FFI_TYPE_DOUBLE */
          .long	.Lcls_retldouble-.Lcls_store_table	/* FFI_TYPE_LONGDOUBLE */
          .long	.Lcls_retuint8-.Lcls_store_table	/* FFI_TYPE_UINT8 */
          .long	.Lcls_retsint8-.Lcls_store_table	/* FFI_TYPE_SINT8 */
          .long	.Lcls_retuint16-.Lcls_store_table	/* FFI_TYPE_UINT16 */
          .long	.Lcls_retsint16-.Lcls_store_table	/* FFI_TYPE_SINT16 */
          .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_UINT32 */
          .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_SINT32 */
          .long	.Lcls_retllong-.Lcls_store_table	/* FFI_TYPE_UINT64 */
          .long	.Lcls_retllong-.Lcls_store_table	/* FFI_TYPE_SINT64 */
          .long	.Lcls_retstruct-.Lcls_store_table	/* FFI_TYPE_STRUCT */
          .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_POINTER */
          .long	.Lcls_retstruct1-.Lcls_store_table	/* FFI_TYPE_SMALL_STRUCT_1B */
          .long	.Lcls_retstruct2-.Lcls_store_table	/* FFI_TYPE_SMALL_STRUCT_2B */
          .long	.Lcls_retstruct4-.Lcls_store_table	/* FFI_TYPE_SMALL_STRUCT_4B */
          .long	.Lcls_retmsstruct-.Lcls_store_table	/* FFI_TYPE_MS_STRUCT */
  
  1:
          shl	$2, %eax
          add	(%esp),%eax
          mov	(%eax),%eax
          add	(%esp),%eax
          add	$4, %esp
          jmp	*%eax
  
          /* Sign/zero extend as appropriate.  */
  .Lcls_retsint8:
          movsbl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retsint16:
          movswl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retuint8:
          movzbl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retuint16:
          movzwl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retint:
          movl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retfloat:
          flds	(%ecx)
          jmp	.Lcls_epilogue
  
  .Lcls_retdouble:
          fldl	(%ecx)
          jmp	.Lcls_epilogue
  
  .Lcls_retldouble:
          fldt	(%ecx)
          jmp	.Lcls_epilogue
  
  .Lcls_retllong:
          movl	(%ecx), %eax
          movl	4(%ecx), %edx
          jmp	.Lcls_epilogue
  
  .Lcls_retstruct1:
          movsbl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retstruct2:
          movswl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retstruct4:
          movl	(%ecx), %eax
          jmp	.Lcls_epilogue
  
  .Lcls_retstruct:
          # Caller expects us to pop struct return value pointer hidden arg.
          movl	%ebp, %esp
          popl	%ebp
          ret	$0x4
  
  .Lcls_retmsstruct:
          # Caller expects us to return a pointer to the real return value.
          mov	%ecx, %eax
          # Caller doesn't expects us to pop struct return value pointer hidden arg.
          jmp	.Lcls_epilogue
  
  .Lcls_noretval:
  .Lcls_epilogue:
          movl	%ebp, %esp
          popl	%ebp
          ret
  .ffi_closure_SYSV_end:
  .LFE3:
  
  #if !FFI_NO_RAW_API
  
  #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
  #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
  #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
  
  #ifdef X86_WIN32
          .balign 16
  FFI_HIDDEN(ffi_closure_raw_THISCALL)
          .globl	USCORE_SYMBOL(ffi_closure_raw_THISCALL)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_raw_THISCALL;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_raw_THISCALL):
          pushl	%ebp
          movl	%esp, %ebp
          pushl	%esi
          subl	$36, %esp
          movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
          movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
          movl	%edx, 12(%esp)	/* user_data */
          leal	12(%ebp), %edx	/* __builtin_dwarf_cfa () */
          jmp	.stubraw
  #endif /* X86_WIN32 */
  
          # This assumes we are using gas.
          .balign 16
  #if defined(X86_WIN32)
          .globl	USCORE_SYMBOL(ffi_closure_raw_SYSV)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_raw_SYSV;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_raw_SYSV):
  #endif /* defined(X86_WIN32) */
  .LFB4:
          pushl	%ebp
  .LCFI6:
          movl	%esp, %ebp
  .LCFI7:
          pushl	%esi
  .LCFI8:
          subl	$36, %esp
          movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
          movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
          movl	%edx, 12(%esp)	/* user_data */
          leal	8(%ebp), %edx	/* __builtin_dwarf_cfa () */
  .stubraw:
          movl	%edx, 8(%esp)	/* raw_args */
          leal	-24(%ebp), %edx
          movl	%edx, 4(%esp)	/* &res */
          movl	%esi, (%esp)	/* cif */
          call	*RAW_CLOSURE_FUN_OFFSET(%eax)		 /* closure->fun */
          movl	CIF_FLAGS_OFFSET(%esi), %eax		 /* rtype */
  0:
          call	1f
          # Do not insert anything here between the call and the jump table.
  .Lrcls_store_table:
          .long	.Lrcls_noretval-.Lrcls_store_table	/* FFI_TYPE_VOID */
          .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_INT */
          .long	.Lrcls_retfloat-.Lrcls_store_table	/* FFI_TYPE_FLOAT */
          .long	.Lrcls_retdouble-.Lrcls_store_table	/* FFI_TYPE_DOUBLE */
          .long	.Lrcls_retldouble-.Lrcls_store_table	/* FFI_TYPE_LONGDOUBLE */
          .long	.Lrcls_retuint8-.Lrcls_store_table	/* FFI_TYPE_UINT8 */
          .long	.Lrcls_retsint8-.Lrcls_store_table	/* FFI_TYPE_SINT8 */
          .long	.Lrcls_retuint16-.Lrcls_store_table	/* FFI_TYPE_UINT16 */
          .long	.Lrcls_retsint16-.Lrcls_store_table	/* FFI_TYPE_SINT16 */
          .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_UINT32 */
          .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_SINT32 */
          .long	.Lrcls_retllong-.Lrcls_store_table	/* FFI_TYPE_UINT64 */
          .long	.Lrcls_retllong-.Lrcls_store_table	/* FFI_TYPE_SINT64 */
          .long	.Lrcls_retstruct-.Lrcls_store_table	/* FFI_TYPE_STRUCT */
          .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_POINTER */
          .long	.Lrcls_retstruct1-.Lrcls_store_table	/* FFI_TYPE_SMALL_STRUCT_1B */
          .long	.Lrcls_retstruct2-.Lrcls_store_table	/* FFI_TYPE_SMALL_STRUCT_2B */
          .long	.Lrcls_retstruct4-.Lrcls_store_table	/* FFI_TYPE_SMALL_STRUCT_4B */
          .long	.Lrcls_retstruct-.Lrcls_store_table	/* FFI_TYPE_MS_STRUCT */
  1:
          shl	$2, %eax
          add	(%esp),%eax
          mov	(%eax),%eax
          add	(%esp),%eax
          add	$4, %esp
          jmp	*%eax
  
          /* Sign/zero extend as appropriate.  */
  .Lrcls_retsint8:
          movsbl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retsint16:
          movswl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retuint8:
          movzbl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retuint16:
          movzwl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retint:
          movl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retfloat:
          flds	-24(%ebp)
          jmp	.Lrcls_epilogue
  
  .Lrcls_retdouble:
          fldl	-24(%ebp)
          jmp	.Lrcls_epilogue
  
  .Lrcls_retldouble:
          fldt	-24(%ebp)
          jmp	.Lrcls_epilogue
  
  .Lrcls_retllong:
          movl	-24(%ebp), %eax
          movl	-20(%ebp), %edx
          jmp	.Lrcls_epilogue
  
  .Lrcls_retstruct1:
          movsbl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retstruct2:
          movswl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retstruct4:
          movl	-24(%ebp), %eax
          jmp	.Lrcls_epilogue
  
  .Lrcls_retstruct:
          # Nothing to do!
  
  .Lrcls_noretval:
  .Lrcls_epilogue:
          addl	$36, %esp
          popl	%esi
          popl	%ebp
          ret
  .ffi_closure_raw_SYSV_end:
  .LFE4:
  
  #endif /* !FFI_NO_RAW_API */
  
          # This assumes we are using gas.
          .balign	16
  FFI_HIDDEN(ffi_closure_STDCALL)
          .globl	USCORE_SYMBOL(ffi_closure_STDCALL)
  #if defined(X86_WIN32) && !defined(__OS2__)
          .def	_ffi_closure_STDCALL;	.scl	2;	.type	32;	.endef
  #endif
  USCORE_SYMBOL(ffi_closure_STDCALL):
  .ffi_closure_STDCALL_internal:
          /* ffi_closure ctx is at top of the stack */
          movl	(%esp), %eax
  .LFB5:
          pushl	%ebp
  .LCFI9:
          movl	%esp, %ebp
  .LCFI10:
          subl	$40, %esp
          leal	-24(%ebp), %edx
          movl	%edx, -12(%ebp)	/* resp */
          leal	12(%ebp), %edx  /* account for stub return address on stack */
          movl	%edx, 4(%esp)	/* args */
          leal	-12(%ebp), %edx
          movl	%edx, (%esp)	/* &resp */
  #if defined(HAVE_HIDDEN_VISIBILITY_ATTRIBUTE) || !defined(__PIC__)
          call	USCORE_SYMBOL(ffi_closure_WIN32_inner)
  #elif defined(X86_DARWIN)
          calll	L_ffi_closure_WIN32_inner$stub
  #else
          movl	%ebx, 8(%esp)
          call	1f
  1:      popl	%ebx
          addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
          call	ffi_closure_WIN32_inner@PLT
          movl	8(%esp), %ebx
  #endif
          movl	-12(%ebp), %ecx
  0:
          xchgl	4(%ebp), %eax /* xchg size of stack parameters and ffi_closure ctx */
          movl	CLOSURE_CIF_OFFSET(%eax), %eax
          movl	CIF_FLAGS_OFFSET(%eax), %eax
  
          call	1f
          # Do not insert anything here between the call and the jump table.
  .Lscls_store_table:
          .long	.Lscls_noretval-.Lscls_store_table	/* FFI_TYPE_VOID */
          .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_INT */
          .long	.Lscls_retfloat-.Lscls_store_table	/* FFI_TYPE_FLOAT */
          .long	.Lscls_retdouble-.Lscls_store_table	/* FFI_TYPE_DOUBLE */
          .long	.Lscls_retldouble-.Lscls_store_table	/* FFI_TYPE_LONGDOUBLE */
          .long	.Lscls_retuint8-.Lscls_store_table	/* FFI_TYPE_UINT8 */
          .long	.Lscls_retsint8-.Lscls_store_table	/* FFI_TYPE_SINT8 */
          .long	.Lscls_retuint16-.Lscls_store_table	/* FFI_TYPE_UINT16 */
          .long	.Lscls_retsint16-.Lscls_store_table	/* FFI_TYPE_SINT16 */
          .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_UINT32 */
          .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_SINT32 */
          .long	.Lscls_retllong-.Lscls_store_table	/* FFI_TYPE_UINT64 */
          .long	.Lscls_retllong-.Lscls_store_table	/* FFI_TYPE_SINT64 */
          .long	.Lscls_retstruct-.Lscls_store_table	/* FFI_TYPE_STRUCT */
          .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_POINTER */
          .long	.Lscls_retstruct1-.Lscls_store_table	/* FFI_TYPE_SMALL_STRUCT_1B */
          .long	.Lscls_retstruct2-.Lscls_store_table	/* FFI_TYPE_SMALL_STRUCT_2B */
          .long	.Lscls_retstruct4-.Lscls_store_table	/* FFI_TYPE_SMALL_STRUCT_4B */
  1:
          shl	$2, %eax
          add	(%esp),%eax
          mov	(%eax),%eax
          add	(%esp),%eax
          add	$4, %esp
          jmp	*%eax
  
          /* Sign/zero extend as appropriate.  */
  .Lscls_retsint8:
          movsbl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retsint16:
          movswl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retuint8:
          movzbl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retuint16:
          movzwl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retint:
          movl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retfloat:
          flds	(%ecx)
          jmp	.Lscls_epilogue
  
  .Lscls_retdouble:
          fldl	(%ecx)
          jmp	.Lscls_epilogue
  
  .Lscls_retldouble:
          fldt	(%ecx)
          jmp	.Lscls_epilogue
  
  .Lscls_retllong:
          movl	(%ecx), %eax
          movl	4(%ecx), %edx
          jmp	.Lscls_epilogue
  
  .Lscls_retstruct1:
          movsbl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retstruct2:
          movswl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retstruct4:
          movl	(%ecx), %eax
          jmp	.Lscls_epilogue
  
  .Lscls_retstruct:
          # Nothing to do!
  
  .Lscls_noretval:
  .Lscls_epilogue:
          movl	%ebp, %esp
          popl	%ebp
          movl	4(%esp), %ecx /* Return address */
          addl	(%esp), %esp  /* Parameters stack size */
          addl	$8, %esp
          jmp	*%ecx
  .ffi_closure_STDCALL_end:
  .LFE5:
  
  #if defined(X86_DARWIN)
  .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
  L_ffi_closure_SYSV_inner$stub:
          .indirect_symbol _ffi_closure_SYSV_inner
          hlt ; hlt ; hlt ; hlt ; hlt
  L_ffi_closure_WIN32_inner$stub:
          .indirect_symbol _ffi_closure_WIN32_inner
          hlt ; hlt ; hlt ; hlt ; hlt
  #endif
  
  #if defined(X86_WIN32) && !defined(__OS2__)
          .section	.eh_frame,"w"
  #endif
  .Lframe1:
  .LSCIE1:
          .long	.LECIE1-.LASCIE1  /* Length of Common Information Entry */
  .LASCIE1:
          .long	0x0	/* CIE Identifier Tag */
          .byte	0x1	/* CIE Version */
  #ifdef __PIC__
          .ascii "zR\0"	/* CIE Augmentation */
  #else
          .ascii "\0"	/* CIE Augmentation */
  #endif
          .byte	0x1	/* .uleb128 0x1; CIE Code Alignment Factor */
          .byte	0x7c	/* .sleb128 -4; CIE Data Alignment Factor */
          .byte	0x8	/* CIE RA Column */
  #ifdef __PIC__
          .byte	0x1	/* .uleb128 0x1; Augmentation size */
          .byte	0x1b	/* FDE Encoding (pcrel sdata4) */
  #endif
          .byte	0xc	/* DW_CFA_def_cfa CFA = r4 + 4 = 4(%esp) */
          .byte	0x4	/* .uleb128 0x4 */
          .byte	0x4	/* .uleb128 0x4 */
          .byte	0x88	/* DW_CFA_offset, column 0x8 %eip at CFA + 1 * -4 */
          .byte	0x1	/* .uleb128 0x1 */
          .align 4
  .LECIE1:
  
  .LSFDE1:
          .long	.LEFDE1-.LASFDE1	/* FDE Length */
  .LASFDE1:
          .long	.LASFDE1-.Lframe1	/* FDE CIE offset */
  #if defined __PIC__ && defined HAVE_AS_X86_PCREL
          .long	.LFB1-.	/* FDE initial location */
  #else
          .long	.LFB1
  #endif
          .long	.LFE1-.LFB1	/* FDE address range */
  #ifdef __PIC__
          .byte	0x0	/* .uleb128 0x0; Augmentation size */
  #endif
          /* DW_CFA_xxx CFI instructions go here.  */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI0-.LFB1
          .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
          .byte	0x8	/* .uleb128 0x8 */
          .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
          .byte	0x2	/* .uleb128 0x2 */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI1-.LCFI0
          .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
          .byte	0x5	/* .uleb128 0x5 */
  
          /* End of DW_CFA_xxx CFI instructions.  */
          .align 4
  .LEFDE1:
  
  .LSFDE3:
          .long	.LEFDE3-.LASFDE3	/* FDE Length */
  .LASFDE3:
          .long	.LASFDE3-.Lframe1	/* FDE CIE offset */
  #if defined __PIC__ && defined HAVE_AS_X86_PCREL
          .long	.LFB3-.	/* FDE initial location */
  #else
          .long	.LFB3
  #endif
          .long	.LFE3-.LFB3	/* FDE address range */
  #ifdef __PIC__
          .byte	0x0	/* .uleb128 0x0; Augmentation size */
  #endif
          /* DW_CFA_xxx CFI instructions go here.  */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI4-.LFB3
          .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
          .byte	0x8	/* .uleb128 0x8 */
          .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
          .byte	0x2	/* .uleb128 0x2 */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI5-.LCFI4
          .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
          .byte	0x5	/* .uleb128 0x5 */
  
          /* End of DW_CFA_xxx CFI instructions.  */
          .align 4
  .LEFDE3:
  
  #if !FFI_NO_RAW_API
  
  .LSFDE4:
          .long	.LEFDE4-.LASFDE4	/* FDE Length */
  .LASFDE4:
          .long	.LASFDE4-.Lframe1	/* FDE CIE offset */
  #if defined __PIC__ && defined HAVE_AS_X86_PCREL
          .long	.LFB4-.	/* FDE initial location */
  #else
          .long	.LFB4
  #endif
          .long	.LFE4-.LFB4	/* FDE address range */
  #ifdef __PIC__
          .byte	0x0	/* .uleb128 0x0; Augmentation size */
  #endif
          /* DW_CFA_xxx CFI instructions go here.  */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI6-.LFB4
          .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
          .byte	0x8	/* .uleb128 0x8 */
          .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
          .byte	0x2	/* .uleb128 0x2 */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI7-.LCFI6
          .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
          .byte	0x5	/* .uleb128 0x5 */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI8-.LCFI7
          .byte	0x86	/* DW_CFA_offset, column 0x6 %esi at CFA + 3 * -4 */
          .byte	0x3	/* .uleb128 0x3 */
  
          /* End of DW_CFA_xxx CFI instructions.  */
          .align 4
  .LEFDE4:
  
  #endif /* !FFI_NO_RAW_API */
  
  .LSFDE5:
          .long	.LEFDE5-.LASFDE5	/* FDE Length */
  .LASFDE5:
          .long	.LASFDE5-.Lframe1	/* FDE CIE offset */
  #if defined __PIC__ && defined HAVE_AS_X86_PCREL
          .long	.LFB5-.	/* FDE initial location */
  #else
          .long	.LFB5
  #endif
          .long	.LFE5-.LFB5	/* FDE address range */
  #ifdef __PIC__
          .byte	0x0	/* .uleb128 0x0; Augmentation size */
  #endif
          /* DW_CFA_xxx CFI instructions go here.  */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI9-.LFB5
          .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
          .byte	0x8	/* .uleb128 0x8 */
          .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
          .byte	0x2	/* .uleb128 0x2 */
  
          .byte	0x4	/* DW_CFA_advance_loc4 */
          .long	.LCFI10-.LCFI9
          .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
          .byte	0x5	/* .uleb128 0x5 */
  
          /* End of DW_CFA_xxx CFI instructions.  */
          .align 4
  .LEFDE5:
  
  #endif /* !_MSC_VER */
  
  #if defined __ELF__ && defined __linux__
          .section	.note.GNU-stack,"",@progbits
  #endif
  

Download