Debian Codegraph @

src/pa/ffi64.c

raw
1 /* -----------------------------------------------------------------------
2 ffi64.c - (c) 2022 John David Anglin <[email protected]>
3
4 HPPA Foreign Function Interface
5 PA 64-Bit ABI support
6
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 ``Software''), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
14
15 The above copyright notice and this permission notice shall be included
16 in all copies or substantial portions of the Software.
17
18 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25 DEALINGS IN THE SOFTWARE.
26 ----------------------------------------------------------------------- */
27
28 #include <ffi.h>
29 #include <ffi_common.h>
30
31 #include <stdlib.h>
32 #include <stdio.h>
33
34 #define ROUND_UP(v, a) (((size_t)(v) + (a) - 1) & ~((a) - 1))
35
36 #define FIRST_ARG_SLOT 0
37 #define DEBUG_LEVEL 0
38
39 #define fldw(addr, fpreg) \
40 __asm__ volatile ("fldw 4(%0), %%" #fpreg "R" : : "r"(addr) : #fpreg)
41 #define fstw(fpreg, addr) \
42 __asm__ volatile ("fstw %%" #fpreg "R, 4(%0)" : : "r"(addr))
43 #define fldd(addr, fpreg) \
44 __asm__ volatile ("fldd 0(%0), %%" #fpreg "L" : : "r"(addr) : #fpreg)
45 #define fstd(fpreg, addr) \
46 __asm__ volatile ("fstd %%" #fpreg "L, 0(%0)" : : "r"(addr))
47
48 #define debug(lvl, x...) do { if (lvl <= DEBUG_LEVEL) { printf(x); } } while (0)
49
50 static inline int ffi_struct_type(ffi_type *t)
51 {
52 int sz = t->size;
53
54 /* Small structure results are returned in registers 28 and 29,
55 larger ones are in a buffer allocated by the callee. The
56 address of the buffer is passed in r28. The buffer is supposed
57 to be aligned on a 16-byte boundary. Register return values are
58 padded on the right. The pad bits on the right are undefined. */
59
60 if (sz <= 16)
61 return -sz;
62 else
63 return FFI_TYPE_STRUCT;
64 }
65
66 /* PA has a downward growing stack, which looks like this. Stack
67 arguments are offset from the argument ponter (AP) in r29.
68
69 Offset
70 [ Fixed args ]
71 AP-64 arg word 0 (r26, fr4)
72 AP-56 arg word 1 (r25, fr5)
73 AP-48 arg word 2 (r24, fr6)
74 AP-40 arg word 3 (r23, fr7)
75 AP-32 arg word 4 (r22, fr8)
76 AP-24 arg word 5 (r21, fr9)
77 AP-16 arg word 6 (r20, fr10)
78 AP-8 arg word 7 (r19, fr11)
79 [ Variable args; AP = SP-16 if there are no variable args ]
80 AP stack arg 0
81 AP+8 stack arg 1
82 ...
83 [ Frame marker ]
84 SP-16 RP
85 SP-8 previous SP
86
87 The first eight argument words on the stack are reserved for use by
88 the callee. Instead, the general and floating registers replace
89 the first four argument slots. Non FP arguments are passed solely
90 in the general registers. Single and double FP arguments are passed
91 in both general and floating registers when using libffi.
92
93 The registers are allocated in the same manner as stack slots.
94 This allows the callee to save its arguments on the stack if
95 necessary:
96
97 arg word 0 -> gr26 or fr4L or fr4R
98 arg word 1 -> gr25 or fr5L or fr5R
99 arg word 2 -> gr24 or fr6L or fr6R
100 arg word 3 -> gr23 or fr7L or fr7R
101 ...
102
103 Single Single-precision floating-point parameters, when passed in
104 floating-point registers, are passed in the right halves of the
105 floating point registers; the left halves are unused.
106
107 Quad-precision floating-point parameters within the first 64 bytes of
108 the parameter list are always passed in general registers.
109
110 The rest of the arguments are passed on the stack starting at AP.
111
112 This means we can have holes either in the register allocation,
113 or in the stack. */
114
115 /* ffi_prep_args is called by the assembly routine once stack space
116 has been allocated for the function's arguments
117
118 The following code will put everything into the stack frame
119 (which was allocated by the asm routine), and on return
120 the asm routine will load the arguments that should be
121 passed by register into the appropriate registers
122
123 NOTE: We load floating point args in this function... that means we
124 assume gcc will not mess with fp regs in here. */
125
126 void ffi_prep_args_pa64(UINT64 *stack, extended_cif *ecif, unsigned bytes)
127 {
128 register unsigned int i;
129 register ffi_type **p_arg;
130 register void **p_argv;
131 unsigned int slot = FIRST_ARG_SLOT;
132 size_t len;
133
134 debug(1, "%s: stack = %p, ecif = %p, bytes = %u\n", __FUNCTION__, stack,
135 ecif, bytes);
136
137 p_arg = ecif->cif->arg_types;
138 p_argv = ecif->avalue;
139
140 for (i = 0; i < ecif->cif->nargs; i++)
141 {
142 int type = (*p_arg)->type;
143
144 len = (*p_arg)->size;
145
146 switch (type)
147 {
148 case FFI_TYPE_SINT8:
149 *(SINT64 *)(stack + slot) = *(SINT8 *)(*p_argv);
150 break;
151
152 case FFI_TYPE_UINT8:
153 *(UINT64 *)(stack + slot) = *(UINT8 *)(*p_argv);
154 break;
155
156 case FFI_TYPE_SINT16:
157 *(SINT64 *)(stack + slot) = *(SINT16 *)(*p_argv);
158 break;
159
160 case FFI_TYPE_UINT16:
161 *(UINT64 *)(stack + slot) = *(UINT16 *)(*p_argv);
162 break;
163
164 case FFI_TYPE_SINT32:
165 *(SINT64 *)(stack + slot) = *(SINT32 *)(*p_argv);
166 break;
167
168 case FFI_TYPE_UINT32:
169 *(UINT64 *)(stack + slot) = *(UINT32 *)(*p_argv);
170 break;
171
172 case FFI_TYPE_UINT64:
173 case FFI_TYPE_SINT64:
174 case FFI_TYPE_POINTER:
175 debug(3, "Storing UINT64 %lu in slot %u\n", *(UINT64 *)(*p_argv),
176 slot);
177 *(UINT64 *)(stack + slot) = *(UINT64 *)(*p_argv);
178 break;
179
180 case FFI_TYPE_FLOAT:
181 /* First 8 args go in fr4L - fr11L. */
182 debug(3, "Storing UINT32(float) in slot %u\n", slot);
183 *(UINT64 *)(stack + slot) = *(UINT32 *)(*p_argv);
184 switch (slot - FIRST_ARG_SLOT)
185 {
186 /* First 4 args go in fr4L - fr7L. */
187 case 0: fldw(stack + slot, fr4); break;
188 case 1: fldw(stack + slot, fr5); break;
189 case 2: fldw(stack + slot, fr6); break;
190 case 3: fldw(stack + slot, fr7); break;
191 case 4: fldw(stack + slot, fr8); break;
192 case 5: fldw(stack + slot, fr9); break;
193 case 6: fldw(stack + slot, fr10); break;
194 case 7: fldw(stack + slot, fr11); break;
195 }
196 break;
197
198 case FFI_TYPE_DOUBLE:
199 debug(3, "Storing UINT64(double) at slot %u\n", slot);
200 *(UINT64 *)(stack + slot) = *(UINT64 *)(*p_argv);
201 switch (slot - FIRST_ARG_SLOT)
202 {
203 /* First 8 args go in fr4 to fr11. */
204 case 0: fldd(stack + slot, fr4); break;
205 case 1: fldd(stack + slot, fr5); break;
206 case 2: fldd(stack + slot, fr6); break;
207 case 3: fldd(stack + slot, fr7); break;
208 case 4: fldd(stack + slot, fr8); break;
209 case 5: fldd(stack + slot, fr9); break;
210 case 6: fldd(stack + slot, fr10); break;
211 case 7: fldd(stack + slot, fr11); break;
212 }
213 break;
214
215 #ifdef PA64_HPUX
216 case FFI_TYPE_LONGDOUBLE:
217 /* Align slot to a 16-byte boundary. */
218 slot += (slot & 1);
219 *(UINT64 *)(stack + slot) = *(UINT64 *)(*p_argv);
220 *(UINT64 *)(stack + slot + 1) = *(UINT64 *)(*p_argv + 8);
221 break;
222 #endif
223
224 case FFI_TYPE_STRUCT:
225 /* Structs larger than 8 bytes are aligned on a 16-byte boundary. */
226 if (len > 8)
227 slot += (slot & 1);
228 memcpy((char *)(stack + slot), (char *)*p_argv, len);
229 break;
230
231 default:
232 FFI_ASSERT(0);
233 }
234
235 slot += ROUND_UP (len, 8) >> 3;
236 p_arg++;
237 p_argv++;
238 }
239
240 FFI_ASSERT(slot * 8 <= bytes);
241
242 return;
243 }
244
245 static void ffi_size_stack_pa64(ffi_cif *cif)
246 {
247 ffi_type **ptr;
248 int i;
249 int z = 0; /* # stack slots */
250
251 for (ptr = cif->arg_types, i = 0; i < cif->nargs; ptr++, i++)
252 {
253 int type = (*ptr)->type;
254 int size = (*ptr)->size;
255
256 switch (type)
257 {
258 #ifdef PA64_HPUX
259 case FFI_TYPE_LONGDOUBLE:
260 z += 2 + (z & 1);
261 break;
262 #endif
263
264 case FFI_TYPE_STRUCT:
265 if (size > 8)
266 z += (z & 1);
267 z += ROUND_UP (size, 8) >> 3;
268 break;
269
270 default: /* 64-bit values */
271 z++;
272 }
273 }
274
275 /* We need a minimum of 8 argument slots. Stack must be 16-byte
276 aligned. */
277 if (z <= 8)
278 z = 8;
279 else
280 z += (z & 1);
281
282 /* Add 16 bytes for frame marker. */
283 cif->bytes = z * 8 + 64;
284 debug(3, "Calculated stack size is %u bytes\n", cif->bytes);
285 }
286
287 /* Perform machine dependent cif processing. */
288 ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
289 {
290 /* Set the return type flag for jump table. */
291 switch (cif->rtype->type)
292 {
293 case FFI_TYPE_COMPLEX:
294 case FFI_TYPE_STRUCT:
295 /* For the return type we have to check the size of the structures.
296 If the size is smaller or equal 8 bytes, the result is given back
297 in one register. If the size is smaller or equal 16 bytes than we
298 return the result in two registers. If the size is bigger than
299 16 bytes, the return is in a buffer allocated by the caller. */
300 cif->flags = ffi_struct_type(cif->rtype);
301 break;
302
303 default:
304 cif->flags = (unsigned) cif->rtype->type;
305 break;
306 }
307
308 /* Lucky us, because of the unique PA ABI we get to do our
309 own stack sizing. */
310 switch (cif->abi)
311 {
312 case FFI_PA64:
313 ffi_size_stack_pa64(cif);
314 break;
315
316 default:
317 FFI_ASSERT(0);
318 break;
319 }
320
321 return FFI_OK;
322 }
323
324 extern void ffi_call_pa64(void (*)(UINT64 *, extended_cif *, unsigned),
325 extended_cif *, unsigned, unsigned, unsigned *,
326 void (*fn)(void));
327
328 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
329 {
330 extended_cif ecif;
331
332 ecif.cif = cif;
333 ecif.avalue = avalue;
334
335 /* If the return value is a struct and we don't have a return
336 value address then we need to make one. */
337
338 if (rvalue == NULL
339 && (cif->rtype->type == FFI_TYPE_STRUCT
340 || cif->rtype->type == FFI_TYPE_COMPLEX)
341 && cif->rtype->size > 16)
342 ecif.rvalue = alloca(ROUND_UP (cif->rtype->size, 16));
343 else
344 ecif.rvalue = rvalue;
345
346
347 switch (cif->abi)
348 {
349 case FFI_PA64:
350 debug(3, "Calling ffi_call_pa64: ecif=%p, bytes=%u, flags=%u, rvalue=%p, fn=%p\n", &ecif, cif->bytes, cif->flags, ecif.rvalue, (void *)fn);
351 ffi_call_pa64(ffi_prep_args_pa64, &ecif, cif->bytes,
352 cif->flags, ecif.rvalue, fn);
353 break;
354
355 default:
356 FFI_ASSERT(0);
357 break;
358 }
359 }
360
361 #if FFI_CLOSURES
362 /* This is more-or-less an inverse of ffi_call -- we have arguments on
363 the stack, and we need to fill them into a cif structure and invoke
364 the user function. This really ought to be in asm to make sure
365 the compiler doesn't do things we don't expect. */
366 ffi_status ffi_closure_inner_pa64(ffi_closure *closure, UINT64 *stack)
367 {
368 ffi_cif *cif;
369 void **avalue;
370 void *rvalue;
371 /* Functions can return up to 128-bits in registers. Return address
372 must be double word aligned. */
373 union { long double rld; UINT64 ret[2]; } u;
374 ffi_type **p_arg;
375 char *tmp;
376 int i, avn;
377 unsigned int slot = FIRST_ARG_SLOT;
378 register UINT64 r28 asm("r28");
379
380 cif = closure->cif;
381
382 /* If returning via structure, callee will write to our pointer. */
383 if (cif->flags == FFI_TYPE_STRUCT)
384 rvalue = (void *)r28;
385 else
386 rvalue = &u;
387
388 avalue = (void **)alloca(cif->nargs * FFI_SIZEOF_ARG);
389 avn = cif->nargs;
390 p_arg = cif->arg_types;
391
392 for (i = 0; i < avn; i++)
393 {
394 int type = (*p_arg)->type;
395
396 switch (type)
397 {
398 case FFI_TYPE_SINT8:
399 case FFI_TYPE_UINT8:
400 avalue[i] = (void *)(stack + slot) + 7;
401 break;
402
403 case FFI_TYPE_SINT16:
404 case FFI_TYPE_UINT16:
405 avalue[i] = (void *)(stack + slot) + 6;
406 break;
407
408 case FFI_TYPE_SINT32:
409 case FFI_TYPE_UINT32:
410 avalue[i] = (void *)(stack + slot) + 4;
411 break;
412
413 case FFI_TYPE_POINTER:
414 case FFI_TYPE_SINT64:
415 case FFI_TYPE_UINT64:
416 avalue[i] = (void *)(stack + slot);
417 break;
418
419 case FFI_TYPE_FLOAT:
420 /* The closure call is indirect. In Linux, floating point
421 arguments in indirect calls with a prototype are passed
422 in the floating point registers instead of the general
423 registers. So, we need to replace what was previously
424 stored in the current slot with the value in the
425 corresponding floating point register. */
426 switch (slot + FIRST_ARG_SLOT)
427 {
428 case 0: fstw(fr4, (void *)(stack + slot)); break;
429 case 1: fstw(fr5, (void *)(stack + slot)); break;
430 case 2: fstw(fr6, (void *)(stack + slot)); break;
431 case 3: fstw(fr7, (void *)(stack + slot)); break;
432 case 4: fstw(fr8, (void *)(stack + slot)); break;
433 case 5: fstw(fr9, (void *)(stack + slot)); break;
434 case 6: fstw(fr10, (void *)(stack + slot)); break;
435 case 7: fstw(fr11, (void *)(stack + slot)); break;
436 }
437 avalue[i] = (void *)(stack + slot) + 4;
438 break;
439
440 case FFI_TYPE_DOUBLE:
441 /* See previous comment for FFI_TYPE_FLOAT. */
442 switch (slot + FIRST_ARG_SLOT)
443 {
444 case 0: fstd(fr4, (void *)(stack + slot)); break;
445 case 1: fstd(fr5, (void *)(stack + slot)); break;
446 case 2: fstd(fr6, (void *)(stack + slot)); break;
447 case 3: fstd(fr7, (void *)(stack + slot)); break;
448 case 4: fstd(fr8, (void *)(stack + slot)); break;
449 case 5: fstd(fr9, (void *)(stack + slot)); break;
450 case 6: fstd(fr10, (void *)(stack + slot)); break;
451 case 7: fstd(fr11, (void *)(stack + slot)); break;
452 }
453 avalue[i] = (void *)(stack + slot);
454 break;
455
456 #ifdef PA64_HPUX
457 case FFI_TYPE_LONGDOUBLE:
458 /* Long doubles are treated like a big structure. */
459 slot += (slot & 1);
460 avalue[i] = (void *)(stack + slot);
461 break;
462 #endif
463
464 case FFI_TYPE_STRUCT:
465 /* All structs are passed in registers. Structs larger
466 than 8 bytes are aligned on a 16-byte boundary. */
467 if((*p_arg)->size > 8)
468 slot += (slot & 1);
469 avalue[i] = (void *) (stack + slot);
470 break;
471
472 default:
473 FFI_ASSERT(0);
474 }
475
476 slot += (ROUND_UP ((*p_arg)->size, 8) >> 3);
477 p_arg++;
478 }
479
480 /* Invoke the closure. */
481 (closure->fun) (cif, rvalue, avalue, closure->user_data);
482
483 debug(3, "after calling function, ret[0] = %16lx, ret[1] = %16lx\n", u.ret[0],
484 u.ret[1]);
485
486 /* Store the result using the lower 2 bytes of the flags. */
487 switch (cif->flags)
488 {
489 case FFI_TYPE_UINT8:
490 *(stack + FIRST_ARG_SLOT) = (UINT8)u.ret[0];
491 break;
492 case FFI_TYPE_SINT8:
493 *(stack + FIRST_ARG_SLOT) = (SINT8)u.ret[0];
494 break;
495 case FFI_TYPE_UINT16:
496 *(stack + FIRST_ARG_SLOT) = (UINT16)u.ret[0];
497 break;
498 case FFI_TYPE_SINT16:
499 *(stack + FIRST_ARG_SLOT) = (SINT16)u.ret[0];
500 break;
501 case FFI_TYPE_INT:
502 case FFI_TYPE_SINT32:
503 *(stack + FIRST_ARG_SLOT) = (SINT32)u.ret[0];
504 break;
505 case FFI_TYPE_UINT32:
506 *(stack - FIRST_ARG_SLOT) = (UINT32)u.ret[0];
507 break;
508 case FFI_TYPE_SINT64:
509 case FFI_TYPE_UINT64:
510 case FFI_TYPE_POINTER:
511 *(stack - FIRST_ARG_SLOT) = u.ret[0];
512 break;
513
514 case FFI_TYPE_LONGDOUBLE:
515 *(stack + FIRST_ARG_SLOT) = u.ret[0];
516 *(stack + FIRST_ARG_SLOT + 1) = u.ret[1];
517 break;
518
519 case FFI_TYPE_DOUBLE:
520 fldd(rvalue, fr4);
521 break;
522
523 case FFI_TYPE_FLOAT:
524 /* Adjust for address adjustment in fldw macro. */
525 fldw(rvalue - 4, fr4);
526 break;
527
528 case FFI_TYPE_STRUCT:
529 /* Don't need a return value, done by caller. */
530 break;
531
532 case -1:
533 case -2:
534 case -3:
535 case -4:
536 case -5:
537 case -6:
538 case -7:
539 case -8:
540 case -9:
541 case -10:
542 case -11:
543 case -12:
544 case -13:
545 case -14:
546 case -15:
547 case -16:
548 tmp = (void*)(stack + FIRST_ARG_SLOT);
549 memcpy((void*)tmp, &u, cif->rtype->size);
550 break;
551
552 case FFI_TYPE_VOID:
553 break;
554
555 default:
556 debug(0, "assert with cif->flags: %d\n",cif->flags);
557 FFI_ASSERT(0);
558 break;
559 }
560 return FFI_OK;
561 }
562
563 /* Fill in a closure to refer to the specified fun and user_data.
564 cif specifies the argument and result types for fun.
565 The cif must already be prep'ed. */
566
567 extern void ffi_closure_pa64(void);
568
569 ffi_status
570 ffi_prep_closure_loc (ffi_closure* closure,
571 ffi_cif* cif,
572 void (*fun)(ffi_cif*,void*,void**,void*),
573 void *user_data,
574 void *codeloc)
575 {
576 /* The layout of a function descriptor. */
577 struct pa64_fd
578 {
579 UINT64 tmp1;
580 UINT64 tmp2;
581 UINT64 code_pointer;
582 UINT64 gp;
583 };
584
585 struct ffi_pa64_trampoline_struct
586 {
587 UINT64 real_gp; /* Real gp value. */
588 UINT64 tmp2;
589 UINT64 code_pointer; /* Pointer to ffi_closure_unix. */
590 UINT64 fake_gp; /* Pointer to closure, installed as gp. */
591 };
592
593 struct ffi_pa64_trampoline_struct *tramp;
594 struct pa64_fd *fd;
595
596 if (cif->abi != FFI_PA64)
597 return FFI_BAD_ABI;
598
599 /* Get function descriptor address for ffi_closure_pa64. */
600 fd = (struct pa64_fd *)((UINT64)ffi_closure_pa64);
601
602 /* Setup trampoline. */
603 tramp = (struct ffi_pa64_trampoline_struct *)closure->tramp;
604 tramp->code_pointer = fd->code_pointer;
605 tramp->fake_gp = (UINT64)codeloc;
606 tramp->real_gp = fd->gp;
607
608 closure->cif = cif;
609 closure->user_data = user_data;
610 closure->fun = fun;
611
612 return FFI_OK;
613 }
614 #endif