Debian Codegraph @

src/pa/ffi.c

raw
1 /* -----------------------------------------------------------------------
2 ffi.c - (c) 2011 Anthony Green
3 (c) 2008 Red Hat, Inc.
4 (c) 2006 Free Software Foundation, Inc.
5 (c) 2003-2004 Randolph Chung <[email protected]>
6
7 HPPA Foreign Function Interface
8 HP-UX PA ABI support
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 #include <ffi.h>
32 #include <ffi_common.h>
33
34 #include <stdlib.h>
35 #include <stdio.h>
36
37 #define ROUND_UP(v, a) (((size_t)(v) + (a) - 1) & ~((a) - 1))
38
39 #define MIN_STACK_SIZE 64
40 #define FIRST_ARG_SLOT 9
41 #define DEBUG_LEVEL 0
42
43 #define fldw(addr, fpreg) \
44 __asm__ volatile ("fldw 0(%0), %%" #fpreg "L" : : "r"(addr) : #fpreg)
45 #define fstw(fpreg, addr) \
46 __asm__ volatile ("fstw %%" #fpreg "L, 0(%0)" : : "r"(addr))
47 #define fldd(addr, fpreg) \
48 __asm__ volatile ("fldd 0(%0), %%" #fpreg : : "r"(addr) : #fpreg)
49 #define fstd(fpreg, addr) \
50 __asm__ volatile ("fstd %%" #fpreg "L, 0(%0)" : : "r"(addr))
51
52 #define debug(lvl, x...) do { if (lvl <= DEBUG_LEVEL) { printf(x); } } while (0)
53
54 static inline int ffi_struct_type(ffi_type *t)
55 {
56 size_t sz = t->size;
57
58 /* Small structure results are passed in registers,
59 larger ones are passed by pointer. Note that small
60 structures differ from the corresponding integer
61 types in that they have different alignment requirements. */
62
63 if (sz <= 8)
64 return -sz;
65 else
66 return FFI_TYPE_STRUCT; /* else, we pass it by pointer. */
67 }
68
69 /* PA has a downward growing stack, which looks like this:
70
71 Offset
72 [ Variable args ]
73 SP = (4*(n+9)) arg word N
74 ...
75 SP-52 arg word 4
76 [ Fixed args ]
77 SP-48 arg word 3
78 SP-44 arg word 2
79 SP-40 arg word 1
80 SP-36 arg word 0
81 [ Frame marker ]
82 ...
83 SP-20 RP
84 SP-4 previous SP
85
86 The first four argument words on the stack are reserved for use by
87 the callee. Instead, the general and floating registers replace
88 the first four argument slots. Non FP arguments are passed solely
89 in the general registers. FP arguments are passed in both general
90 and floating registers when using libffi.
91
92 Non-FP 32-bit args are passed in gr26, gr25, gr24 and gr23.
93 Non-FP 64-bit args are passed in register pairs, starting
94 on an odd numbered register (i.e. r25+r26 and r23+r24).
95 FP 32-bit arguments are passed in fr4L, fr5L, fr6L and fr7L.
96 FP 64-bit arguments are passed in fr5 and fr7.
97
98 The registers are allocated in the same manner as stack slots.
99 This allows the callee to save its arguments on the stack if
100 necessary:
101
102 arg word 3 -> gr23 or fr7L
103 arg word 2 -> gr24 or fr6L or fr7R
104 arg word 1 -> gr25 or fr5L
105 arg word 0 -> gr26 or fr4L or fr5R
106
107 Note that fr4R and fr6R are never used for arguments (i.e.,
108 doubles are not passed in fr4 or fr6).
109
110 The rest of the arguments are passed on the stack starting at SP-52,
111 but 64-bit arguments need to be aligned to an 8-byte boundary
112
113 This means we can have holes either in the register allocation,
114 or in the stack. */
115
116 /* ffi_prep_args is called by the assembly routine once stack space
117 has been allocated for the function's arguments
118
119 The following code will put everything into the stack frame
120 (which was allocated by the asm routine), and on return
121 the asm routine will load the arguments that should be
122 passed by register into the appropriate registers
123
124 NOTE: We load floating point args in this function... that means we
125 assume gcc will not mess with fp regs in here. */
126
127 void ffi_prep_args_pa32(UINT32 *stack, extended_cif *ecif, unsigned bytes)
128 {
129 register unsigned int i;
130 register ffi_type **p_arg;
131 register void **p_argv;
132 unsigned int slot = FIRST_ARG_SLOT;
133 char *dest_cpy;
134 size_t len;
135
136 debug(1, "%s: stack = %p, ecif = %p, bytes = %u\n", __FUNCTION__, stack,
137 ecif, bytes);
138
139 p_arg = ecif->cif->arg_types;
140 p_argv = ecif->avalue;
141
142 for (i = 0; i < ecif->cif->nargs; i++)
143 {
144 int type = (*p_arg)->type;
145
146 switch (type)
147 {
148 case FFI_TYPE_SINT8:
149 *(SINT32 *)(stack - slot) = *(SINT8 *)(*p_argv);
150 break;
151
152 case FFI_TYPE_UINT8:
153 *(UINT32 *)(stack - slot) = *(UINT8 *)(*p_argv);
154 break;
155
156 case FFI_TYPE_SINT16:
157 *(SINT32 *)(stack - slot) = *(SINT16 *)(*p_argv);
158 break;
159
160 case FFI_TYPE_UINT16:
161 *(UINT32 *)(stack - slot) = *(UINT16 *)(*p_argv);
162 break;
163
164 case FFI_TYPE_UINT32:
165 case FFI_TYPE_SINT32:
166 case FFI_TYPE_POINTER:
167 debug(3, "Storing UINT32 %u in slot %u\n", *(UINT32 *)(*p_argv),
168 slot);
169 *(UINT32 *)(stack - slot) = *(UINT32 *)(*p_argv);
170 break;
171
172 case FFI_TYPE_UINT64:
173 case FFI_TYPE_SINT64:
174 /* Align slot for 64-bit type. */
175 slot += (slot & 1) ? 1 : 2;
176 *(UINT64 *)(stack - slot) = *(UINT64 *)(*p_argv);
177 break;
178
179 case FFI_TYPE_FLOAT:
180 /* First 4 args go in fr4L - fr7L. */
181 debug(3, "Storing UINT32(float) in slot %u\n", slot);
182 *(UINT32 *)(stack - slot) = *(UINT32 *)(*p_argv);
183 switch (slot - FIRST_ARG_SLOT)
184 {
185 /* First 4 args go in fr4L - fr7L. */
186 case 0: fldw(stack - slot, fr4); break;
187 case 1: fldw(stack - slot, fr5); break;
188 case 2: fldw(stack - slot, fr6); break;
189 case 3: fldw(stack - slot, fr7); break;
190 }
191 break;
192
193 case FFI_TYPE_DOUBLE:
194 /* Align slot for 64-bit type. */
195 slot += (slot & 1) ? 1 : 2;
196 debug(3, "Storing UINT64(double) at slot %u\n", slot);
197 *(UINT64 *)(stack - slot) = *(UINT64 *)(*p_argv);
198 switch (slot - FIRST_ARG_SLOT)
199 {
200 /* First 2 args go in fr5, fr7. */
201 case 1: fldd(stack - slot, fr5); break;
202 case 3: fldd(stack - slot, fr7); break;
203 }
204 break;
205
206 #ifdef PA_HPUX
207 case FFI_TYPE_LONGDOUBLE:
208 /* Long doubles are passed in the same manner as structures
209 larger than 8 bytes. */
210 *(UINT32 *)(stack - slot) = (UINT32)(*p_argv);
211 break;
212 #endif
213
214 case FFI_TYPE_STRUCT:
215
216 /* Structs smaller or equal than 4 bytes are passed in one
217 register. Structs smaller or equal 8 bytes are passed in two
218 registers. Larger structures are passed by pointer. */
219
220 len = (*p_arg)->size;
221 if (len <= 4)
222 {
223 dest_cpy = (char *)(stack - slot) + 4 - len;
224 memcpy(dest_cpy, (char *)*p_argv, len);
225 }
226 else if (len <= 8)
227 {
228 slot += (slot & 1) ? 1 : 2;
229 dest_cpy = (char *)(stack - slot) + 8 - len;
230 memcpy(dest_cpy, (char *)*p_argv, len);
231 }
232 else
233 *(UINT32 *)(stack - slot) = (UINT32)(*p_argv);
234 break;
235
236 default:
237 FFI_ASSERT(0);
238 }
239
240 slot++;
241 p_arg++;
242 p_argv++;
243 }
244
245 /* Make sure we didn't mess up and scribble on the stack. */
246 {
247 unsigned int n;
248
249 debug(5, "Stack setup:\n");
250 for (n = 0; n < (bytes + 3) / 4; n++)
251 {
252 if ((n%4) == 0) { debug(5, "\n%08x: ", (unsigned int)(stack - n)); }
253 debug(5, "%08x ", *(stack - n));
254 }
255 debug(5, "\n");
256 }
257
258 FFI_ASSERT(slot * 4 <= bytes);
259
260 return;
261 }
262
263 static void ffi_size_stack_pa32(ffi_cif *cif)
264 {
265 ffi_type **ptr;
266 int i;
267 int z = 0; /* # stack slots */
268
269 for (ptr = cif->arg_types, i = 0; i < cif->nargs; ptr++, i++)
270 {
271 int type = (*ptr)->type;
272
273 switch (type)
274 {
275 case FFI_TYPE_DOUBLE:
276 case FFI_TYPE_UINT64:
277 case FFI_TYPE_SINT64:
278 z += 2 + (z & 1); /* must start on even regs, so we may waste one */
279 break;
280
281 #ifdef PA_HPUX
282 case FFI_TYPE_LONGDOUBLE:
283 #endif
284 case FFI_TYPE_STRUCT:
285 z += 1; /* pass by ptr, callee will copy */
286 break;
287
288 default: /* <= 32-bit values */
289 z++;
290 }
291 }
292
293 /* We can fit up to 6 args in the default 64-byte stack frame,
294 if we need more, we need more stack. */
295 if (z <= 6)
296 cif->bytes = MIN_STACK_SIZE; /* min stack size */
297 else
298 cif->bytes = 64 + ROUND_UP((z - 6) * sizeof(UINT32), MIN_STACK_SIZE);
299
300 debug(3, "Calculated stack size is %u bytes\n", cif->bytes);
301 }
302
303 /* Perform machine dependent cif processing. */
304 ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
305 {
306 /* Set the return type flag */
307 switch (cif->rtype->type)
308 {
309 case FFI_TYPE_VOID:
310 case FFI_TYPE_FLOAT:
311 case FFI_TYPE_DOUBLE:
312 cif->flags = (unsigned) cif->rtype->type;
313 break;
314
315 #ifdef PA_HPUX
316 case FFI_TYPE_LONGDOUBLE:
317 /* Long doubles are treated like a structure. */
318 cif->flags = FFI_TYPE_STRUCT;
319 break;
320 #endif
321
322 case FFI_TYPE_STRUCT:
323 /* For the return type we have to check the size of the structures.
324 If the size is smaller or equal 4 bytes, the result is given back
325 in one register. If the size is smaller or equal 8 bytes than we
326 return the result in two registers. But if the size is bigger than
327 8 bytes, we work with pointers. */
328 cif->flags = ffi_struct_type(cif->rtype);
329 break;
330
331 case FFI_TYPE_UINT64:
332 case FFI_TYPE_SINT64:
333 cif->flags = FFI_TYPE_UINT64;
334 break;
335
336 default:
337 cif->flags = FFI_TYPE_INT;
338 break;
339 }
340
341 /* Lucky us, because of the unique PA ABI we get to do our
342 own stack sizing. */
343 switch (cif->abi)
344 {
345 case FFI_PA32:
346 ffi_size_stack_pa32(cif);
347 break;
348
349 default:
350 FFI_ASSERT(0);
351 break;
352 }
353
354 return FFI_OK;
355 }
356
357 extern void ffi_call_pa32(void (*)(UINT32 *, extended_cif *, unsigned),
358 extended_cif *, unsigned, unsigned, unsigned *,
359 void (*fn)(void));
360
361 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
362 {
363 extended_cif ecif;
364 size_t i, nargs = cif->nargs;
365 ffi_type **arg_types = cif->arg_types;
366
367 ecif.cif = cif;
368 ecif.avalue = avalue;
369
370 /* If we have any large structure arguments, make a copy so we are passing
371 by value. */
372 for (i = 0; i < nargs; i++)
373 {
374 ffi_type *at = arg_types[i];
375 int size = at->size;
376 if (at->type == FFI_TYPE_STRUCT && size > 8)
377 {
378 char *argcopy = alloca (size);
379 memcpy (argcopy, avalue[i], size);
380 avalue[i] = argcopy;
381 }
382 }
383
384 /* If the return value is a struct and we don't have a return
385 value address then we need to make one. */
386
387 if (rvalue == NULL
388 #ifdef PA_HPUX
389 && (cif->rtype->type == FFI_TYPE_STRUCT
390 || cif->rtype->type == FFI_TYPE_LONGDOUBLE))
391 #else
392 && cif->rtype->type == FFI_TYPE_STRUCT)
393 #endif
394 {
395 ecif.rvalue = alloca(cif->rtype->size);
396 }
397 else
398 ecif.rvalue = rvalue;
399
400
401 switch (cif->abi)
402 {
403 case FFI_PA32:
404 debug(3, "Calling ffi_call_pa32: ecif=%p, bytes=%u, flags=%u, rvalue=%p, fn=%p\n", &ecif, cif->bytes, cif->flags, ecif.rvalue, (void *)fn);
405 ffi_call_pa32(ffi_prep_args_pa32, &ecif, cif->bytes,
406 cif->flags, ecif.rvalue, fn);
407 break;
408
409 default:
410 FFI_ASSERT(0);
411 break;
412 }
413 }
414
415 #if FFI_CLOSURES
416 /* This is more-or-less an inverse of ffi_call -- we have arguments on
417 the stack, and we need to fill them into a cif structure and invoke
418 the user function. This really ought to be in asm to make sure
419 the compiler doesn't do things we don't expect. */
420 ffi_status ffi_closure_inner_pa32(ffi_closure *closure, UINT32 *stack)
421 {
422 ffi_cif *cif;
423 void **avalue;
424 void *rvalue;
425 /* Functions can return up to 64-bits in registers. Return address
426 must be double word aligned. */
427 union { double rd; UINT32 ret[2]; } u;
428 ffi_type **p_arg;
429 char *tmp;
430 int i, avn;
431 unsigned int slot = FIRST_ARG_SLOT;
432 register UINT32 r28 asm("r28");
433
434 cif = closure->cif;
435
436 /* If returning via structure, callee will write to our pointer. */
437 if (cif->flags == FFI_TYPE_STRUCT)
438 rvalue = (void *)r28;
439 else
440 rvalue = &u;
441
442 avalue = (void **)alloca(cif->nargs * FFI_SIZEOF_ARG);
443 avn = cif->nargs;
444 p_arg = cif->arg_types;
445
446 for (i = 0; i < avn; i++)
447 {
448 int type = (*p_arg)->type;
449
450 switch (type)
451 {
452 case FFI_TYPE_SINT8:
453 case FFI_TYPE_UINT8:
454 case FFI_TYPE_SINT16:
455 case FFI_TYPE_UINT16:
456 case FFI_TYPE_SINT32:
457 case FFI_TYPE_UINT32:
458 case FFI_TYPE_POINTER:
459 avalue[i] = (char *)(stack - slot) + sizeof(UINT32) - (*p_arg)->size;
460 break;
461
462 case FFI_TYPE_SINT64:
463 case FFI_TYPE_UINT64:
464 slot += (slot & 1) ? 1 : 2;
465 avalue[i] = (void *)(stack - slot);
466 break;
467
468 case FFI_TYPE_FLOAT:
469 #ifdef PA_LINUX
470 /* The closure call is indirect. In Linux, floating point
471 arguments in indirect calls with a prototype are passed
472 in the floating point registers instead of the general
473 registers. So, we need to replace what was previously
474 stored in the current slot with the value in the
475 corresponding floating point register. */
476 switch (slot - FIRST_ARG_SLOT)
477 {
478 case 0: fstw(fr4, (void *)(stack - slot)); break;
479 case 1: fstw(fr5, (void *)(stack - slot)); break;
480 case 2: fstw(fr6, (void *)(stack - slot)); break;
481 case 3: fstw(fr7, (void *)(stack - slot)); break;
482 }
483 #endif
484 avalue[i] = (void *)(stack - slot);
485 break;
486
487 case FFI_TYPE_DOUBLE:
488 slot += (slot & 1) ? 1 : 2;
489 #ifdef PA_LINUX
490 /* See previous comment for FFI_TYPE_FLOAT. */
491 switch (slot - FIRST_ARG_SLOT)
492 {
493 case 1: fstd(fr5, (void *)(stack - slot)); break;
494 case 3: fstd(fr7, (void *)(stack - slot)); break;
495 }
496 #endif
497 avalue[i] = (void *)(stack - slot);
498 break;
499
500 #ifdef PA_HPUX
501 case FFI_TYPE_LONGDOUBLE:
502 /* Long doubles are treated like a big structure. */
503 avalue[i] = (void *) *(stack - slot);
504 break;
505 #endif
506
507 case FFI_TYPE_STRUCT:
508 /* Structs smaller or equal than 4 bytes are passed in one
509 register. Structs smaller or equal 8 bytes are passed in two
510 registers. Larger structures are passed by pointer. */
511 if((*p_arg)->size <= 4)
512 {
513 avalue[i] = (void *)(stack - slot) + sizeof(UINT32) -
514 (*p_arg)->size;
515 }
516 else if ((*p_arg)->size <= 8)
517 {
518 slot += (slot & 1) ? 1 : 2;
519 avalue[i] = (void *)(stack - slot) + sizeof(UINT64) -
520 (*p_arg)->size;
521 }
522 else
523 avalue[i] = (void *) *(stack - slot);
524 break;
525
526 default:
527 FFI_ASSERT(0);
528 }
529
530 slot++;
531 p_arg++;
532 }
533
534 /* Invoke the closure. */
535 (closure->fun) (cif, rvalue, avalue, closure->user_data);
536
537 debug(3, "after calling function, ret[0] = %08x, ret[1] = %08x\n", u.ret[0],
538 u.ret[1]);
539
540 /* Store the result using the lower 2 bytes of the flags. */
541 switch (cif->flags)
542 {
543 case FFI_TYPE_UINT8:
544 *(stack - FIRST_ARG_SLOT) = (UINT8)u.ret[0];
545 break;
546 case FFI_TYPE_SINT8:
547 *(stack - FIRST_ARG_SLOT) = (SINT8)u.ret[0];
548 break;
549 case FFI_TYPE_UINT16:
550 *(stack - FIRST_ARG_SLOT) = (UINT16)u.ret[0];
551 break;
552 case FFI_TYPE_SINT16:
553 *(stack - FIRST_ARG_SLOT) = (SINT16)u.ret[0];
554 break;
555 case FFI_TYPE_INT:
556 case FFI_TYPE_SINT32:
557 case FFI_TYPE_UINT32:
558 *(stack - FIRST_ARG_SLOT) = u.ret[0];
559 break;
560 case FFI_TYPE_SINT64:
561 case FFI_TYPE_UINT64:
562 *(stack - FIRST_ARG_SLOT) = u.ret[0];
563 *(stack - FIRST_ARG_SLOT - 1) = u.ret[1];
564 break;
565
566 case FFI_TYPE_DOUBLE:
567 fldd(rvalue, fr4);
568 break;
569
570 case FFI_TYPE_FLOAT:
571 fldw(rvalue, fr4);
572 break;
573
574 case FFI_TYPE_STRUCT:
575 /* Don't need a return value, done by caller. */
576 break;
577
578 case FFI_TYPE_SMALL_STRUCT1:
579 case FFI_TYPE_SMALL_STRUCT2:
580 case FFI_TYPE_SMALL_STRUCT3:
581 case FFI_TYPE_SMALL_STRUCT4:
582 tmp = (void*)(stack - FIRST_ARG_SLOT);
583 tmp += 4 - cif->rtype->size;
584 memcpy((void*)tmp, &u, cif->rtype->size);
585 break;
586
587 case FFI_TYPE_SMALL_STRUCT5:
588 case FFI_TYPE_SMALL_STRUCT6:
589 case FFI_TYPE_SMALL_STRUCT7:
590 case FFI_TYPE_SMALL_STRUCT8:
591 {
592 unsigned int ret2[2];
593 int off;
594
595 /* Right justify ret[0] and ret[1] */
596 switch (cif->flags)
597 {
598 case FFI_TYPE_SMALL_STRUCT5: off = 3; break;
599 case FFI_TYPE_SMALL_STRUCT6: off = 2; break;
600 case FFI_TYPE_SMALL_STRUCT7: off = 1; break;
601 default: off = 0; break;
602 }
603
604 memset (ret2, 0, sizeof (ret2));
605 memcpy ((char *)ret2 + off, &u, 8 - off);
606
607 *(stack - FIRST_ARG_SLOT) = ret2[0];
608 *(stack - FIRST_ARG_SLOT - 1) = ret2[1];
609 }
610 break;
611
612 case FFI_TYPE_POINTER:
613 case FFI_TYPE_VOID:
614 break;
615
616 default:
617 debug(0, "assert with cif->flags: %d\n",cif->flags);
618 FFI_ASSERT(0);
619 break;
620 }
621 return FFI_OK;
622 }
623
624 /* Fill in a closure to refer to the specified fun and user_data.
625 cif specifies the argument and result types for fun.
626 The cif must already be prep'ed. */
627
628 extern void ffi_closure_pa32(void);
629
630 ffi_status
631 ffi_prep_closure_loc (ffi_closure* closure,
632 ffi_cif* cif,
633 void (*fun)(ffi_cif*,void*,void**,void*),
634 void *user_data,
635 void *codeloc)
636 {
637 /* The layout of a function descriptor. A function pointer with the PLABEL
638 bit set points to a function descriptor. */
639 struct pa32_fd
640 {
641 UINT32 code_pointer;
642 UINT32 gp;
643 };
644
645 struct ffi_pa32_trampoline_struct
646 {
647 UINT32 code_pointer; /* Pointer to ffi_closure_unix. */
648 UINT32 fake_gp; /* Pointer to closure, installed as gp. */
649 UINT32 real_gp; /* Real gp value. */
650 };
651
652 struct ffi_pa32_trampoline_struct *tramp;
653 struct pa32_fd *fd;
654
655 if (cif->abi != FFI_PA32)
656 return FFI_BAD_ABI;
657
658 /* Get function descriptor address for ffi_closure_pa32. */
659 fd = (struct pa32_fd *)((UINT32)ffi_closure_pa32 & ~3);
660
661 /* Setup trampoline. */
662 tramp = (struct ffi_pa32_trampoline_struct *)closure->tramp;
663 tramp->code_pointer = fd->code_pointer;
664 tramp->fake_gp = (UINT32)codeloc & ~3;
665 tramp->real_gp = fd->gp;
666
667 closure->cif = cif;
668 closure->user_data = user_data;
669 closure->fun = fun;
670
671 return FFI_OK;
672 }
673 #endif