OSDN Git Service

a6c9c0da101c5b4e5cc050284ba7b9b77b0ca380
[pf3gnuchains/gcc-fork.git] / 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: