1 /* -----------------------------------------------------------------------
2 ffi.c - Copyright (c) 2017 Anthony Green
3 Copyright (c) 1996, 1998, 1999, 2001, 2007, 2008 Red Hat, Inc.
4 Copyright (c) 2002 Ranjit Mathew
5 Copyright (c) 2002 Bo Thorsen
6 Copyright (c) 2002 Roger Sayle
7 Copyright (C) 2008, 2010 Free Software Foundation, Inc.
8
9 x86 Foreign Function Interface
10
11 Permission is hereby granted, free of charge, to any person obtaining
12 a copy of this software and associated documentation files (the
13 ``Software''), to deal in the Software without restriction, including
14 without limitation the rights to use, copy, modify, merge, publish,
15 distribute, sublicense, and/or sell copies of the Software, and to
16 permit persons to whom the Software is furnished to do so, subject to
17 the following conditions:
18
19 The above copyright notice and this permission notice shall be included
20 in all copies or substantial portions of the Software.
21
22 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
27 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 DEALINGS IN THE SOFTWARE.
30 ----------------------------------------------------------------------- */
31
32 #if defined(__i386__) || defined(_M_IX86)
33 #include <ffi.h>
34 #include <ffi_common.h>
35 #include <stdint.h>
36 #include <stdlib.h>
37 #include <tramp.h>
38 #include "internal.h"
39
40 /* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
41 all further uses in this file will refer to the 80-bit type. */
42 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
43 # if FFI_TYPE_LONGDOUBLE != 4
44 # error FFI_TYPE_LONGDOUBLE out of date
45 # endif
46 #else
47 # undef FFI_TYPE_LONGDOUBLE
48 # define FFI_TYPE_LONGDOUBLE 4
49 #endif
50
51 #if defined(__GNUC__) && !defined(__declspec)
52 # define __declspec(x) __attribute__((x))
53 #endif
54
55 #if defined(_MSC_VER) && defined(_M_IX86)
56 /* Stack is not 16-byte aligned on Windows. */
57 #define STACK_ALIGN(bytes) (bytes)
58 #else
59 #define STACK_ALIGN(bytes) FFI_ALIGN (bytes, 16)
60 #endif
61
62 /* Perform machine dependent cif processing. */
63 ffi_status FFI_HIDDEN
64 ffi_prep_cif_machdep(ffi_cif *cif)
65 {
66 size_t bytes = 0;
67 int i, n, flags, cabi = cif->abi;
68
69 switch (cabi)
70 {
71 case FFI_SYSV:
72 case FFI_STDCALL:
73 case FFI_THISCALL:
74 case FFI_FASTCALL:
75 case FFI_MS_CDECL:
76 case FFI_PASCAL:
77 case FFI_REGISTER:
78 break;
79 default:
80 return FFI_BAD_ABI;
81 }
82
83 switch (cif->rtype->type)
84 {
85 case FFI_TYPE_VOID:
86 flags = X86_RET_VOID;
87 break;
88 case FFI_TYPE_FLOAT:
89 flags = X86_RET_FLOAT;
90 break;
91 case FFI_TYPE_DOUBLE:
92 flags = X86_RET_DOUBLE;
93 break;
94 case FFI_TYPE_LONGDOUBLE:
95 flags = X86_RET_LDOUBLE;
96 break;
97 case FFI_TYPE_UINT8:
98 flags = X86_RET_UINT8;
99 break;
100 case FFI_TYPE_UINT16:
101 flags = X86_RET_UINT16;
102 break;
103 case FFI_TYPE_SINT8:
104 flags = X86_RET_SINT8;
105 break;
106 case FFI_TYPE_SINT16:
107 flags = X86_RET_SINT16;
108 break;
109 case FFI_TYPE_INT:
110 case FFI_TYPE_SINT32:
111 case FFI_TYPE_UINT32:
112 case FFI_TYPE_POINTER:
113 flags = X86_RET_INT32;
114 break;
115 case FFI_TYPE_SINT64:
116 case FFI_TYPE_UINT64:
117 flags = X86_RET_INT64;
118 break;
119 case FFI_TYPE_STRUCT:
120 #ifndef X86
121 /* ??? This should be a different ABI rather than an ifdef. */
122 if (cif->rtype->size == 1)
123 flags = X86_RET_STRUCT_1B;
124 else if (cif->rtype->size == 2)
125 flags = X86_RET_STRUCT_2B;
126 else if (cif->rtype->size == 4)
127 flags = X86_RET_INT32;
128 else if (cif->rtype->size == 8)
129 flags = X86_RET_INT64;
130 else
131 #endif
132 {
133 do_struct:
134 switch (cabi)
135 {
136 case FFI_THISCALL:
137 case FFI_FASTCALL:
138 case FFI_STDCALL:
139 case FFI_MS_CDECL:
140 flags = X86_RET_STRUCTARG;
141 break;
142 default:
143 flags = X86_RET_STRUCTPOP;
144 break;
145 }
146 /* Allocate space for return value pointer. */
147 bytes += FFI_ALIGN (sizeof(void*), FFI_SIZEOF_ARG);
148 }
149 break;
150 case FFI_TYPE_COMPLEX:
151 switch (cif->rtype->elements[0]->type)
152 {
153 case FFI_TYPE_DOUBLE:
154 case FFI_TYPE_LONGDOUBLE:
155 case FFI_TYPE_SINT64:
156 case FFI_TYPE_UINT64:
157 goto do_struct;
158 case FFI_TYPE_FLOAT:
159 case FFI_TYPE_INT:
160 case FFI_TYPE_SINT32:
161 case FFI_TYPE_UINT32:
162 flags = X86_RET_INT64;
163 break;
164 case FFI_TYPE_SINT16:
165 case FFI_TYPE_UINT16:
166 flags = X86_RET_INT32;
167 break;
168 case FFI_TYPE_SINT8:
169 case FFI_TYPE_UINT8:
170 flags = X86_RET_STRUCT_2B;
171 break;
172 default:
173 return FFI_BAD_TYPEDEF;
174 }
175 break;
176 default:
177 return FFI_BAD_TYPEDEF;
178 }
179 cif->flags = flags;
180
181 for (i = 0, n = cif->nargs; i < n; i++)
182 {
183 ffi_type *t = cif->arg_types[i];
184
185 bytes = FFI_ALIGN (bytes, t->alignment);
186 bytes += FFI_ALIGN (t->size, FFI_SIZEOF_ARG);
187 }
188 cif->bytes = bytes;
189
190 return FFI_OK;
191 }
192
193 static ffi_arg
194 extend_basic_type(void *arg, int type)
195 {
196 switch (type)
197 {
198 case FFI_TYPE_SINT8:
199 return *(SINT8 *)arg;
200 case FFI_TYPE_UINT8:
201 return *(UINT8 *)arg;
202 case FFI_TYPE_SINT16:
203 return *(SINT16 *)arg;
204 case FFI_TYPE_UINT16:
205 return *(UINT16 *)arg;
206
207 case FFI_TYPE_SINT32:
208 case FFI_TYPE_UINT32:
209 case FFI_TYPE_POINTER:
210 case FFI_TYPE_FLOAT:
211 return *(UINT32 *)arg;
212
213 default:
214 abort();
215 }
216 }
217
218 struct call_frame
219 {
220 void *ebp; /* 0 */
221 void *retaddr; /* 4 */
222 void (*fn)(void); /* 8 */
223 int flags; /* 12 */
224 void *rvalue; /* 16 */
225 unsigned regs[3]; /* 20-28 */
226 };
227
228 struct abi_params
229 {
230 int dir; /* parameter growth direction */
231 int static_chain; /* the static chain register used by gcc */
232 int nregs; /* number of register parameters */
233 int regs[3];
234 };
235
236 static const struct abi_params abi_params[FFI_LAST_ABI] = {
237 [FFI_SYSV] = { 1, R_ECX, 0 },
238 [FFI_THISCALL] = { 1, R_EAX, 1, { R_ECX } },
239 [FFI_FASTCALL] = { 1, R_EAX, 2, { R_ECX, R_EDX } },
240 [FFI_STDCALL] = { 1, R_ECX, 0 },
241 [FFI_PASCAL] = { -1, R_ECX, 0 },
242 /* ??? No defined static chain; gcc does not support REGISTER. */
243 [FFI_REGISTER] = { -1, R_ECX, 3, { R_EAX, R_EDX, R_ECX } },
244 [FFI_MS_CDECL] = { 1, R_ECX, 0 }
245 };
246
247 #ifdef HAVE_FASTCALL
248 #ifdef _MSC_VER
249 #define FFI_DECLARE_FASTCALL __fastcall
250 #else
251 #define FFI_DECLARE_FASTCALL __declspec(fastcall)
252 #endif
253 #else
254 #define FFI_DECLARE_FASTCALL
255 #endif
256
257 extern void FFI_DECLARE_FASTCALL ffi_call_i386(struct call_frame *, char *) FFI_HIDDEN;
258
259 /* We perform some black magic here to use some of the parent's stack frame in
260 * ffi_call_i386() that breaks with the MSVC compiler with the /RTCs or /GZ
261 * flags. Disable the 'Stack frame run time error checking' for this function
262 * so we don't hit weird exceptions in debug builds. */
263 #if defined(_MSC_VER)
264 #pragma runtime_checks("s", off)
265 #endif
266 static void
267 ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
268 void **avalue, void *closure)
269 {
270 size_t rsize, bytes;
271 struct call_frame *frame;
272 char *stack, *argp;
273 ffi_type **arg_types;
274 int flags, cabi, i, n, dir, narg_reg;
275 const struct abi_params *pabi;
276
277 flags = cif->flags;
278 cabi = cif->abi;
279 pabi = &abi_params[cabi];
280 dir = pabi->dir;
281
282 rsize = 0;
283 if (rvalue == NULL)
284 {
285 switch (flags)
286 {
287 case X86_RET_FLOAT:
288 case X86_RET_DOUBLE:
289 case X86_RET_LDOUBLE:
290 case X86_RET_STRUCTPOP:
291 case X86_RET_STRUCTARG:
292 /* The float cases need to pop the 387 stack.
293 The struct cases need to pass a valid pointer to the callee. */
294 rsize = cif->rtype->size;
295 break;
296 default:
297 /* We can pretend that the callee returns nothing. */
298 flags = X86_RET_VOID;
299 break;
300 }
301 }
302
303 bytes = STACK_ALIGN (cif->bytes);
304 stack = alloca(bytes + sizeof(*frame) + rsize);
305 argp = (dir < 0 ? stack + bytes : stack);
306 frame = (struct call_frame *)(stack + bytes);
307 if (rsize)
308 rvalue = frame + 1;
309
310 frame->fn = fn;
311 frame->flags = flags;
312 frame->rvalue = rvalue;
313 frame->regs[pabi->static_chain] = (unsigned)closure;
314
315 narg_reg = 0;
316 switch (flags)
317 {
318 case X86_RET_STRUCTARG:
319 /* The pointer is passed as the first argument. */
320 if (pabi->nregs > 0)
321 {
322 frame->regs[pabi->regs[0]] = (unsigned)rvalue;
323 narg_reg = 1;
324 break;
325 }
326 /* fallthru */
327 case X86_RET_STRUCTPOP:
328 *(void **)argp = rvalue;
329 argp += sizeof(void *);
330 break;
331 }
332
333 arg_types = cif->arg_types;
334 for (i = 0, n = cif->nargs; i < n; i++)
335 {
336 ffi_type *ty = arg_types[i];
337 void *valp = avalue[i];
338 size_t z = ty->size;
339 int t = ty->type;
340
341 if (z <= FFI_SIZEOF_ARG && t != FFI_TYPE_STRUCT)
342 {
343 ffi_arg val = extend_basic_type (valp, t);
344
345 if (t != FFI_TYPE_FLOAT && narg_reg < pabi->nregs)
346 frame->regs[pabi->regs[narg_reg++]] = val;
347 else if (dir < 0)
348 {
349 argp -= 4;
350 *(ffi_arg *)argp = val;
351 }
352 else
353 {
354 *(ffi_arg *)argp = val;
355 argp += 4;
356 }
357 }
358 else
359 {
360 size_t za = FFI_ALIGN (z, FFI_SIZEOF_ARG);
361 size_t align = FFI_SIZEOF_ARG;
362
363 /* Issue 434: For thiscall and fastcall, if the paramter passed
364 as 64-bit integer or struct, all following integer parameters
365 will be passed on stack. */
366 if ((cabi == FFI_THISCALL || cabi == FFI_FASTCALL)
367 && (t == FFI_TYPE_SINT64
368 || t == FFI_TYPE_UINT64
369 || t == FFI_TYPE_STRUCT))
370 narg_reg = 2;
371
372 /* Alignment rules for arguments are quite complex. Vectors and
373 structures with 16 byte alignment get it. Note that long double
374 on Darwin does have 16 byte alignment, and does not get this
375 alignment if passed directly; a structure with a long double
376 inside, however, would get 16 byte alignment. Since libffi does
377 not support vectors, we need non concern ourselves with other
378 cases. */
379 if (t == FFI_TYPE_STRUCT && ty->alignment >= 16)
380 align = 16;
381
382 if (dir < 0)
383 {
384 /* ??? These reverse argument ABIs are probably too old
385 to have cared about alignment. Someone should check. */
386 argp -= za;
387 memcpy (argp, valp, z);
388 }
389 else
390 {
391 argp = (char *)FFI_ALIGN (argp, align);
392 memcpy (argp, valp, z);
393 argp += za;
394 }
395 }
396 }
397 FFI_ASSERT (dir > 0 || argp == stack);
398
399 ffi_call_i386 (frame, stack);
400 }
401 #if defined(_MSC_VER)
402 #pragma runtime_checks("s", restore)
403 #endif
404
405 void
406 ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
407 {
408 ffi_call_int (cif, fn, rvalue, avalue, NULL);
409 }
410
411 #ifdef FFI_GO_CLOSURES
412 void
413 ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue,
414 void **avalue, void *closure)
415 {
416 ffi_call_int (cif, fn, rvalue, avalue, closure);
417 }
418 #endif
419
420 /** private members **/
421
422 void FFI_HIDDEN ffi_closure_i386(void);
423 void FFI_HIDDEN ffi_closure_STDCALL(void);
424 void FFI_HIDDEN ffi_closure_REGISTER(void);
425 #if defined(FFI_EXEC_STATIC_TRAMP)
426 void FFI_HIDDEN ffi_closure_i386_alt(void);
427 void FFI_HIDDEN ffi_closure_STDCALL_alt(void);
428 void FFI_HIDDEN ffi_closure_REGISTER_alt(void);
429 #endif
430
431 struct closure_frame
432 {
433 unsigned rettemp[4]; /* 0 */
434 unsigned regs[3]; /* 16-24 */
435 ffi_cif *cif; /* 28 */
436 void (*fun)(ffi_cif*,void*,void**,void*); /* 32 */
437 void *user_data; /* 36 */
438 };
439
440 int FFI_HIDDEN FFI_DECLARE_FASTCALL
441 ffi_closure_inner (struct closure_frame *frame, char *stack)
442 {
443 ffi_cif *cif = frame->cif;
444 int cabi, i, n, flags, dir, narg_reg;
445 const struct abi_params *pabi;
446 ffi_type **arg_types;
447 char *argp;
448 void *rvalue;
449 void **avalue;
450
451 cabi = cif->abi;
452 flags = cif->flags;
453 narg_reg = 0;
454 rvalue = frame->rettemp;
455 pabi = &abi_params[cabi];
456 dir = pabi->dir;
457 argp = (dir < 0 ? stack + STACK_ALIGN (cif->bytes) : stack);
458
459 switch (flags)
460 {
461 case X86_RET_STRUCTARG:
462 if (pabi->nregs > 0)
463 {
464 rvalue = (void *)frame->regs[pabi->regs[0]];
465 narg_reg = 1;
466 frame->rettemp[0] = (unsigned)rvalue;
467 break;
468 }
469 /* fallthru */
470 case X86_RET_STRUCTPOP:
471 rvalue = *(void **)argp;
472 argp += sizeof(void *);
473 frame->rettemp[0] = (unsigned)rvalue;
474 break;
475 }
476
477 n = cif->nargs;
478 avalue = alloca(sizeof(void *) * n);
479
480 arg_types = cif->arg_types;
481 for (i = 0; i < n; ++i)
482 {
483 ffi_type *ty = arg_types[i];
484 size_t z = ty->size;
485 int t = ty->type;
486 void *valp;
487
488 if (z <= FFI_SIZEOF_ARG && t != FFI_TYPE_STRUCT)
489 {
490 if (t != FFI_TYPE_FLOAT && narg_reg < pabi->nregs)
491 valp = &frame->regs[pabi->regs[narg_reg++]];
492 else if (dir < 0)
493 {
494 argp -= 4;
495 valp = argp;
496 }
497 else
498 {
499 valp = argp;
500 argp += 4;
501 }
502 }
503 else
504 {
505 size_t za = FFI_ALIGN (z, FFI_SIZEOF_ARG);
506 size_t align = FFI_SIZEOF_ARG;
507
508 /* See the comment in ffi_call_int. */
509 if (t == FFI_TYPE_STRUCT && ty->alignment >= 16)
510 align = 16;
511
512 /* Issue 434: For thiscall and fastcall, if the paramter passed
513 as 64-bit integer or struct, all following integer parameters
514 will be passed on stack. */
515 if ((cabi == FFI_THISCALL || cabi == FFI_FASTCALL)
516 && (t == FFI_TYPE_SINT64
517 || t == FFI_TYPE_UINT64
518 || t == FFI_TYPE_STRUCT))
519 narg_reg = 2;
520
521 if (dir < 0)
522 {
523 /* ??? These reverse argument ABIs are probably too old
524 to have cared about alignment. Someone should check. */
525 argp -= za;
526 valp = argp;
527 }
528 else
529 {
530 argp = (char *)FFI_ALIGN (argp, align);
531 valp = argp;
532 argp += za;
533 }
534 }
535
536 avalue[i] = valp;
537 }
538
539 frame->fun (cif, rvalue, avalue, frame->user_data);
540
541 switch (cabi)
542 {
543 case FFI_STDCALL:
544 return flags | (cif->bytes << X86_RET_POP_SHIFT);
545 case FFI_THISCALL:
546 case FFI_FASTCALL:
547 return flags | ((cif->bytes - (narg_reg * FFI_SIZEOF_ARG))
548 << X86_RET_POP_SHIFT);
549 default:
550 return flags;
551 }
552 }
553
554 ffi_status
555 ffi_prep_closure_loc (ffi_closure* closure,
556 ffi_cif* cif,
557 void (*fun)(ffi_cif*,void*,void**,void*),
558 void *user_data,
559 void *codeloc)
560 {
561 char *tramp = closure->tramp;
562 void (*dest)(void);
563 int op = 0xb8; /* movl imm, %eax */
564
565 switch (cif->abi)
566 {
567 case FFI_SYSV:
568 case FFI_MS_CDECL:
569 dest = ffi_closure_i386;
570 break;
571 case FFI_STDCALL:
572 case FFI_THISCALL:
573 case FFI_FASTCALL:
574 case FFI_PASCAL:
575 dest = ffi_closure_STDCALL;
576 break;
577 case FFI_REGISTER:
578 dest = ffi_closure_REGISTER;
579 op = 0x68; /* pushl imm */
580 break;
581 default:
582 return FFI_BAD_ABI;
583 }
584
585 #if defined(FFI_EXEC_STATIC_TRAMP)
586 if (ffi_tramp_is_present(closure))
587 {
588 /* Initialize the static trampoline's parameters. */
589 if (dest == ffi_closure_i386)
590 dest = ffi_closure_i386_alt;
591 else if (dest == ffi_closure_STDCALL)
592 dest = ffi_closure_STDCALL_alt;
593 else
594 dest = ffi_closure_REGISTER_alt;
595 ffi_tramp_set_parms (closure->ftramp, dest, closure);
596 goto out;
597 }
598 #endif
599
600 /* Initialize the dynamic trampoline. */
601 /* endbr32. */
602 *(UINT32 *) tramp = 0xfb1e0ff3;
603
604 /* movl or pushl immediate. */
605 tramp[4] = op;
606 *(void **)(tramp + 5) = codeloc;
607
608 /* jmp dest */
609 tramp[9] = 0xe9;
610 *(unsigned *)(tramp + 10) = (unsigned)dest - ((unsigned)codeloc + 14);
611
612 out:
613 closure->cif = cif;
614 closure->fun = fun;
615 closure->user_data = user_data;
616
617 return FFI_OK;
618 }
619
620 #ifdef FFI_GO_CLOSURES
621
622 void FFI_HIDDEN ffi_go_closure_EAX(void);
623 void FFI_HIDDEN ffi_go_closure_ECX(void);
624 void FFI_HIDDEN ffi_go_closure_STDCALL(void);
625
626 ffi_status
627 ffi_prep_go_closure (ffi_go_closure* closure, ffi_cif* cif,
628 void (*fun)(ffi_cif*,void*,void**,void*))
629 {
630 void (*dest)(void);
631
632 switch (cif->abi)
633 {
634 case FFI_SYSV:
635 case FFI_MS_CDECL:
636 dest = ffi_go_closure_ECX;
637 break;
638 case FFI_THISCALL:
639 case FFI_FASTCALL:
640 dest = ffi_go_closure_EAX;
641 break;
642 case FFI_STDCALL:
643 case FFI_PASCAL:
644 dest = ffi_go_closure_STDCALL;
645 break;
646 case FFI_REGISTER:
647 default:
648 return FFI_BAD_ABI;
649 }
650
651 closure->tramp = dest;
652 closure->cif = cif;
653 closure->fun = fun;
654
655 return FFI_OK;
656 }
657
658 #endif /* FFI_GO_CLOSURES */
659
660 /* ------- Native raw API support -------------------------------- */
661
662 #if !FFI_NO_RAW_API
663
664 void FFI_HIDDEN ffi_closure_raw_SYSV(void);
665 void FFI_HIDDEN ffi_closure_raw_THISCALL(void);
666
667 ffi_status
668 ffi_prep_raw_closure_loc (ffi_raw_closure *closure,
669 ffi_cif *cif,
670 void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
671 void *user_data,
672 void *codeloc)
673 {
674 char *tramp = closure->tramp;
675 void (*dest)(void);
676 int i;
677
678 /* We currently don't support certain kinds of arguments for raw
679 closures. This should be implemented by a separate assembly
680 language routine, since it would require argument processing,
681 something we don't do now for performance. */
682 for (i = cif->nargs-1; i >= 0; i--)
683 switch (cif->arg_types[i]->type)
684 {
685 case FFI_TYPE_STRUCT:
686 case FFI_TYPE_LONGDOUBLE:
687 return FFI_BAD_TYPEDEF;
688 }
689
690 switch (cif->abi)
691 {
692 case FFI_THISCALL:
693 dest = ffi_closure_raw_THISCALL;
694 break;
695 case FFI_SYSV:
696 dest = ffi_closure_raw_SYSV;
697 break;
698 default:
699 return FFI_BAD_ABI;
700 }
701
702 /* movl imm, %eax. */
703 tramp[0] = 0xb8;
704 *(void **)(tramp + 1) = codeloc;
705
706 /* jmp dest */
707 tramp[5] = 0xe9;
708 *(unsigned *)(tramp + 6) = (unsigned)dest - ((unsigned)codeloc + 10);
709
710 closure->cif = cif;
711 closure->fun = fun;
712 closure->user_data = user_data;
713
714 return FFI_OK;
715 }
716
717 void
718 ffi_raw_call(ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *avalue)
719 {
720 size_t rsize, bytes;
721 struct call_frame *frame;
722 char *stack, *argp;
723 ffi_type **arg_types;
724 int flags, cabi, i, n, narg_reg;
725 const struct abi_params *pabi;
726
727 flags = cif->flags;
728 cabi = cif->abi;
729 pabi = &abi_params[cabi];
730
731 rsize = 0;
732 if (rvalue == NULL)
733 {
734 switch (flags)
735 {
736 case X86_RET_FLOAT:
737 case X86_RET_DOUBLE:
738 case X86_RET_LDOUBLE:
739 case X86_RET_STRUCTPOP:
740 case X86_RET_STRUCTARG:
741 /* The float cases need to pop the 387 stack.
742 The struct cases need to pass a valid pointer to the callee. */
743 rsize = cif->rtype->size;
744 break;
745 default:
746 /* We can pretend that the callee returns nothing. */
747 flags = X86_RET_VOID;
748 break;
749 }
750 }
751
752 bytes = STACK_ALIGN (cif->bytes);
753 argp = stack =
754 (void *)((uintptr_t)alloca(bytes + sizeof(*frame) + rsize + 15) & ~16);
755 frame = (struct call_frame *)(stack + bytes);
756 if (rsize)
757 rvalue = frame + 1;
758
759 frame->fn = fn;
760 frame->flags = flags;
761 frame->rvalue = rvalue;
762
763 narg_reg = 0;
764 switch (flags)
765 {
766 case X86_RET_STRUCTARG:
767 /* The pointer is passed as the first argument. */
768 if (pabi->nregs > 0)
769 {
770 frame->regs[pabi->regs[0]] = (unsigned)rvalue;
771 narg_reg = 1;
772 break;
773 }
774 /* fallthru */
775 case X86_RET_STRUCTPOP:
776 *(void **)argp = rvalue;
777 argp += sizeof(void *);
778 bytes -= sizeof(void *);
779 break;
780 }
781
782 arg_types = cif->arg_types;
783 for (i = 0, n = cif->nargs; narg_reg < pabi->nregs && i < n; i++)
784 {
785 ffi_type *ty = arg_types[i];
786 size_t z = ty->size;
787 int t = ty->type;
788
789 if (z <= FFI_SIZEOF_ARG && t != FFI_TYPE_STRUCT && t != FFI_TYPE_FLOAT)
790 {
791 ffi_arg val = extend_basic_type (avalue, t);
792 frame->regs[pabi->regs[narg_reg++]] = val;
793 z = FFI_SIZEOF_ARG;
794 }
795 else
796 {
797 memcpy (argp, avalue, z);
798 z = FFI_ALIGN (z, FFI_SIZEOF_ARG);
799 argp += z;
800 }
801 avalue += z;
802 bytes -= z;
803 }
804 if (i < n)
805 memcpy (argp, avalue, bytes);
806
807 ffi_call_i386 (frame, stack);
808 }
809 #endif /* !FFI_NO_RAW_API */
810
811 #if defined(FFI_EXEC_STATIC_TRAMP)
812 void *
813 ffi_tramp_arch (size_t *tramp_size, size_t *map_size)
814 {
815 extern void *trampoline_code_table;
816
817 *map_size = X86_TRAMP_MAP_SIZE;
818 *tramp_size = X86_TRAMP_SIZE;
819 return &trampoline_code_table;
820 }
821 #endif
822
823 #endif /* __i386__ */