| 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 |