libffi/src/x86/win32.S

   1 /* -----------------------------------------------------------------------
   2    win32.S - Copyright (c) 1996, 1998, 2001, 2002, 2009  Red Hat, Inc.
   3              Copyright (c) 2001  John Beniton
   4              Copyright (c) 2002  Ranjit Mathew
   5
   6
   7    X86 Foreign Function Interface
   8
   9    Permission is hereby granted, free of charge, to any person obtaining
  10    a copy of this software and associated documentation files (the
  11    ``Software''), to deal in the Software without restriction, including
  12    without limitation the rights to use, copy, modify, merge, publish,
  13    distribute, sublicense, and/or sell copies of the Software, and to
  14    permit persons to whom the Software is furnished to do so, subject to
  15    the following conditions:
  16
  17    The above copyright notice and this permission notice shall be included
  18    in all copies or substantial portions of the Software.
  19
  20    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  21    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  24    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  25    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  27    DEALINGS IN THE SOFTWARE.
  28    -----------------------------------------------------------------------
  29    */
  30
  31 #define LIBFFI_ASM
  32 #include <fficonfig.h>
  33 #include <ffi.h>
  34
  35         .text
  36
  37         .extern ffi_prep_args
  38
  39         # This assumes we are using gas.
  40         .balign 16
  41         .globl  _ffi_call_SYSV
  42         .def    _ffi_call_SYSV; .scl    2;      .type   32;     .endef
  43 _ffi_call_SYSV:
  44 .LFB1:
  45         pushl %ebp
  46 .LCFI0:
  47         movl  %esp,%ebp
  48 .LCFI1:
  49         # Make room for all of the new args.
  50         movl  16(%ebp),%ecx
  51         subl  %ecx,%esp
  52
  53         movl  %esp,%eax
  54
  55         # Place all of the ffi_prep_args in position
  56         pushl 12(%ebp)
  57         pushl %eax
  58         call  *8(%ebp)
  59
  60         # Return stack to previous state and call the function
  61         addl  $8,%esp
  62
  63         # FIXME: Align the stack to a 128-bit boundary to avoid
  64         # potential performance hits.
  65
  66         call  *28(%ebp)
  67
  68         # Remove the space we pushed for the args
  69         movl  16(%ebp),%ecx
  70         addl  %ecx,%esp
  71
  72         # Load %ecx with the return type code
  73         movl  20(%ebp),%ecx
  74
  75         # If the return value pointer is NULL, assume no return value.
  76         cmpl  $0,24(%ebp)
  77         jne   retint
  78
  79         # Even if there is no space for the return value, we are
  80         # obliged to handle floating-point values.
  81         cmpl  $FFI_TYPE_FLOAT,%ecx
  82         jne   noretval
  83         fstp  %st(0)
  84
  85         jmp   epilogue
  86
  87 retint:
  88         cmpl  $FFI_TYPE_INT,%ecx
  89         jne   retfloat
  90         # Load %ecx with the pointer to storage for the return value
  91         movl  24(%ebp),%ecx
  92         movl  %eax,0(%ecx)
  93         jmp   epilogue
  94
  95 retfloat:
  96         cmpl  $FFI_TYPE_FLOAT,%ecx
  97         jne   retdouble
  98          # Load %ecx with the pointer to storage for the return value
  99         movl  24(%ebp),%ecx
 100         fstps (%ecx)
 101         jmp   epilogue
 102
 103 retdouble:
 104         cmpl  $FFI_TYPE_DOUBLE,%ecx
 105         jne   retlongdouble
 106         # Load %ecx with the pointer to storage for the return value
 107         movl  24(%ebp),%ecx
 108         fstpl (%ecx)
 109         jmp   epilogue
 110
 111 retlongdouble:
 112         cmpl  $FFI_TYPE_LONGDOUBLE,%ecx
 113         jne   retint64
 114         # Load %ecx with the pointer to storage for the return value
 115         movl  24(%ebp),%ecx
 116         fstpt (%ecx)
 117         jmp   epilogue
 118
 119 retint64:
 120         cmpl  $FFI_TYPE_SINT64,%ecx
 121         jne   retstruct1b
 122         # Load %ecx with the pointer to storage for the return value
 123         movl  24(%ebp),%ecx
 124         movl  %eax,0(%ecx)
 125         movl  %edx,4(%ecx)
 126
 127 retstruct1b:
 128         cmpl  $FFI_TYPE_SINT8,%ecx
 129         jne   retstruct2b
 130         # Load %ecx with the pointer to storage for the return value
 131         movl  24(%ebp),%ecx
 132         movb  %al,0(%ecx)
 133         jmp   epilogue
 134
 135 retstruct2b:
 136         cmpl  $FFI_TYPE_SINT16,%ecx
 137         jne   retstruct
 138         # Load %ecx with the pointer to storage for the return value
 139         movl  24(%ebp),%ecx
 140         movw  %ax,0(%ecx)
 141         jmp   epilogue
 142
 143 retstruct:
 144         # Nothing to do!
 145
 146 noretval:
 147 epilogue:
 148         movl %ebp,%esp
 149         popl %ebp
 150         ret
 151 .ffi_call_SYSV_end:
 152 .LFE1:
 153
 154         # This assumes we are using gas.
 155         .balign 16
 156         .globl  _ffi_call_STDCALL
 157         .def    _ffi_call_STDCALL;      .scl    2;      .type   32;     .endef
 158 _ffi_call_STDCALL:
 159 .LFB2:
 160         pushl %ebp
 161 .LCFI2:
 162         movl  %esp,%ebp
 163 .LCFI3:
 164         # Make room for all of the new args.
 165         movl  16(%ebp),%ecx
 166         subl  %ecx,%esp
 167
 168         movl  %esp,%eax
 169
 170         # Place all of the ffi_prep_args in position
 171         pushl 12(%ebp)
 172         pushl %eax
 173         call  *8(%ebp)
 174
 175         # Return stack to previous state and call the function
 176         addl  $8,%esp
 177
 178         # FIXME: Align the stack to a 128-bit boundary to avoid
 179         # potential performance hits.
 180
 181         call  *28(%ebp)
 182
 183         # stdcall functions pop arguments off the stack themselves
 184
 185         # Load %ecx with the return type code
 186         movl  20(%ebp),%ecx
 187
 188         # If the return value pointer is NULL, assume no return value.
 189         cmpl  $0,24(%ebp)
 190         jne   sc_retint
 191
 192         # Even if there is no space for the return value, we are
 193         # obliged to handle floating-point values.
 194         cmpl  $FFI_TYPE_FLOAT,%ecx
 195         jne   sc_noretval
 196         fstp  %st(0)
 197
 198         jmp   sc_epilogue
 199
 200 sc_retint:
 201         cmpl  $FFI_TYPE_INT,%ecx
 202         jne   sc_retfloat
 203         # Load %ecx with the pointer to storage for the return value
 204         movl  24(%ebp),%ecx
 205         movl  %eax,0(%ecx)
 206         jmp   sc_epilogue
 207
 208 sc_retfloat:
 209         cmpl  $FFI_TYPE_FLOAT,%ecx
 210         jne   sc_retdouble
 211          # Load %ecx with the pointer to storage for the return value
 212         movl  24(%ebp),%ecx
 213         fstps (%ecx)
 214         jmp   sc_epilogue
 215
 216 sc_retdouble:
 217         cmpl  $FFI_TYPE_DOUBLE,%ecx
 218         jne   sc_retlongdouble
 219         # Load %ecx with the pointer to storage for the return value
 220         movl  24(%ebp),%ecx
 221         fstpl (%ecx)
 222         jmp   sc_epilogue
 223
 224 sc_retlongdouble:
 225         cmpl  $FFI_TYPE_LONGDOUBLE,%ecx
 226         jne   sc_retint64
 227         # Load %ecx with the pointer to storage for the return value
 228         movl  24(%ebp),%ecx
 229         fstpt (%ecx)
 230         jmp   sc_epilogue
 231
 232 sc_retint64:
 233         cmpl  $FFI_TYPE_SINT64,%ecx
 234         jne   sc_retstruct1b
 235         # Load %ecx with the pointer to storage for the return value
 236         movl  24(%ebp),%ecx
 237         movl  %eax,0(%ecx)
 238         movl  %edx,4(%ecx)
 239
 240 sc_retstruct1b:
 241         cmpl  $FFI_TYPE_SINT8,%ecx
 242         jne   sc_retstruct2b
 243         # Load %ecx with the pointer to storage for the return value
 244         movl  24(%ebp),%ecx
 245         movb  %al,0(%ecx)
 246         jmp   sc_epilogue
 247
 248 sc_retstruct2b:
 249         cmpl  $FFI_TYPE_SINT16,%ecx
 250         jne   sc_retstruct
 251         # Load %ecx with the pointer to storage for the return value
 252         movl  24(%ebp),%ecx
 253         movw  %ax,0(%ecx)
 254         jmp   sc_epilogue
 255
 256 sc_retstruct:
 257         # Nothing to do!
 258
 259 sc_noretval:
 260 sc_epilogue:
 261         movl %ebp,%esp
 262         popl %ebp
 263         ret
 264 .ffi_call_STDCALL_end:
 265 .LFE2:
 266
 267         # This assumes we are using gas.
 268         .balign 16
 269         .globl  _ffi_closure_SYSV
 270         .def    _ffi_closure_SYSV;      .scl    2;      .type   32;     .endef
 271 _ffi_closure_SYSV:
 272 .LFB3:
 273         pushl   %ebp
 274 .LCFI4:
 275         movl    %esp, %ebp
 276 .LCFI5:
 277         subl    $40, %esp
 278         leal    -24(%ebp), %edx
 279         movl    %edx, -12(%ebp) /* resp */
 280         leal    8(%ebp), %edx
 281         movl    %edx, 4(%esp)   /* args = __builtin_dwarf_cfa () */
 282         leal    -12(%ebp), %edx
 283         movl    %edx, (%esp)    /* &resp */
 284         call    _ffi_closure_SYSV_inner
 285         movl    -12(%ebp), %ecx
 286         cmpl    $FFI_TYPE_INT, %eax
 287         je      .Lcls_retint
 288         cmpl    $FFI_TYPE_FLOAT, %eax
 289         je      .Lcls_retfloat
 290         cmpl    $FFI_TYPE_DOUBLE, %eax
 291         je      .Lcls_retdouble
 292         cmpl    $FFI_TYPE_LONGDOUBLE, %eax
 293         je      .Lcls_retldouble
 294         cmpl    $FFI_TYPE_SINT64, %eax
 295         je      .Lcls_retllong
 296         cmpl    $FFI_TYPE_SINT8, %eax   /* 1-byte struct */
 297         je      .Lcls_retstruct1
 298         cmpl    $FFI_TYPE_SINT16, %eax  /* 2-bytes struct */
 299         je      .Lcls_retstruct2
 300 .Lcls_epilogue:
 301         movl    %ebp, %esp
 302         popl    %ebp
 303         ret
 304 .Lcls_retint:
 305         movl    (%ecx), %eax
 306         jmp     .Lcls_epilogue
 307 .Lcls_retfloat:
 308         flds    (%ecx)
 309         jmp     .Lcls_epilogue
 310 .Lcls_retdouble:
 311         fldl    (%ecx)
 312         jmp     .Lcls_epilogue
 313 .Lcls_retldouble:
 314         fldt    (%ecx)
 315         jmp     .Lcls_epilogue
 316 .Lcls_retllong:
 317         movl    (%ecx), %eax
 318         movl    4(%ecx), %edx
 319         jmp     .Lcls_epilogue
 320 .Lcls_retstruct1:
 321         movsbl  (%ecx), %eax
 322         jmp     .Lcls_epilogue
 323 .Lcls_retstruct2:
 324         movswl  (%ecx), %eax
 325         jmp     .Lcls_epilogue
 326 .ffi_closure_SYSV_end:
 327 .LFE3:
 328
 329 #if !FFI_NO_RAW_API
 330
 331 #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
 332 #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
 333 #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
 334 #define CIF_FLAGS_OFFSET 20
 335
 336         # This assumes we are using gas.
 337         .balign 16
 338         .globl  _ffi_closure_raw_SYSV
 339         .def    _ffi_closure_raw_SYSV;  .scl    2;      .type   32;     .endef
 340 _ffi_closure_raw_SYSV:
 341 .LFB4:
 342         pushl   %ebp
 343 .LCFI6:
 344         movl    %esp, %ebp
 345 .LCFI7:
 346         pushl   %esi
 347 .LCFI8:
 348         subl    $36, %esp
 349         movl    RAW_CLOSURE_CIF_OFFSET(%eax), %esi       /* closure->cif */
 350         movl    RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
 351         movl    %edx, 12(%esp)  /* user_data */
 352         leal    8(%ebp), %edx   /* __builtin_dwarf_cfa () */
 353         movl    %edx, 8(%esp)   /* raw_args */
 354         leal    -24(%ebp), %edx
 355         movl    %edx, 4(%esp)   /* &res */
 356         movl    %esi, (%esp)    /* cif */
 357         call    *RAW_CLOSURE_FUN_OFFSET(%eax)            /* closure->fun */
 358         movl    CIF_FLAGS_OFFSET(%esi), %eax             /* rtype */
 359         cmpl    $FFI_TYPE_INT, %eax
 360         je      .Lrcls_retint
 361         cmpl    $FFI_TYPE_FLOAT, %eax
 362         je      .Lrcls_retfloat
 363         cmpl    $FFI_TYPE_DOUBLE, %eax
 364         je      .Lrcls_retdouble
 365         cmpl    $FFI_TYPE_LONGDOUBLE, %eax
 366         je      .Lrcls_retldouble
 367         cmpl    $FFI_TYPE_SINT64, %eax
 368         je      .Lrcls_retllong
 369 .Lrcls_epilogue:
 370         addl    $36, %esp
 371         popl    %esi
 372         popl    %ebp
 373         ret
 374 .Lrcls_retint:
 375         movl    -24(%ebp), %eax
 376         jmp     .Lrcls_epilogue
 377 .Lrcls_retfloat:
 378         flds    -24(%ebp)
 379         jmp     .Lrcls_epilogue
 380 .Lrcls_retdouble:
 381         fldl    -24(%ebp)
 382         jmp     .Lrcls_epilogue
 383 .Lrcls_retldouble:
 384         fldt    -24(%ebp)
 385         jmp     .Lrcls_epilogue
 386 .Lrcls_retllong:
 387         movl    -24(%ebp), %eax
 388         movl    -20(%ebp), %edx
 389         jmp     .Lrcls_epilogue
 390 .ffi_closure_raw_SYSV_end:
 391 .LFE4:
 392
 393 #endif /* !FFI_NO_RAW_API */
 394
 395         # This assumes we are using gas.
 396         .balign 16
 397         .globl  _ffi_closure_STDCALL
 398         .def    _ffi_closure_STDCALL;   .scl    2;      .type   32;     .endef
 399 _ffi_closure_STDCALL:
 400 .LFB5:
 401         pushl   %ebp
 402 .LCFI9:
 403         movl    %esp, %ebp
 404 .LCFI10:
 405         subl    $40, %esp
 406         leal    -24(%ebp), %edx
 407         movl    %edx, -12(%ebp) /* resp */
 408         leal    12(%ebp), %edx  /* account for stub return address on stack */
 409         movl    %edx, 4(%esp)   /* args */
 410         leal    -12(%ebp), %edx
 411         movl    %edx, (%esp)    /* &resp */
 412         call    _ffi_closure_SYSV_inner
 413         movl    -12(%ebp), %ecx
 414         /* It would be nice to just share this code with the
 415            duplicate sequence in _ffi_closure_SYSV, if only
 416            there were some way to represent that in the EH info.  */
 417         cmpl    $FFI_TYPE_INT, %eax
 418         je      .Lscls_retint
 419         cmpl    $FFI_TYPE_FLOAT, %eax
 420         je      .Lscls_retfloat
 421         cmpl    $FFI_TYPE_DOUBLE, %eax
 422         je      .Lscls_retdouble
 423         cmpl    $FFI_TYPE_LONGDOUBLE, %eax
 424         je      .Lscls_retldouble
 425         cmpl    $FFI_TYPE_SINT64, %eax
 426         je      .Lscls_retllong
 427         cmpl    $FFI_TYPE_SINT8, %eax   /* 1-byte struct */
 428         je      .Lscls_retstruct1
 429         cmpl    $FFI_TYPE_SINT16, %eax  /* 2-bytes struct */
 430         je      .Lscls_retstruct2
 431 .Lscls_epilogue:
 432         movl    %ebp, %esp
 433         popl    %ebp
 434         ret
 435 .Lscls_retint:
 436         movl    (%ecx), %eax
 437         jmp     .Lscls_epilogue
 438 .Lscls_retfloat:
 439         flds    (%ecx)
 440         jmp     .Lscls_epilogue
 441 .Lscls_retdouble:
 442         fldl    (%ecx)
 443         jmp     .Lscls_epilogue
 444 .Lscls_retldouble:
 445         fldt    (%ecx)
 446         jmp     .Lscls_epilogue
 447 .Lscls_retllong:
 448         movl    (%ecx), %eax
 449         movl    4(%ecx), %edx
 450         jmp     .Lscls_epilogue
 451 .Lscls_retstruct1:
 452         movsbl  (%ecx), %eax
 453         jmp     .Lscls_epilogue
 454 .Lscls_retstruct2:
 455         movswl  (%ecx), %eax
 456         jmp     .Lscls_epilogue
 457 .ffi_closure_STDCALL_end:
 458 .LFE5:
 459
 460         .section        .eh_frame,"w"
 461 .Lframe1:
 462 .LSCIE1:
 463         .long   .LECIE1-.LASCIE1  /* Length of Common Information Entry */
 464 .LASCIE1:
 465         .long   0x0     /* CIE Identifier Tag */
 466         .byte   0x1     /* CIE Version */
 467 #ifdef __PIC__
 468         .ascii "zR\0"   /* CIE Augmentation */
 469 #else
 470         .ascii "\0"     /* CIE Augmentation */
 471 #endif
 472         .byte   0x1     /* .uleb128 0x1; CIE Code Alignment Factor */
 473         .byte   0x7c    /* .sleb128 -4; CIE Data Alignment Factor */
 474         .byte   0x8     /* CIE RA Column */
 475 #ifdef __PIC__
 476         .byte   0x1     /* .uleb128 0x1; Augmentation size */
 477         .byte   0x1b    /* FDE Encoding (pcrel sdata4) */
 478 #endif
 479         .byte   0xc     /* DW_CFA_def_cfa CFA = r4 + 4 = 4(%esp) */
 480         .byte   0x4     /* .uleb128 0x4 */
 481         .byte   0x4     /* .uleb128 0x4 */
 482         .byte   0x88    /* DW_CFA_offset, column 0x8 %eip at CFA + 1 * -4 */
 483         .byte   0x1     /* .uleb128 0x1 */
 484         .align 4
 485 .LECIE1:
 486
 487 .LSFDE1:
 488         .long   .LEFDE1-.LASFDE1        /* FDE Length */
 489 .LASFDE1:
 490         .long   .LASFDE1-.Lframe1       /* FDE CIE offset */
 491 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
 492         .long   .LFB1-. /* FDE initial location */
 493 #else
 494         .long   .LFB1
 495 #endif
 496         .long   .LFE1-.LFB1     /* FDE address range */
 497 #ifdef __PIC__
 498         .byte   0x0     /* .uleb128 0x0; Augmentation size */
 499 #endif
 500         /* DW_CFA_xxx CFI instructions go here.  */
 501
 502         .byte   0x4     /* DW_CFA_advance_loc4 */
 503         .long   .LCFI0-.LFB1
 504         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
 505         .byte   0x8     /* .uleb128 0x8 */
 506         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
 507         .byte   0x2     /* .uleb128 0x2 */
 508
 509         .byte   0x4     /* DW_CFA_advance_loc4 */
 510         .long   .LCFI1-.LCFI0
 511         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
 512         .byte   0x5     /* .uleb128 0x5 */
 513
 514         /* End of DW_CFA_xxx CFI instructions.  */
 515         .align 4
 516 .LEFDE1:
 517
 518
 519 .LSFDE2:
 520         .long   .LEFDE2-.LASFDE2        /* FDE Length */
 521 .LASFDE2:
 522         .long   .LASFDE2-.Lframe1       /* FDE CIE offset */
 523 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
 524         .long   .LFB2-. /* FDE initial location */
 525 #else
 526         .long   .LFB2
 527 #endif
 528         .long   .LFE2-.LFB2     /* FDE address range */
 529 #ifdef __PIC__
 530         .byte   0x0     /* .uleb128 0x0; Augmentation size */
 531 #endif
 532         /* DW_CFA_xxx CFI instructions go here.  */
 533
 534         .byte   0x4     /* DW_CFA_advance_loc4 */
 535         .long   .LCFI2-.LFB2
 536         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
 537         .byte   0x8     /* .uleb128 0x8 */
 538         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
 539         .byte   0x2     /* .uleb128 0x2 */
 540
 541         .byte   0x4     /* DW_CFA_advance_loc4 */
 542         .long   .LCFI3-.LCFI2
 543         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
 544         .byte   0x5     /* .uleb128 0x5 */
 545
 546         /* End of DW_CFA_xxx CFI instructions.  */
 547         .align 4
 548 .LEFDE2:
 549
 550
 551 .LSFDE3:
 552         .long   .LEFDE3-.LASFDE3        /* FDE Length */
 553 .LASFDE3:
 554         .long   .LASFDE3-.Lframe1       /* FDE CIE offset */
 555 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
 556         .long   .LFB3-. /* FDE initial location */
 557 #else
 558         .long   .LFB3
 559 #endif
 560         .long   .LFE3-.LFB3     /* FDE address range */
 561 #ifdef __PIC__
 562         .byte   0x0     /* .uleb128 0x0; Augmentation size */
 563 #endif
 564         /* DW_CFA_xxx CFI instructions go here.  */
 565
 566         .byte   0x4     /* DW_CFA_advance_loc4 */
 567         .long   .LCFI4-.LFB3
 568         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
 569         .byte   0x8     /* .uleb128 0x8 */
 570         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
 571         .byte   0x2     /* .uleb128 0x2 */
 572
 573         .byte   0x4     /* DW_CFA_advance_loc4 */
 574         .long   .LCFI5-.LCFI4
 575         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
 576         .byte   0x5     /* .uleb128 0x5 */
 577
 578         /* End of DW_CFA_xxx CFI instructions.  */
 579         .align 4
 580 .LEFDE3:
 581
 582 #if !FFI_NO_RAW_API
 583
 584 .LSFDE4:
 585         .long   .LEFDE4-.LASFDE4        /* FDE Length */
 586 .LASFDE4:
 587         .long   .LASFDE4-.Lframe1       /* FDE CIE offset */
 588 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
 589         .long   .LFB4-. /* FDE initial location */
 590 #else
 591         .long   .LFB4
 592 #endif
 593         .long   .LFE4-.LFB4     /* FDE address range */
 594 #ifdef __PIC__
 595         .byte   0x0     /* .uleb128 0x0; Augmentation size */
 596 #endif
 597         /* DW_CFA_xxx CFI instructions go here.  */
 598
 599         .byte   0x4     /* DW_CFA_advance_loc4 */
 600         .long   .LCFI6-.LFB4
 601         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
 602         .byte   0x8     /* .uleb128 0x8 */
 603         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
 604         .byte   0x2     /* .uleb128 0x2 */
 605
 606         .byte   0x4     /* DW_CFA_advance_loc4 */
 607         .long   .LCFI7-.LCFI6
 608         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
 609         .byte   0x5     /* .uleb128 0x5 */
 610
 611         .byte   0x4     /* DW_CFA_advance_loc4 */
 612         .long   .LCFI8-.LCFI7
 613         .byte   0x86    /* DW_CFA_offset, column 0x6 %esi at CFA + 3 * -4 */
 614         .byte   0x3     /* .uleb128 0x3 */
 615
 616         /* End of DW_CFA_xxx CFI instructions.  */
 617         .align 4
 618 .LEFDE4:
 619
 620 #endif /* !FFI_NO_RAW_API */
 621
 622 .LSFDE5:
 623         .long   .LEFDE5-.LASFDE5        /* FDE Length */
 624 .LASFDE5:
 625         .long   .LASFDE5-.Lframe1       /* FDE CIE offset */
 626 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
 627         .long   .LFB5-. /* FDE initial location */
 628 #else
 629         .long   .LFB5
 630 #endif
 631         .long   .LFE5-.LFB5     /* FDE address range */
 632 #ifdef __PIC__
 633         .byte   0x0     /* .uleb128 0x0; Augmentation size */
 634 #endif
 635         /* DW_CFA_xxx CFI instructions go here.  */
 636
 637         .byte   0x4     /* DW_CFA_advance_loc4 */
 638         .long   .LCFI9-.LFB5
 639         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
 640         .byte   0x8     /* .uleb128 0x8 */
 641         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
 642         .byte   0x2     /* .uleb128 0x2 */
 643
 644         .byte   0x4     /* DW_CFA_advance_loc4 */
 645         .long   .LCFI10-.LCFI9
 646         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
 647         .byte   0x5     /* .uleb128 0x5 */
 648
 649         /* End of DW_CFA_xxx CFI instructions.  */
 650         .align 4
 651 .LEFDE5: