Handle fastcall declaration differently for some Microsoft compilers
[libffi.git] / src / x86 / ffi.c
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 #ifndef __x86_64__
33 #include <ffi.h>
34 #include <ffi_common.h>
35 #include <stdlib.h>
36 #include "internal.h"
37
38 /* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
39 all further uses in this file will refer to the 80-bit type. */
40 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
41 # if FFI_TYPE_LONGDOUBLE != 4
42 # error FFI_TYPE_LONGDOUBLE out of date
43 # endif
44 #else
45 # undef FFI_TYPE_LONGDOUBLE
46 # define FFI_TYPE_LONGDOUBLE 4
47 #endif
48
49 #if defined(__GNUC__) && !defined(__declspec)
50 # define __declspec(x) __attribute__((x))
51 #endif
52
53 /* Perform machine dependent cif processing. */
54 ffi_status FFI_HIDDEN
55 ffi_prep_cif_machdep(ffi_cif *cif)
56 {
57 size_t bytes = 0;
58 int i, n, flags, cabi = cif->abi;
59
60 switch (cabi)
61 {
62 case FFI_SYSV:
63 case FFI_STDCALL:
64 case FFI_THISCALL:
65 case FFI_FASTCALL:
66 case FFI_MS_CDECL:
67 case FFI_PASCAL:
68 case FFI_REGISTER:
69 break;
70 default:
71 return FFI_BAD_ABI;
72 }
73
74 switch (cif->rtype->type)
75 {
76 case FFI_TYPE_VOID:
77 flags = X86_RET_VOID;
78 break;
79 case FFI_TYPE_FLOAT:
80 flags = X86_RET_FLOAT;
81 break;
82 case FFI_TYPE_DOUBLE:
83 flags = X86_RET_DOUBLE;
84 break;
85 case FFI_TYPE_LONGDOUBLE:
86 flags = X86_RET_LDOUBLE;
87 break;
88 case FFI_TYPE_UINT8:
89 flags = X86_RET_UINT8;
90 break;
91 case FFI_TYPE_UINT16:
92 flags = X86_RET_UINT16;
93 break;
94 case FFI_TYPE_SINT8:
95 flags = X86_RET_SINT8;
96 break;
97 case FFI_TYPE_SINT16:
98 flags = X86_RET_SINT16;
99 break;
100 case FFI_TYPE_INT:
101 case FFI_TYPE_SINT32:
102 case FFI_TYPE_UINT32:
103 case FFI_TYPE_POINTER:
104 flags = X86_RET_INT32;
105 break;
106 case FFI_TYPE_SINT64:
107 case FFI_TYPE_UINT64:
108 flags = X86_RET_INT64;
109 break;
110 case FFI_TYPE_STRUCT:
111 #ifndef X86
112 /* ??? This should be a different ABI rather than an ifdef. */
113 if (cif->rtype->size == 1)
114 flags = X86_RET_STRUCT_1B;
115 else if (cif->rtype->size == 2)
116 flags = X86_RET_STRUCT_2B;
117 else if (cif->rtype->size == 4)
118 flags = X86_RET_INT32;
119 else if (cif->rtype->size == 8)
120 flags = X86_RET_INT64;
121 else
122 #endif
123 {
124 do_struct:
125 switch (cabi)
126 {
127 case FFI_THISCALL:
128 case FFI_FASTCALL:
129 case FFI_STDCALL:
130 case FFI_MS_CDECL:
131 flags = X86_RET_STRUCTARG;
132 break;
133 default:
134 flags = X86_RET_STRUCTPOP;
135 break;
136 }
137 /* Allocate space for return value pointer. */
138 bytes += ALIGN (sizeof(void*), FFI_SIZEOF_ARG);
139 }
140 break;
141 case FFI_TYPE_COMPLEX:
142 switch (cif->rtype->elements[0]->type)
143 {
144 case FFI_TYPE_DOUBLE:
145 case FFI_TYPE_LONGDOUBLE:
146 case FFI_TYPE_SINT64:
147 case FFI_TYPE_UINT64:
148 goto do_struct;
149 case FFI_TYPE_FLOAT:
150 case FFI_TYPE_INT:
151 case FFI_TYPE_SINT32:
152 case FFI_TYPE_UINT32:
153 flags = X86_RET_INT64;
154 break;
155 case FFI_TYPE_SINT16:
156 case FFI_TYPE_UINT16:
157 flags = X86_RET_INT32;
158 break;
159 case FFI_TYPE_SINT8:
160 case FFI_TYPE_UINT8:
161 flags = X86_RET_STRUCT_2B;
162 break;
163 default:
164 return FFI_BAD_TYPEDEF;
165 }
166 break;
167 default:
168 return FFI_BAD_TYPEDEF;
169 }
170 cif->flags = flags;
171
172 for (i = 0, n = cif->nargs; i < n; i++)
173 {
174 ffi_type *t = cif->arg_types[i];
175
176 bytes = ALIGN (bytes, t->alignment);
177 bytes += ALIGN (t->size, FFI_SIZEOF_ARG);
178 }
179 cif->bytes = ALIGN (bytes, 16);
180
181 return FFI_OK;
182 }
183
184 static ffi_arg
185 extend_basic_type(void *arg, int type)
186 {
187 switch (type)
188 {
189 case FFI_TYPE_SINT8:
190 return *(SINT8 *)arg;
191 case FFI_TYPE_UINT8:
192 return *(UINT8 *)arg;
193 case FFI_TYPE_SINT16:
194 return *(SINT16 *)arg;
195 case FFI_TYPE_UINT16:
196 return *(UINT16 *)arg;
197
198 case FFI_TYPE_SINT32:
199 case FFI_TYPE_UINT32:
200 case FFI_TYPE_POINTER:
201 case FFI_TYPE_FLOAT:
202 return *(UINT32 *)arg;
203
204 default:
205 abort();
206 }
207 }
208
209 struct call_frame
210 {
211 void *ebp; /* 0 */
212 void *retaddr; /* 4 */
213 void (*fn)(void); /* 8 */
214 int flags; /* 12 */
215 void *rvalue; /* 16 */
216 unsigned regs[3]; /* 20-28 */
217 };
218
219 struct abi_params
220 {
221 int dir; /* parameter growth direction */
222 int static_chain; /* the static chain register used by gcc */
223 int nregs; /* number of register parameters */
224 int regs[3];
225 };
226
227 static const struct abi_params abi_params[FFI_LAST_ABI] = {
228 [FFI_SYSV] = { 1, R_ECX, 0 },
229 [FFI_THISCALL] = { 1, R_EAX, 1, { R_ECX } },
230 [FFI_FASTCALL] = { 1, R_EAX, 2, { R_ECX, R_EDX } },
231 [FFI_STDCALL] = { 1, R_ECX, 0 },
232 [FFI_PASCAL] = { -1, R_ECX, 0 },
233 /* ??? No defined static chain; gcc does not support REGISTER. */
234 [FFI_REGISTER] = { -1, R_ECX, 3, { R_EAX, R_EDX, R_ECX } },
235 [FFI_MS_CDECL] = { 1, R_ECX, 0 }
236 };
237
238 #ifdef HAVE_FASTCALL
239 #ifdef _MSC_VER
240 #define FFI_DECLARE_FASTCALL __fastcall
241 #else
242 #define FFI_DECLARE_FASTCALL __declspec(fastcall)
243 #endif
244 #else
245 #define FFI_DECLARE_FASTCALL
246 #endif
247
248 extern void FFI_DECLARE_FASTCALL ffi_call_i386(struct call_frame *, char *) FFI_HIDDEN;
249
250 static void
251 ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
252 void **avalue, void *closure)
253 {
254 size_t rsize, bytes;
255 struct call_frame *frame;
256 char *stack, *argp;
257 ffi_type **arg_types;
258 int flags, cabi, i, n, dir, narg_reg;
259 const struct abi_params *pabi;
260
261 flags = cif->flags;
262 cabi = cif->abi;
263 pabi = &abi_params[cabi];
264 dir = pabi->dir;
265
266 rsize = 0;
267 if (rvalue == NULL)
268 {
269 switch (flags)
270 {
271 case X86_RET_FLOAT:
272 case X86_RET_DOUBLE:
273 case X86_RET_LDOUBLE:
274 case X86_RET_STRUCTPOP:
275 case X86_RET_STRUCTARG:
276 /* The float cases need to pop the 387 stack.
277 The struct cases need to pass a valid pointer to the callee. */
278 rsize = cif->rtype->size;
279 break;
280 default:
281 /* We can pretend that the callee returns nothing. */
282 flags = X86_RET_VOID;
283 break;
284 }
285 }
286
287 bytes = cif->bytes;
288 stack = alloca(bytes + sizeof(*frame) + rsize);
289 argp = (dir < 0 ? stack + bytes : stack);
290 frame = (struct call_frame *)(stack + bytes);
291 if (rsize)
292 rvalue = frame + 1;
293
294 frame->fn = fn;
295 frame->flags = flags;
296 frame->rvalue = rvalue;
297 frame->regs[pabi->static_chain] = (unsigned)closure;
298
299 narg_reg = 0;
300 switch (flags)
301 {
302 case X86_RET_STRUCTARG:
303 /* The pointer is passed as the first argument. */
304 if (pabi->nregs > 0)
305 {
306 frame->regs[pabi->regs[0]] = (unsigned)rvalue;
307 narg_reg = 1;
308 break;
309 }
310 /* fallthru */
311 case X86_RET_STRUCTPOP:
312 *(void **)argp = rvalue;
313 argp += sizeof(void *);
314 break;
315 }
316
317 arg_types = cif->arg_types;
318 for (i = 0, n = cif->nargs; i < n; i++)
319 {
320 ffi_type *ty = arg_types[i];
321 void *valp = avalue[i];
322 size_t z = ty->size;
323 int t = ty->type;
324
325 if (z <= FFI_SIZEOF_ARG && t != FFI_TYPE_STRUCT)
326 {
327 ffi_arg val = extend_basic_type (valp, t);
328
329 if (t != FFI_TYPE_FLOAT && narg_reg < pabi->nregs)
330 frame->regs[pabi->regs[narg_reg++]] = val;
331 else if (dir < 0)
332 {
333 argp -= 4;
334 *(ffi_arg *)argp = val;
335 }
336 else
337 {
338 *(ffi_arg *)argp = val;
339 argp += 4;
340 }
341 }
342 else
343 {
344 size_t za = ALIGN (z, FFI_SIZEOF_ARG);
345 size_t align = FFI_SIZEOF_ARG;
346
347 /* Alignment rules for arguments are quite complex. Vectors and
348 structures with 16 byte alignment get it. Note that long double
349 on Darwin does have 16 byte alignment, and does not get this
350 alignment if passed directly; a structure with a long double
351 inside, however, would get 16 byte alignment. Since libffi does
352 not support vectors, we need non concern ourselves with other
353 cases. */
354 if (t == FFI_TYPE_STRUCT && ty->alignment >= 16)
355 align = 16;
356
357 if (dir < 0)
358 {
359 /* ??? These reverse argument ABIs are probably too old
360 to have cared about alignment. Someone should check. */
361 argp -= za;
362 memcpy (argp, valp, z);
363 }
364 else
365 {
366 argp = (char *)ALIGN (argp, align);
367 memcpy (argp, valp, z);
368 argp += za;
369 }
370 }
371 }
372 FFI_ASSERT (dir > 0 || argp == stack);
373
374 ffi_call_i386 (frame, stack);
375 }
376
377 void
378 ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
379 {
380 ffi_call_int (cif, fn, rvalue, avalue, NULL);
381 }
382
383 void
384 ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue,
385 void **avalue, void *closure)
386 {
387 ffi_call_int (cif, fn, rvalue, avalue, closure);
388 }
389
390 /** private members **/
391
392 void FFI_HIDDEN ffi_closure_i386(void);
393 void FFI_HIDDEN ffi_closure_STDCALL(void);
394 void FFI_HIDDEN ffi_closure_REGISTER(void);
395
396 struct closure_frame
397 {
398 unsigned rettemp[4]; /* 0 */
399 unsigned regs[3]; /* 16-24 */
400 ffi_cif *cif; /* 28 */
401 void (*fun)(ffi_cif*,void*,void**,void*); /* 32 */
402 void *user_data; /* 36 */
403 };
404
405 int FFI_HIDDEN FFI_DECLARE_FASTCALL
406 ffi_closure_inner (struct closure_frame *frame, char *stack)
407 {
408 ffi_cif *cif = frame->cif;
409 int cabi, i, n, flags, dir, narg_reg;
410 const struct abi_params *pabi;
411 ffi_type **arg_types;
412 char *argp;
413 void *rvalue;
414 void **avalue;
415
416 cabi = cif->abi;
417 flags = cif->flags;
418 narg_reg = 0;
419 rvalue = frame->rettemp;
420 pabi = &abi_params[cabi];
421 dir = pabi->dir;
422 argp = (dir < 0 ? stack + cif->bytes : stack);
423
424 switch (flags)
425 {
426 case X86_RET_STRUCTARG:
427 if (pabi->nregs > 0)
428 {
429 rvalue = (void *)frame->regs[pabi->regs[0]];
430 narg_reg = 1;
431 frame->rettemp[0] = (unsigned)rvalue;
432 break;
433 }
434 /* fallthru */
435 case X86_RET_STRUCTPOP:
436 rvalue = *(void **)argp;
437 argp += sizeof(void *);
438 frame->rettemp[0] = (unsigned)rvalue;
439 break;
440 }
441
442 n = cif->nargs;
443 avalue = alloca(sizeof(void *) * n);
444
445 arg_types = cif->arg_types;
446 for (i = 0; i < n; ++i)
447 {
448 ffi_type *ty = arg_types[i];
449 size_t z = ty->size;
450 int t = ty->type;
451 void *valp;
452
453 if (z <= FFI_SIZEOF_ARG && t != FFI_TYPE_STRUCT)
454 {
455 if (t != FFI_TYPE_FLOAT && narg_reg < pabi->nregs)
456 valp = &frame->regs[pabi->regs[narg_reg++]];
457 else if (dir < 0)
458 {
459 argp -= 4;
460 valp = argp;
461 }
462 else
463 {
464 valp = argp;
465 argp += 4;
466 }
467 }
468 else
469 {
470 size_t za = ALIGN (z, FFI_SIZEOF_ARG);
471 size_t align = FFI_SIZEOF_ARG;
472
473 /* See the comment in ffi_call_int. */
474 if (t == FFI_TYPE_STRUCT && ty->alignment >= 16)
475 align = 16;
476
477 if (dir < 0)
478 {
479 /* ??? These reverse argument ABIs are probably too old
480 to have cared about alignment. Someone should check. */
481 argp -= za;
482 valp = argp;
483 }
484 else
485 {
486 argp = (char *)ALIGN (argp, align);
487 valp = argp;
488 argp += za;
489 }
490 }
491
492 avalue[i] = valp;
493 }
494
495 frame->fun (cif, rvalue, avalue, frame->user_data);
496
497 if (cabi == FFI_STDCALL)
498 return flags + (cif->bytes << X86_RET_POP_SHIFT);
499 else
500 return flags;
501 }
502
503 ffi_status
504 ffi_prep_closure_loc (ffi_closure* closure,
505 ffi_cif* cif,
506 void (*fun)(ffi_cif*,void*,void**,void*),
507 void *user_data,
508 void *codeloc)
509 {
510 char *tramp = closure->tramp;
511 void (*dest)(void);
512 int op = 0xb8; /* movl imm, %eax */
513
514 switch (cif->abi)
515 {
516 case FFI_SYSV:
517 case FFI_THISCALL:
518 case FFI_FASTCALL:
519 case FFI_MS_CDECL:
520 dest = ffi_closure_i386;
521 break;
522 case FFI_STDCALL:
523 case FFI_PASCAL:
524 dest = ffi_closure_STDCALL;
525 break;
526 case FFI_REGISTER:
527 dest = ffi_closure_REGISTER;
528 op = 0x68; /* pushl imm */
529 default:
530 return FFI_BAD_ABI;
531 }
532
533 /* movl or pushl immediate. */
534 tramp[0] = op;
535 *(void **)(tramp + 1) = codeloc;
536
537 /* jmp dest */
538 tramp[5] = 0xe9;
539 *(unsigned *)(tramp + 6) = (unsigned)dest - ((unsigned)codeloc + 10);
540
541 closure->cif = cif;
542 closure->fun = fun;
543 closure->user_data = user_data;
544
545 return FFI_OK;
546 }
547
548 void FFI_HIDDEN ffi_go_closure_EAX(void);
549 void FFI_HIDDEN ffi_go_closure_ECX(void);
550 void FFI_HIDDEN ffi_go_closure_STDCALL(void);
551
552 ffi_status
553 ffi_prep_go_closure (ffi_go_closure* closure, ffi_cif* cif,
554 void (*fun)(ffi_cif*,void*,void**,void*))
555 {
556 void (*dest)(void);
557
558 switch (cif->abi)
559 {
560 case FFI_SYSV:
561 case FFI_MS_CDECL:
562 dest = ffi_go_closure_ECX;
563 break;
564 case FFI_THISCALL:
565 case FFI_FASTCALL:
566 dest = ffi_go_closure_EAX;
567 break;
568 case FFI_STDCALL:
569 case FFI_PASCAL:
570 dest = ffi_go_closure_STDCALL;
571 break;
572 case FFI_REGISTER:
573 default:
574 return FFI_BAD_ABI;
575 }
576
577 closure->tramp = dest;
578 closure->cif = cif;
579 closure->fun = fun;
580
581 return FFI_OK;
582 }
583
584 /* ------- Native raw API support -------------------------------- */
585
586 #if !FFI_NO_RAW_API
587
588 void FFI_HIDDEN ffi_closure_raw_SYSV(void);
589 void FFI_HIDDEN ffi_closure_raw_THISCALL(void);
590
591 ffi_status
592 ffi_prep_raw_closure_loc (ffi_raw_closure *closure,
593 ffi_cif *cif,
594 void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
595 void *user_data,
596 void *codeloc)
597 {
598 char *tramp = closure->tramp;
599 void (*dest)(void);
600 int i;
601
602 /* We currently don't support certain kinds of arguments for raw
603 closures. This should be implemented by a separate assembly
604 language routine, since it would require argument processing,
605 something we don't do now for performance. */
606 for (i = cif->nargs-1; i >= 0; i--)
607 switch (cif->arg_types[i]->type)
608 {
609 case FFI_TYPE_STRUCT:
610 case FFI_TYPE_LONGDOUBLE:
611 return FFI_BAD_TYPEDEF;
612 }
613
614 switch (cif->abi)
615 {
616 case FFI_THISCALL:
617 dest = ffi_closure_raw_THISCALL;
618 break;
619 case FFI_SYSV:
620 dest = ffi_closure_raw_SYSV;
621 break;
622 default:
623 return FFI_BAD_ABI;
624 }
625
626 /* movl imm, %eax. */
627 tramp[0] = 0xb8;
628 *(void **)(tramp + 1) = codeloc;
629
630 /* jmp dest */
631 tramp[5] = 0xe9;
632 *(unsigned *)(tramp + 6) = (unsigned)dest - ((unsigned)codeloc + 10);
633
634 closure->cif = cif;
635 closure->fun = fun;
636 closure->user_data = user_data;
637
638 return FFI_OK;
639 }
640
641 void
642 ffi_raw_call(ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *avalue)
643 {
644 size_t rsize, bytes;
645 struct call_frame *frame;
646 char *stack, *argp;
647 ffi_type **arg_types;
648 int flags, cabi, i, n, narg_reg;
649 const struct abi_params *pabi;
650
651 flags = cif->flags;
652 cabi = cif->abi;
653 pabi = &abi_params[cabi];
654
655 rsize = 0;
656 if (rvalue == NULL)
657 {
658 switch (flags)
659 {
660 case X86_RET_FLOAT:
661 case X86_RET_DOUBLE:
662 case X86_RET_LDOUBLE:
663 case X86_RET_STRUCTPOP:
664 case X86_RET_STRUCTARG:
665 /* The float cases need to pop the 387 stack.
666 The struct cases need to pass a valid pointer to the callee. */
667 rsize = cif->rtype->size;
668 break;
669 default:
670 /* We can pretend that the callee returns nothing. */
671 flags = X86_RET_VOID;
672 break;
673 }
674 }
675
676 bytes = cif->bytes;
677 argp = stack = alloca(bytes + sizeof(*frame) + rsize);
678 frame = (struct call_frame *)(stack + bytes);
679 if (rsize)
680 rvalue = frame + 1;
681
682 frame->fn = fn;
683 frame->flags = flags;
684 frame->rvalue = rvalue;
685
686 narg_reg = 0;
687 switch (flags)
688 {
689 case X86_RET_STRUCTARG:
690 /* The pointer is passed as the first argument. */
691 if (pabi->nregs > 0)
692 {
693 frame->regs[pabi->regs[0]] = (unsigned)rvalue;
694 narg_reg = 1;
695 break;
696 }
697 /* fallthru */
698 case X86_RET_STRUCTPOP:
699 *(void **)argp = rvalue;
700 argp += sizeof(void *);
701 bytes -= sizeof(void *);
702 break;
703 }
704
705 arg_types = cif->arg_types;
706 for (i = 0, n = cif->nargs; narg_reg < pabi->nregs && i < n; i++)
707 {
708 ffi_type *ty = arg_types[i];
709 size_t z = ty->size;
710 int t = ty->type;
711
712 if (z <= FFI_SIZEOF_ARG && t != FFI_TYPE_STRUCT && t != FFI_TYPE_FLOAT)
713 {
714 ffi_arg val = extend_basic_type (avalue, t);
715 frame->regs[pabi->regs[narg_reg++]] = val;
716 z = FFI_SIZEOF_ARG;
717 }
718 else
719 {
720 memcpy (argp, avalue, z);
721 z = ALIGN (z, FFI_SIZEOF_ARG);
722 argp += z;
723 }
724 avalue += z;
725 bytes -= z;
726 }
727 if (i < n)
728 memcpy (argp, avalue, bytes);
729
730 ffi_call_i386 (frame, stack);
731 }
732 #endif /* !FFI_NO_RAW_API */
733 #endif /* !__x86_64__ */