Rebased from gcc
[libffi.git] / 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              Copyright (c) 2009  Daniel Witte
6                         
7  
8    X86 Foreign Function Interface
9  
10    Permission is hereby granted, free of charge, to any person obtaining
11    a copy of this software and associated documentation files (the
12    ``Software''), to deal in the Software without restriction, including
13    without limitation the rights to use, copy, modify, merge, publish,
14    distribute, sublicense, and/or sell copies of the Software, and to
15    permit persons to whom the Software is furnished to do so, subject to
16    the following conditions:
17  
18    The above copyright notice and this permission notice shall be included
19    in all copies or substantial portions of the Software.
20  
21    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
22    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
26    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28    DEALINGS IN THE SOFTWARE.
29    -----------------------------------------------------------------------
30    */
31  
32 #define LIBFFI_ASM
33 #include <fficonfig.h>
34 #include <ffi.h>
35
36 #ifdef _MSC_VER
37
38 .386
39 .MODEL FLAT, C
40
41 EXTRN ffi_closure_SYSV_inner:NEAR
42
43 _TEXT SEGMENT
44
45 ffi_call_win32 PROC NEAR,
46     ffi_prep_args : NEAR PTR DWORD,
47     ecif          : NEAR PTR DWORD,
48     cif_abi       : DWORD,
49     cif_bytes     : DWORD,
50     cif_flags     : DWORD,
51     rvalue        : NEAR PTR DWORD,
52     fn            : NEAR PTR DWORD
53
54         ;; Make room for all of the new args.
55         mov  ecx, cif_bytes
56         sub  esp, ecx
57
58         mov  eax, esp
59
60         ;; Place all of the ffi_prep_args in position
61         push ecif
62         push eax
63         call ffi_prep_args
64
65         ;; Return stack to previous state and call the function
66         add  esp, 8
67
68         ;; Handle thiscall and fastcall
69         cmp cif_abi, 3 ;; FFI_THISCALL
70         jz do_thiscall
71         cmp cif_abi, 4 ;; FFI_FASTCALL
72         jnz do_stdcall
73         mov ecx, DWORD PTR [esp]
74         mov edx, DWORD PTR [esp+4]
75         add esp, 8
76         jmp do_stdcall
77 do_thiscall:
78         mov ecx, DWORD PTR [esp]
79         add esp, 4
80 do_stdcall:
81         call fn
82
83         ;; cdecl:   we restore esp in the epilogue, so there's no need to
84         ;;          remove the space we pushed for the args.
85         ;; stdcall: the callee has already cleaned the stack.
86
87         ;; Load ecx with the return type code
88         mov  ecx, cif_flags
89
90         ;; If the return value pointer is NULL, assume no return value.
91         cmp  rvalue, 0
92         jne  ca_jumptable
93
94         ;; Even if there is no space for the return value, we are
95         ;; obliged to handle floating-point values.
96         cmp  ecx, FFI_TYPE_FLOAT
97         jne  ca_epilogue
98         fstp st(0)
99
100         jmp  ca_epilogue
101
102 ca_jumptable:
103         jmp  [ca_jumpdata + 4 * ecx]
104 ca_jumpdata:
105         ;; Do not insert anything here between label and jump table.
106         dd offset ca_epilogue       ;; FFI_TYPE_VOID
107         dd offset ca_retint         ;; FFI_TYPE_INT
108         dd offset ca_retfloat       ;; FFI_TYPE_FLOAT
109         dd offset ca_retdouble      ;; FFI_TYPE_DOUBLE
110         dd offset ca_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
111         dd offset ca_retint8        ;; FFI_TYPE_UINT8
112         dd offset ca_retint8        ;; FFI_TYPE_SINT8
113         dd offset ca_retint16       ;; FFI_TYPE_UINT16
114         dd offset ca_retint16       ;; FFI_TYPE_SINT16
115         dd offset ca_retint         ;; FFI_TYPE_UINT32
116         dd offset ca_retint         ;; FFI_TYPE_SINT32
117         dd offset ca_retint64       ;; FFI_TYPE_UINT64
118         dd offset ca_retint64       ;; FFI_TYPE_SINT64
119         dd offset ca_epilogue       ;; FFI_TYPE_STRUCT
120         dd offset ca_retint         ;; FFI_TYPE_POINTER
121         dd offset ca_retint8        ;; FFI_TYPE_SMALL_STRUCT_1B
122         dd offset ca_retint16       ;; FFI_TYPE_SMALL_STRUCT_2B
123         dd offset ca_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
124
125 ca_retint8:
126         ;; Load %ecx with the pointer to storage for the return value
127         mov   ecx, rvalue
128         mov   [ecx + 0], al
129         jmp   ca_epilogue
130
131 ca_retint16:
132         ;; Load %ecx with the pointer to storage for the return value
133         mov   ecx, rvalue
134         mov   [ecx + 0], ax
135         jmp   ca_epilogue
136
137 ca_retint:
138         ;; Load %ecx with the pointer to storage for the return value
139         mov   ecx, rvalue
140         mov   [ecx + 0], eax
141         jmp   ca_epilogue
142
143 ca_retint64:
144         ;; Load %ecx with the pointer to storage for the return value
145         mov   ecx, rvalue
146         mov   [ecx + 0], eax
147         mov   [ecx + 4], edx
148         jmp   ca_epilogue
149
150 ca_retfloat:
151         ;; Load %ecx with the pointer to storage for the return value
152         mov   ecx, rvalue
153         fstp  DWORD PTR [ecx]
154         jmp   ca_epilogue
155
156 ca_retdouble:
157         ;; Load %ecx with the pointer to storage for the return value
158         mov   ecx, rvalue
159         fstp  QWORD PTR [ecx]
160         jmp   ca_epilogue
161
162 ca_retlongdouble:
163         ;; Load %ecx with the pointer to storage for the return value
164         mov   ecx, rvalue
165         fstp  TBYTE PTR [ecx]
166         jmp   ca_epilogue
167
168 ca_epilogue:
169         ;; Epilogue code is autogenerated.
170         ret
171 ffi_call_win32 ENDP
172
173 ffi_closure_THISCALL PROC NEAR FORCEFRAME
174         push    ebp
175         mov     ebp, esp
176         sub     esp, 40
177         lea     edx, [ebp -24]
178         mov     [ebp - 12], edx /* resp */
179         lea     edx, [ebp + 12]  /* account for stub return address on stack */
180         jmp     stub
181 ffi_closure_THISCALL ENDP
182
183 ffi_closure_SYSV PROC NEAR FORCEFRAME
184     ;; the ffi_closure ctx is passed in eax by the trampoline.
185
186         sub  esp, 40
187         lea  edx, [ebp - 24]
188         mov  [ebp - 12], edx         ;; resp
189         lea  edx, [ebp + 8]
190 stub:
191         mov  [esp + 8], edx          ;; args
192         lea  edx, [ebp - 12]
193         mov  [esp + 4], edx          ;; &resp
194         mov  [esp], eax              ;; closure
195         call ffi_closure_SYSV_inner
196         mov  ecx, [ebp - 12]
197
198 cs_jumptable:
199         jmp  [cs_jumpdata + 4 * eax]
200 cs_jumpdata:
201         ;; Do not insert anything here between the label and jump table.
202         dd offset cs_epilogue       ;; FFI_TYPE_VOID
203         dd offset cs_retint         ;; FFI_TYPE_INT
204         dd offset cs_retfloat       ;; FFI_TYPE_FLOAT
205         dd offset cs_retdouble      ;; FFI_TYPE_DOUBLE
206         dd offset cs_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
207         dd offset cs_retint8        ;; FFI_TYPE_UINT8
208         dd offset cs_retint8        ;; FFI_TYPE_SINT8
209         dd offset cs_retint16       ;; FFI_TYPE_UINT16
210         dd offset cs_retint16       ;; FFI_TYPE_SINT16
211         dd offset cs_retint         ;; FFI_TYPE_UINT32
212         dd offset cs_retint         ;; FFI_TYPE_SINT32
213         dd offset cs_retint64       ;; FFI_TYPE_UINT64
214         dd offset cs_retint64       ;; FFI_TYPE_SINT64
215         dd offset cs_retstruct      ;; FFI_TYPE_STRUCT
216         dd offset cs_retint         ;; FFI_TYPE_POINTER
217         dd offset cs_retint8        ;; FFI_TYPE_SMALL_STRUCT_1B
218         dd offset cs_retint16       ;; FFI_TYPE_SMALL_STRUCT_2B
219         dd offset cs_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
220
221 cs_retint8:
222         mov   al, [ecx]
223         jmp   cs_epilogue
224
225 cs_retint16:
226         mov   ax, [ecx]
227         jmp   cs_epilogue
228
229 cs_retint:
230         mov   eax, [ecx]
231         jmp   cs_epilogue
232
233 cs_retint64:
234         mov   eax, [ecx + 0]
235         mov   edx, [ecx + 4]
236         jmp   cs_epilogue
237
238 cs_retfloat:
239         fld   DWORD PTR [ecx]
240         jmp   cs_epilogue
241
242 cs_retdouble:
243         fld   QWORD PTR [ecx]
244         jmp   cs_epilogue
245
246 cs_retlongdouble:
247         fld   TBYTE PTR [ecx]
248         jmp   cs_epilogue
249
250 cs_retstruct:
251         ;; Caller expects us to pop struct return value pointer hidden arg.
252         ;; Epilogue code is autogenerated.
253         ret     4
254
255 cs_epilogue:
256         ;; Epilogue code is autogenerated.
257         ret
258 ffi_closure_SYSV ENDP
259
260 #if !FFI_NO_RAW_API
261
262 #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) AND NOT 3)
263 #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
264 #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
265 #define CIF_FLAGS_OFFSET 20
266
267 ffi_closure_raw_SYSV PROC NEAR USES esi
268     ;; the ffi_closure ctx is passed in eax by the trampoline.
269
270         sub  esp, 40
271         mov  esi, [eax + RAW_CLOSURE_CIF_OFFSET]        ;; closure->cif
272         mov  edx, [eax + RAW_CLOSURE_USER_DATA_OFFSET]  ;; closure->user_data
273         mov  [esp + 12], edx                            ;; user_data
274         lea  edx, [ebp + 8]
275         mov  [esp + 8], edx                             ;; raw_args
276         lea  edx, [ebp - 24]
277         mov  [esp + 4], edx                             ;; &res
278         mov  [esp], esi                                 ;; cif
279         call DWORD PTR [eax + RAW_CLOSURE_FUN_OFFSET]   ;; closure->fun
280         mov  eax, [esi + CIF_FLAGS_OFFSET]              ;; cif->flags
281         lea  ecx, [ebp - 24]
282
283 cr_jumptable:
284         jmp  [cr_jumpdata + 4 * eax]
285 cr_jumpdata:
286         ;; Do not insert anything here between the label and jump table.
287         dd offset cr_epilogue       ;; FFI_TYPE_VOID
288         dd offset cr_retint         ;; FFI_TYPE_INT
289         dd offset cr_retfloat       ;; FFI_TYPE_FLOAT
290         dd offset cr_retdouble      ;; FFI_TYPE_DOUBLE
291         dd offset cr_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
292         dd offset cr_retint8        ;; FFI_TYPE_UINT8
293         dd offset cr_retint8        ;; FFI_TYPE_SINT8
294         dd offset cr_retint16       ;; FFI_TYPE_UINT16
295         dd offset cr_retint16       ;; FFI_TYPE_SINT16
296         dd offset cr_retint         ;; FFI_TYPE_UINT32
297         dd offset cr_retint         ;; FFI_TYPE_SINT32
298         dd offset cr_retint64       ;; FFI_TYPE_UINT64
299         dd offset cr_retint64       ;; FFI_TYPE_SINT64
300         dd offset cr_epilogue       ;; FFI_TYPE_STRUCT
301         dd offset cr_retint         ;; FFI_TYPE_POINTER
302         dd offset cr_retint8        ;; FFI_TYPE_SMALL_STRUCT_1B
303         dd offset cr_retint16       ;; FFI_TYPE_SMALL_STRUCT_2B
304         dd offset cr_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
305
306 cr_retint8:
307         mov   al, [ecx]
308         jmp   cr_epilogue
309
310 cr_retint16:
311         mov   ax, [ecx]
312         jmp   cr_epilogue
313
314 cr_retint:
315         mov   eax, [ecx]
316         jmp   cr_epilogue
317
318 cr_retint64:
319         mov   eax, [ecx + 0]
320         mov   edx, [ecx + 4]
321         jmp   cr_epilogue
322
323 cr_retfloat:
324         fld   DWORD PTR [ecx]
325         jmp   cr_epilogue
326
327 cr_retdouble:
328         fld   QWORD PTR [ecx]
329         jmp   cr_epilogue
330
331 cr_retlongdouble:
332         fld   TBYTE PTR [ecx]
333         jmp   cr_epilogue
334
335 cr_epilogue:
336         ;; Epilogue code is autogenerated.
337         ret
338 ffi_closure_raw_SYSV ENDP
339
340 #endif /* !FFI_NO_RAW_API */
341
342 ffi_closure_STDCALL PROC NEAR FORCEFRAME
343     ;; the ffi_closure ctx is passed in eax by the trampoline.
344
345         sub  esp, 40
346         lea  edx, [ebp - 24]
347         mov  [ebp - 12], edx         ;; resp
348         lea  edx, [ebp + 12]         ;; account for stub return address on stack
349         mov  [esp + 8], edx          ;; args
350         lea  edx, [ebp - 12]
351         mov  [esp + 4], edx          ;; &resp
352         mov  [esp], eax              ;; closure
353         call ffi_closure_SYSV_inner
354         mov  ecx, [ebp - 12]
355
356 cd_jumptable:
357         jmp  [cd_jumpdata + 4 * eax]
358 cd_jumpdata:
359         ;; Do not insert anything here between the label and jump table.
360         dd offset cd_epilogue       ;; FFI_TYPE_VOID
361         dd offset cd_retint         ;; FFI_TYPE_INT
362         dd offset cd_retfloat       ;; FFI_TYPE_FLOAT
363         dd offset cd_retdouble      ;; FFI_TYPE_DOUBLE
364         dd offset cd_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
365         dd offset cd_retint8        ;; FFI_TYPE_UINT8
366         dd offset cd_retint8        ;; FFI_TYPE_SINT8
367         dd offset cd_retint16       ;; FFI_TYPE_UINT16
368         dd offset cd_retint16       ;; FFI_TYPE_SINT16
369         dd offset cd_retint         ;; FFI_TYPE_UINT32
370         dd offset cd_retint         ;; FFI_TYPE_SINT32
371         dd offset cd_retint64       ;; FFI_TYPE_UINT64
372         dd offset cd_retint64       ;; FFI_TYPE_SINT64
373         dd offset cd_epilogue       ;; FFI_TYPE_STRUCT
374         dd offset cd_retint         ;; FFI_TYPE_POINTER
375         dd offset cd_retint8        ;; FFI_TYPE_SMALL_STRUCT_1B
376         dd offset cd_retint16       ;; FFI_TYPE_SMALL_STRUCT_2B
377         dd offset cd_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
378
379 cd_retint8:
380         mov   al, [ecx]
381         jmp   cd_epilogue
382
383 cd_retint16:
384         mov   ax, [ecx]
385         jmp   cd_epilogue
386
387 cd_retint:
388         mov   eax, [ecx]
389         jmp   cd_epilogue
390
391 cd_retint64:
392         mov   eax, [ecx + 0]
393         mov   edx, [ecx + 4]
394         jmp   cd_epilogue
395
396 cd_retfloat:
397         fld   DWORD PTR [ecx]
398         jmp   cd_epilogue
399
400 cd_retdouble:
401         fld   QWORD PTR [ecx]
402         jmp   cd_epilogue
403
404 cd_retlongdouble:
405         fld   TBYTE PTR [ecx]
406         jmp   cd_epilogue
407
408 cd_epilogue:
409         ;; Epilogue code is autogenerated.
410         ret
411 ffi_closure_STDCALL ENDP
412
413 _TEXT ENDS
414 END
415
416 #else
417
418         .text
419  
420         # This assumes we are using gas.
421         .balign 16
422         .globl  _ffi_call_win32
423 #ifndef __OS2__
424         .def    _ffi_call_win32;        .scl    2;      .type   32;     .endef
425 #endif
426 _ffi_call_win32:
427 .LFB1:
428         pushl %ebp
429 .LCFI0:
430         movl  %esp,%ebp
431 .LCFI1:
432         # Make room for all of the new args.
433         movl  20(%ebp),%ecx                                                     
434         subl  %ecx,%esp
435  
436         movl  %esp,%eax
437  
438         # Place all of the ffi_prep_args in position
439         pushl 12(%ebp)
440         pushl %eax
441         call  *8(%ebp)
442  
443         # Return stack to previous state and call the function
444         addl  $8,%esp
445
446         # Handle fastcall and thiscall
447         cmpl $3, 16(%ebp)  # FFI_THISCALL
448         jz .do_thiscall
449         cmpl $4, 16(%ebp) # FFI_FASTCALL
450         jnz .do_fncall
451         movl (%esp), %ecx
452         movl 4(%esp), %edx
453         addl $8, %esp
454         jmp .do_fncall
455 .do_thiscall:
456         movl (%esp), %ecx
457         addl $4, %esp
458
459 .do_fncall:
460          
461         # FIXME: Align the stack to a 128-bit boundary to avoid
462         # potential performance hits.
463
464         call  *32(%ebp)
465  
466         # stdcall functions pop arguments off the stack themselves
467
468         # Load %ecx with the return type code
469         movl  24(%ebp),%ecx
470  
471         # If the return value pointer is NULL, assume no return value.
472         cmpl  $0,28(%ebp)
473         jne   0f
474  
475         # Even if there is no space for the return value, we are
476         # obliged to handle floating-point values.
477         cmpl  $FFI_TYPE_FLOAT,%ecx
478         jne   .Lnoretval
479         fstp  %st(0)
480  
481         jmp   .Lepilogue
482
483 0:
484         call    1f
485         # Do not insert anything here between the call and the jump table.
486 .Lstore_table:
487         .long   .Lnoretval              /* FFI_TYPE_VOID */
488         .long   .Lretint                /* FFI_TYPE_INT */
489         .long   .Lretfloat              /* FFI_TYPE_FLOAT */
490         .long   .Lretdouble             /* FFI_TYPE_DOUBLE */
491         .long   .Lretlongdouble         /* FFI_TYPE_LONGDOUBLE */
492         .long   .Lretuint8              /* FFI_TYPE_UINT8 */
493         .long   .Lretsint8              /* FFI_TYPE_SINT8 */
494         .long   .Lretuint16             /* FFI_TYPE_UINT16 */
495         .long   .Lretsint16             /* FFI_TYPE_SINT16 */
496         .long   .Lretint                /* FFI_TYPE_UINT32 */
497         .long   .Lretint                /* FFI_TYPE_SINT32 */
498         .long   .Lretint64              /* FFI_TYPE_UINT64 */
499         .long   .Lretint64              /* FFI_TYPE_SINT64 */
500         .long   .Lretstruct             /* FFI_TYPE_STRUCT */
501         .long   .Lretint                /* FFI_TYPE_POINTER */
502         .long   .Lretstruct1b           /* FFI_TYPE_SMALL_STRUCT_1B */
503         .long   .Lretstruct2b           /* FFI_TYPE_SMALL_STRUCT_2B */
504         .long   .Lretstruct4b           /* FFI_TYPE_SMALL_STRUCT_4B */
505 1:
506         add     %ecx, %ecx
507         add     %ecx, %ecx
508         add     (%esp),%ecx
509         add     $4, %esp
510         jmp     *(%ecx)
511
512         /* Sign/zero extend as appropriate.  */
513 .Lretsint8:
514         movsbl  %al, %eax
515         jmp     .Lretint
516
517 .Lretsint16:
518         movswl  %ax, %eax
519         jmp     .Lretint
520
521 .Lretuint8:
522         movzbl  %al, %eax
523         jmp     .Lretint
524
525 .Lretuint16:
526         movzwl  %ax, %eax
527         jmp     .Lretint
528
529 .Lretint:
530         # Load %ecx with the pointer to storage for the return value
531         movl  28(%ebp),%ecx
532         movl  %eax,0(%ecx)
533         jmp   .Lepilogue
534  
535 .Lretfloat:
536          # Load %ecx with the pointer to storage for the return value
537         movl  28(%ebp),%ecx
538         fstps (%ecx)
539         jmp   .Lepilogue
540  
541 .Lretdouble:
542         # Load %ecx with the pointer to storage for the return value
543         movl  28(%ebp),%ecx
544         fstpl (%ecx)
545         jmp   .Lepilogue
546  
547 .Lretlongdouble:
548         # Load %ecx with the pointer to storage for the return value
549         movl  28(%ebp),%ecx
550         fstpt (%ecx)
551         jmp   .Lepilogue
552  
553 .Lretint64:
554         # Load %ecx with the pointer to storage for the return value
555         movl  28(%ebp),%ecx
556         movl  %eax,0(%ecx)
557         movl  %edx,4(%ecx)
558         jmp   .Lepilogue
559
560 .Lretstruct1b:
561         # Load %ecx with the pointer to storage for the return value
562         movl  28(%ebp),%ecx
563         movb  %al,0(%ecx)
564         jmp   .Lepilogue
565  
566 .Lretstruct2b:
567         # Load %ecx with the pointer to storage for the return value
568         movl  28(%ebp),%ecx
569         movw  %ax,0(%ecx)
570         jmp   .Lepilogue
571
572 .Lretstruct4b:
573         # Load %ecx with the pointer to storage for the return value
574         movl  28(%ebp),%ecx
575         movl  %eax,0(%ecx)
576         jmp   .Lepilogue
577
578 .Lretstruct:
579         # Nothing to do!
580  
581 .Lnoretval:
582 .Lepilogue:
583         movl %ebp,%esp
584         popl %ebp
585         ret
586 .ffi_call_win32_end:
587         .balign 16
588         .globl  _ffi_closure_THISCALL
589 #ifndef __OS2__
590         .def    _ffi_closure_THISCALL;  .scl    2;      .type   32;     .endef
591 #endif
592 _ffi_closure_THISCALL:
593         pushl   %ebp
594         movl    %esp, %ebp
595         subl    $40, %esp
596         leal    -24(%ebp), %edx
597         movl    %edx, -12(%ebp) /* resp */
598         leal    12(%ebp), %edx  /* account for stub return address on stack */
599         jmp     .stub
600 .LFE1:
601
602         # This assumes we are using gas.
603         .balign 16
604         .globl  _ffi_closure_SYSV
605 #ifndef __OS2__
606         .def    _ffi_closure_SYSV;      .scl    2;      .type   32;     .endef
607 #endif
608 _ffi_closure_SYSV:
609 .LFB3:
610         pushl   %ebp
611 .LCFI4:
612         movl    %esp, %ebp
613 .LCFI5:
614         subl    $40, %esp
615         leal    -24(%ebp), %edx
616         movl    %edx, -12(%ebp) /* resp */
617         leal    8(%ebp), %edx
618 .stub:
619         movl    %edx, 4(%esp)   /* args = __builtin_dwarf_cfa () */
620         leal    -12(%ebp), %edx
621         movl    %edx, (%esp)    /* &resp */
622         call    _ffi_closure_SYSV_inner
623         movl    -12(%ebp), %ecx
624
625 0:
626         call    1f
627         # Do not insert anything here between the call and the jump table.
628 .Lcls_store_table:
629         .long   .Lcls_noretval          /* FFI_TYPE_VOID */
630         .long   .Lcls_retint            /* FFI_TYPE_INT */
631         .long   .Lcls_retfloat          /* FFI_TYPE_FLOAT */
632         .long   .Lcls_retdouble         /* FFI_TYPE_DOUBLE */
633         .long   .Lcls_retldouble        /* FFI_TYPE_LONGDOUBLE */
634         .long   .Lcls_retuint8          /* FFI_TYPE_UINT8 */
635         .long   .Lcls_retsint8          /* FFI_TYPE_SINT8 */
636         .long   .Lcls_retuint16         /* FFI_TYPE_UINT16 */
637         .long   .Lcls_retsint16         /* FFI_TYPE_SINT16 */
638         .long   .Lcls_retint            /* FFI_TYPE_UINT32 */
639         .long   .Lcls_retint            /* FFI_TYPE_SINT32 */
640         .long   .Lcls_retllong          /* FFI_TYPE_UINT64 */
641         .long   .Lcls_retllong          /* FFI_TYPE_SINT64 */
642         .long   .Lcls_retstruct         /* FFI_TYPE_STRUCT */
643         .long   .Lcls_retint            /* FFI_TYPE_POINTER */
644         .long   .Lcls_retstruct1        /* FFI_TYPE_SMALL_STRUCT_1B */
645         .long   .Lcls_retstruct2        /* FFI_TYPE_SMALL_STRUCT_2B */
646         .long   .Lcls_retstruct4        /* FFI_TYPE_SMALL_STRUCT_4B */
647
648 1:
649         add     %eax, %eax
650         add     %eax, %eax
651         add     (%esp),%eax
652         add     $4, %esp
653         jmp     *(%eax)
654
655         /* Sign/zero extend as appropriate.  */
656 .Lcls_retsint8:
657         movsbl  (%ecx), %eax
658         jmp     .Lcls_epilogue
659
660 .Lcls_retsint16:
661         movswl  (%ecx), %eax
662         jmp     .Lcls_epilogue
663
664 .Lcls_retuint8:
665         movzbl  (%ecx), %eax
666         jmp     .Lcls_epilogue
667
668 .Lcls_retuint16:
669         movzwl  (%ecx), %eax
670         jmp     .Lcls_epilogue
671
672 .Lcls_retint:
673         movl    (%ecx), %eax
674         jmp     .Lcls_epilogue
675
676 .Lcls_retfloat:
677         flds    (%ecx)
678         jmp     .Lcls_epilogue
679
680 .Lcls_retdouble:
681         fldl    (%ecx)
682         jmp     .Lcls_epilogue
683
684 .Lcls_retldouble:
685         fldt    (%ecx)
686         jmp     .Lcls_epilogue
687
688 .Lcls_retllong:
689         movl    (%ecx), %eax
690         movl    4(%ecx), %edx
691         jmp     .Lcls_epilogue
692
693 .Lcls_retstruct1:
694         movsbl  (%ecx), %eax
695         jmp     .Lcls_epilogue
696
697 .Lcls_retstruct2:
698         movswl  (%ecx), %eax
699         jmp     .Lcls_epilogue
700
701 .Lcls_retstruct4:
702         movl    (%ecx), %eax
703         jmp     .Lcls_epilogue
704
705 .Lcls_retstruct:
706         # Caller expects us to pop struct return value pointer hidden arg.
707         movl    %ebp, %esp
708         popl    %ebp
709         ret     $0x4
710
711 .Lcls_noretval:
712 .Lcls_epilogue:
713         movl    %ebp, %esp
714         popl    %ebp
715         ret
716 .ffi_closure_SYSV_end:
717 .LFE3:
718
719 #if !FFI_NO_RAW_API
720
721 #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
722 #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
723 #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
724 #define CIF_FLAGS_OFFSET 20
725
726         # This assumes we are using gas.
727         .balign 16
728         .globl  _ffi_closure_raw_SYSV
729 #ifndef __OS2__
730         .def    _ffi_closure_raw_SYSV;  .scl    2;      .type   32;     .endef
731 #endif
732 _ffi_closure_raw_SYSV:
733 .LFB4:
734         pushl   %ebp
735 .LCFI6:
736         movl    %esp, %ebp
737 .LCFI7:
738         pushl   %esi
739 .LCFI8:
740         subl    $36, %esp
741         movl    RAW_CLOSURE_CIF_OFFSET(%eax), %esi       /* closure->cif */
742         movl    RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
743         movl    %edx, 12(%esp)  /* user_data */
744         leal    8(%ebp), %edx   /* __builtin_dwarf_cfa () */
745         movl    %edx, 8(%esp)   /* raw_args */
746         leal    -24(%ebp), %edx
747         movl    %edx, 4(%esp)   /* &res */
748         movl    %esi, (%esp)    /* cif */
749         call    *RAW_CLOSURE_FUN_OFFSET(%eax)            /* closure->fun */
750         movl    CIF_FLAGS_OFFSET(%esi), %eax             /* rtype */
751 0:
752         call    1f
753         # Do not insert anything here between the call and the jump table.
754 .Lrcls_store_table:
755         .long   .Lrcls_noretval         /* FFI_TYPE_VOID */
756         .long   .Lrcls_retint           /* FFI_TYPE_INT */
757         .long   .Lrcls_retfloat         /* FFI_TYPE_FLOAT */
758         .long   .Lrcls_retdouble        /* FFI_TYPE_DOUBLE */
759         .long   .Lrcls_retldouble       /* FFI_TYPE_LONGDOUBLE */
760         .long   .Lrcls_retuint8         /* FFI_TYPE_UINT8 */
761         .long   .Lrcls_retsint8         /* FFI_TYPE_SINT8 */
762         .long   .Lrcls_retuint16        /* FFI_TYPE_UINT16 */
763         .long   .Lrcls_retsint16        /* FFI_TYPE_SINT16 */
764         .long   .Lrcls_retint           /* FFI_TYPE_UINT32 */
765         .long   .Lrcls_retint           /* FFI_TYPE_SINT32 */
766         .long   .Lrcls_retllong         /* FFI_TYPE_UINT64 */
767         .long   .Lrcls_retllong         /* FFI_TYPE_SINT64 */
768         .long   .Lrcls_retstruct        /* FFI_TYPE_STRUCT */
769         .long   .Lrcls_retint           /* FFI_TYPE_POINTER */
770         .long   .Lrcls_retstruct1       /* FFI_TYPE_SMALL_STRUCT_1B */
771         .long   .Lrcls_retstruct2       /* FFI_TYPE_SMALL_STRUCT_2B */
772         .long   .Lrcls_retstruct4       /* FFI_TYPE_SMALL_STRUCT_4B */
773 1:
774         add     %eax, %eax
775         add     %eax, %eax
776         add     (%esp),%eax
777         add     $4, %esp
778         jmp     *(%eax)
779
780         /* Sign/zero extend as appropriate.  */
781 .Lrcls_retsint8:
782         movsbl  -24(%ebp), %eax
783         jmp     .Lrcls_epilogue
784
785 .Lrcls_retsint16:
786         movswl  -24(%ebp), %eax
787         jmp     .Lrcls_epilogue
788
789 .Lrcls_retuint8:
790         movzbl  -24(%ebp), %eax
791         jmp     .Lrcls_epilogue
792
793 .Lrcls_retuint16:
794         movzwl  -24(%ebp), %eax
795         jmp     .Lrcls_epilogue
796
797 .Lrcls_retint:
798         movl    -24(%ebp), %eax
799         jmp     .Lrcls_epilogue
800
801 .Lrcls_retfloat:
802         flds    -24(%ebp)
803         jmp     .Lrcls_epilogue
804
805 .Lrcls_retdouble:
806         fldl    -24(%ebp)
807         jmp     .Lrcls_epilogue
808
809 .Lrcls_retldouble:
810         fldt    -24(%ebp)
811         jmp     .Lrcls_epilogue
812
813 .Lrcls_retllong:
814         movl    -24(%ebp), %eax
815         movl    -20(%ebp), %edx
816         jmp     .Lrcls_epilogue
817
818 .Lrcls_retstruct1:
819         movsbl  -24(%ebp), %eax
820         jmp     .Lrcls_epilogue
821
822 .Lrcls_retstruct2:
823         movswl  -24(%ebp), %eax
824         jmp     .Lrcls_epilogue
825
826 .Lrcls_retstruct4:
827         movl    -24(%ebp), %eax
828         jmp     .Lrcls_epilogue
829
830 .Lrcls_retstruct:
831         # Nothing to do!
832
833 .Lrcls_noretval:
834 .Lrcls_epilogue:
835         addl    $36, %esp
836         popl    %esi
837         popl    %ebp
838         ret
839 .ffi_closure_raw_SYSV_end:
840 .LFE4:
841
842 #endif /* !FFI_NO_RAW_API */
843
844         # This assumes we are using gas.
845         .balign 16
846         .globl  _ffi_closure_STDCALL
847 #ifndef __OS2__
848         .def    _ffi_closure_STDCALL;   .scl    2;      .type   32;     .endef
849 #endif
850 _ffi_closure_STDCALL:
851 .LFB5:
852         pushl   %ebp
853 .LCFI9:
854         movl    %esp, %ebp
855 .LCFI10:
856         subl    $40, %esp
857         leal    -24(%ebp), %edx
858         movl    %edx, -12(%ebp) /* resp */
859         leal    12(%ebp), %edx  /* account for stub return address on stack */
860         movl    %edx, 4(%esp)   /* args */
861         leal    -12(%ebp), %edx
862         movl    %edx, (%esp)    /* &resp */
863         call    _ffi_closure_SYSV_inner
864         movl    -12(%ebp), %ecx
865 0:
866         call    1f
867         # Do not insert anything here between the call and the jump table.
868 .Lscls_store_table:
869         .long   .Lscls_noretval         /* FFI_TYPE_VOID */
870         .long   .Lscls_retint           /* FFI_TYPE_INT */
871         .long   .Lscls_retfloat         /* FFI_TYPE_FLOAT */
872         .long   .Lscls_retdouble        /* FFI_TYPE_DOUBLE */
873         .long   .Lscls_retldouble       /* FFI_TYPE_LONGDOUBLE */
874         .long   .Lscls_retuint8         /* FFI_TYPE_UINT8 */
875         .long   .Lscls_retsint8         /* FFI_TYPE_SINT8 */
876         .long   .Lscls_retuint16        /* FFI_TYPE_UINT16 */
877         .long   .Lscls_retsint16        /* FFI_TYPE_SINT16 */
878         .long   .Lscls_retint           /* FFI_TYPE_UINT32 */
879         .long   .Lscls_retint           /* FFI_TYPE_SINT32 */
880         .long   .Lscls_retllong         /* FFI_TYPE_UINT64 */
881         .long   .Lscls_retllong         /* FFI_TYPE_SINT64 */
882         .long   .Lscls_retstruct        /* FFI_TYPE_STRUCT */
883         .long   .Lscls_retint           /* FFI_TYPE_POINTER */
884         .long   .Lscls_retstruct1       /* FFI_TYPE_SMALL_STRUCT_1B */
885         .long   .Lscls_retstruct2       /* FFI_TYPE_SMALL_STRUCT_2B */
886         .long   .Lscls_retstruct4       /* FFI_TYPE_SMALL_STRUCT_4B */
887 1:
888         add     %eax, %eax
889         add     %eax, %eax
890         add     (%esp),%eax
891         add     $4, %esp
892         jmp     *(%eax)
893
894         /* Sign/zero extend as appropriate.  */
895 .Lscls_retsint8:
896         movsbl  (%ecx), %eax
897         jmp     .Lscls_epilogue
898
899 .Lscls_retsint16:
900         movswl  (%ecx), %eax
901         jmp     .Lscls_epilogue
902
903 .Lscls_retuint8:
904         movzbl  (%ecx), %eax
905         jmp     .Lscls_epilogue
906
907 .Lscls_retuint16:
908         movzwl  (%ecx), %eax
909         jmp     .Lscls_epilogue
910
911 .Lscls_retint:
912         movl    (%ecx), %eax
913         jmp     .Lscls_epilogue
914
915 .Lscls_retfloat:
916         flds    (%ecx)
917         jmp     .Lscls_epilogue
918
919 .Lscls_retdouble:
920         fldl    (%ecx)
921         jmp     .Lscls_epilogue
922
923 .Lscls_retldouble:
924         fldt    (%ecx)
925         jmp     .Lscls_epilogue
926
927 .Lscls_retllong:
928         movl    (%ecx), %eax
929         movl    4(%ecx), %edx
930         jmp     .Lscls_epilogue
931
932 .Lscls_retstruct1:
933         movsbl  (%ecx), %eax
934         jmp     .Lscls_epilogue
935
936 .Lscls_retstruct2:
937         movswl  (%ecx), %eax
938         jmp     .Lscls_epilogue
939
940 .Lscls_retstruct4:
941         movl    (%ecx), %eax
942         jmp     .Lscls_epilogue
943
944 .Lscls_retstruct:
945         # Nothing to do!
946
947 .Lscls_noretval:
948 .Lscls_epilogue:
949         movl    %ebp, %esp
950         popl    %ebp
951         ret
952 .ffi_closure_STDCALL_end:
953 .LFE5:
954
955 #ifndef __OS2__
956         .section        .eh_frame,"w"
957 #endif
958 .Lframe1:
959 .LSCIE1:
960         .long   .LECIE1-.LASCIE1  /* Length of Common Information Entry */
961 .LASCIE1:
962         .long   0x0     /* CIE Identifier Tag */
963         .byte   0x1     /* CIE Version */
964 #ifdef __PIC__
965         .ascii "zR\0"   /* CIE Augmentation */
966 #else
967         .ascii "\0"     /* CIE Augmentation */
968 #endif
969         .byte   0x1     /* .uleb128 0x1; CIE Code Alignment Factor */
970         .byte   0x7c    /* .sleb128 -4; CIE Data Alignment Factor */
971         .byte   0x8     /* CIE RA Column */
972 #ifdef __PIC__
973         .byte   0x1     /* .uleb128 0x1; Augmentation size */
974         .byte   0x1b    /* FDE Encoding (pcrel sdata4) */
975 #endif
976         .byte   0xc     /* DW_CFA_def_cfa CFA = r4 + 4 = 4(%esp) */
977         .byte   0x4     /* .uleb128 0x4 */
978         .byte   0x4     /* .uleb128 0x4 */
979         .byte   0x88    /* DW_CFA_offset, column 0x8 %eip at CFA + 1 * -4 */
980         .byte   0x1     /* .uleb128 0x1 */
981         .align 4
982 .LECIE1:
983
984 .LSFDE1:
985         .long   .LEFDE1-.LASFDE1        /* FDE Length */
986 .LASFDE1:
987         .long   .LASFDE1-.Lframe1       /* FDE CIE offset */
988 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
989         .long   .LFB1-. /* FDE initial location */
990 #else
991         .long   .LFB1
992 #endif
993         .long   .LFE1-.LFB1     /* FDE address range */
994 #ifdef __PIC__
995         .byte   0x0     /* .uleb128 0x0; Augmentation size */
996 #endif
997         /* DW_CFA_xxx CFI instructions go here.  */
998
999         .byte   0x4     /* DW_CFA_advance_loc4 */
1000         .long   .LCFI0-.LFB1
1001         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
1002         .byte   0x8     /* .uleb128 0x8 */
1003         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
1004         .byte   0x2     /* .uleb128 0x2 */
1005
1006         .byte   0x4     /* DW_CFA_advance_loc4 */
1007         .long   .LCFI1-.LCFI0
1008         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
1009         .byte   0x5     /* .uleb128 0x5 */
1010
1011         /* End of DW_CFA_xxx CFI instructions.  */
1012         .align 4
1013 .LEFDE1:
1014
1015
1016 .LSFDE3:
1017         .long   .LEFDE3-.LASFDE3        /* FDE Length */
1018 .LASFDE3:
1019         .long   .LASFDE3-.Lframe1       /* FDE CIE offset */
1020 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
1021         .long   .LFB3-. /* FDE initial location */
1022 #else
1023         .long   .LFB3
1024 #endif
1025         .long   .LFE3-.LFB3     /* FDE address range */
1026 #ifdef __PIC__
1027         .byte   0x0     /* .uleb128 0x0; Augmentation size */
1028 #endif
1029         /* DW_CFA_xxx CFI instructions go here.  */
1030
1031         .byte   0x4     /* DW_CFA_advance_loc4 */
1032         .long   .LCFI4-.LFB3
1033         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
1034         .byte   0x8     /* .uleb128 0x8 */
1035         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
1036         .byte   0x2     /* .uleb128 0x2 */
1037
1038         .byte   0x4     /* DW_CFA_advance_loc4 */
1039         .long   .LCFI5-.LCFI4
1040         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
1041         .byte   0x5     /* .uleb128 0x5 */
1042
1043         /* End of DW_CFA_xxx CFI instructions.  */
1044         .align 4
1045 .LEFDE3:
1046
1047 #if !FFI_NO_RAW_API
1048
1049 .LSFDE4:
1050         .long   .LEFDE4-.LASFDE4        /* FDE Length */
1051 .LASFDE4:
1052         .long   .LASFDE4-.Lframe1       /* FDE CIE offset */
1053 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
1054         .long   .LFB4-. /* FDE initial location */
1055 #else
1056         .long   .LFB4
1057 #endif
1058         .long   .LFE4-.LFB4     /* FDE address range */
1059 #ifdef __PIC__
1060         .byte   0x0     /* .uleb128 0x0; Augmentation size */
1061 #endif
1062         /* DW_CFA_xxx CFI instructions go here.  */
1063
1064         .byte   0x4     /* DW_CFA_advance_loc4 */
1065         .long   .LCFI6-.LFB4
1066         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
1067         .byte   0x8     /* .uleb128 0x8 */
1068         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
1069         .byte   0x2     /* .uleb128 0x2 */
1070
1071         .byte   0x4     /* DW_CFA_advance_loc4 */
1072         .long   .LCFI7-.LCFI6
1073         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
1074         .byte   0x5     /* .uleb128 0x5 */
1075
1076         .byte   0x4     /* DW_CFA_advance_loc4 */
1077         .long   .LCFI8-.LCFI7
1078         .byte   0x86    /* DW_CFA_offset, column 0x6 %esi at CFA + 3 * -4 */
1079         .byte   0x3     /* .uleb128 0x3 */
1080
1081         /* End of DW_CFA_xxx CFI instructions.  */
1082         .align 4
1083 .LEFDE4:
1084
1085 #endif /* !FFI_NO_RAW_API */
1086
1087 .LSFDE5:
1088         .long   .LEFDE5-.LASFDE5        /* FDE Length */
1089 .LASFDE5:
1090         .long   .LASFDE5-.Lframe1       /* FDE CIE offset */
1091 #if defined __PIC__ && defined HAVE_AS_X86_PCREL
1092         .long   .LFB5-. /* FDE initial location */
1093 #else
1094         .long   .LFB5
1095 #endif
1096         .long   .LFE5-.LFB5     /* FDE address range */
1097 #ifdef __PIC__
1098         .byte   0x0     /* .uleb128 0x0; Augmentation size */
1099 #endif
1100         /* DW_CFA_xxx CFI instructions go here.  */
1101
1102         .byte   0x4     /* DW_CFA_advance_loc4 */
1103         .long   .LCFI9-.LFB5
1104         .byte   0xe     /* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
1105         .byte   0x8     /* .uleb128 0x8 */
1106         .byte   0x85    /* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
1107         .byte   0x2     /* .uleb128 0x2 */
1108
1109         .byte   0x4     /* DW_CFA_advance_loc4 */
1110         .long   .LCFI10-.LCFI9
1111         .byte   0xd     /* DW_CFA_def_cfa_register CFA = r5 = %ebp */
1112         .byte   0x5     /* .uleb128 0x5 */
1113
1114         /* End of DW_CFA_xxx CFI instructions.  */
1115         .align 4
1116 .LEFDE5:
1117
1118 #endif /* !_MSC_VER */
1119