/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
C | 800 lines | 493 code | 101 blank | 206 comment | 92 complexity | 99c864cc939078110592da3cedda290f MD5 | raw file
1/* ----------------------------------------------------------------------- 2 ffi_darwin.c 3 4 Copyright (C) 1998 Geoffrey Keating 5 Copyright (C) 2001 John Hornkvist 6 Copyright (C) 2002, 2006, 2007 Free Software Foundation, Inc. 7 8 FFI support for Darwin and AIX. 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, EXPRESS 22 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 24 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR 25 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 26 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 27 OTHER DEALINGS IN THE SOFTWARE. 28 ----------------------------------------------------------------------- */ 29 30#include <ffi.h> 31#include <ffi_common.h> 32 33#include <stdlib.h> 34 35extern void ffi_closure_ASM(void); 36 37enum { 38 /* The assembly depends on these exact flags. */ 39 FLAG_RETURNS_NOTHING = 1 << (31-30), /* These go in cr7 */ 40 FLAG_RETURNS_FP = 1 << (31-29), 41 FLAG_RETURNS_64BITS = 1 << (31-28), 42 FLAG_RETURNS_128BITS = 1 << (31-31), 43 44 FLAG_ARG_NEEDS_COPY = 1 << (31- 7), 45 FLAG_FP_ARGUMENTS = 1 << (31- 6), /* cr1.eq; specified by ABI */ 46 FLAG_4_GPR_ARGUMENTS = 1 << (31- 5), 47 FLAG_RETVAL_REFERENCE = 1 << (31- 4) 48}; 49 50/* About the DARWIN ABI. */ 51enum { 52 NUM_GPR_ARG_REGISTERS = 8, 53 NUM_FPR_ARG_REGISTERS = 13 54}; 55enum { ASM_NEEDS_REGISTERS = 4 }; 56 57/* ffi_prep_args is called by the assembly routine once stack space 58 has been allocated for the function's arguments. 59 60 The stack layout we want looks like this: 61 62 | Return address from ffi_call_DARWIN | higher addresses 63 |--------------------------------------------| 64 | Previous backchain pointer 4 | stack pointer here 65 |--------------------------------------------|<+ <<< on entry to 66 | Saved r28-r31 4*4 | | ffi_call_DARWIN 67 |--------------------------------------------| | 68 | Parameters (at least 8*4=32) | | 69 |--------------------------------------------| | 70 | Space for GPR2 4 | | 71 |--------------------------------------------| | stack | 72 | Reserved 2*4 | | grows | 73 |--------------------------------------------| | down V 74 | Space for callee's LR 4 | | 75 |--------------------------------------------| | lower addresses 76 | Saved CR 4 | | 77 |--------------------------------------------| | stack pointer here 78 | Current backchain pointer 4 |-/ during 79 |--------------------------------------------| <<< ffi_call_DARWIN 80 81 */ 82 83void ffi_prep_args(extended_cif *ecif, unsigned *const stack) 84{ 85 const unsigned bytes = ecif->cif->bytes; 86 const unsigned flags = ecif->cif->flags; 87 88 /* 'stacktop' points at the previous backchain pointer. */ 89 unsigned *const stacktop = stack + (bytes / sizeof(unsigned)); 90 91 /* 'fpr_base' points at the space for fpr1, and grows upwards as 92 we use FPR registers. */ 93 double *fpr_base = (double*) (stacktop - ASM_NEEDS_REGISTERS) - NUM_FPR_ARG_REGISTERS; 94 int fparg_count = 0; 95 96 97 /* 'next_arg' grows up as we put parameters in it. */ 98 unsigned *next_arg = stack + 6; /* 6 reserved positions. */ 99 100 int i = ecif->cif->nargs; 101 double double_tmp; 102 void **p_argv = ecif->avalue; 103 unsigned gprvalue; 104 ffi_type** ptr = ecif->cif->arg_types; 105 char *dest_cpy; 106 unsigned size_al = 0; 107 108 /* Check that everything starts aligned properly. */ 109 FFI_ASSERT(((unsigned)(char *)stack & 0xF) == 0); 110 FFI_ASSERT(((unsigned)(char *)stacktop & 0xF) == 0); 111 FFI_ASSERT((bytes & 0xF) == 0); 112 113 /* Deal with return values that are actually pass-by-reference. 114 Rule: 115 Return values are referenced by r3, so r4 is the first parameter. */ 116 117 if (flags & FLAG_RETVAL_REFERENCE) 118 *next_arg++ = (unsigned)(char *)ecif->rvalue; 119 120 /* Now for the arguments. */ 121 for (; 122 i > 0; 123 i--, ptr++, p_argv++) 124 { 125 switch ((*ptr)->type) 126 { 127 /* If a floating-point parameter appears before all of the general- 128 purpose registers are filled, the corresponding GPRs that match 129 the size of the floating-point parameter are skipped. */ 130 case FFI_TYPE_FLOAT: 131 double_tmp = *(float *)*p_argv; 132 if (fparg_count >= NUM_FPR_ARG_REGISTERS) 133 *(double *)next_arg = double_tmp; 134 else 135 *fpr_base++ = double_tmp; 136 next_arg++; 137 fparg_count++; 138 FFI_ASSERT(flags & FLAG_FP_ARGUMENTS); 139 break; 140 141 case FFI_TYPE_DOUBLE: 142 double_tmp = *(double *)*p_argv; 143 if (fparg_count >= NUM_FPR_ARG_REGISTERS) 144 *(double *)next_arg = double_tmp; 145 else 146 *fpr_base++ = double_tmp; 147 next_arg += 2; 148 fparg_count++; 149 FFI_ASSERT(flags & FLAG_FP_ARGUMENTS); 150 break; 151 152#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE 153 154 case FFI_TYPE_LONGDOUBLE: 155 double_tmp = ((double *)*p_argv)[0]; 156 if (fparg_count >= NUM_FPR_ARG_REGISTERS) 157 *(double *)next_arg = double_tmp; 158 else 159 *fpr_base++ = double_tmp; 160 next_arg += 2; 161 fparg_count++; 162 double_tmp = ((double *)*p_argv)[1]; 163 if (fparg_count >= NUM_FPR_ARG_REGISTERS) 164 *(double *)next_arg = double_tmp; 165 else 166 *fpr_base++ = double_tmp; 167 next_arg += 2; 168 fparg_count++; 169 FFI_ASSERT(flags & FLAG_FP_ARGUMENTS); 170 break; 171#endif 172 case FFI_TYPE_UINT64: 173 case FFI_TYPE_SINT64: 174 *(long long *)next_arg = *(long long *)*p_argv; 175 next_arg+=2; 176 break; 177 case FFI_TYPE_UINT8: 178 gprvalue = *(unsigned char *)*p_argv; 179 goto putgpr; 180 case FFI_TYPE_SINT8: 181 gprvalue = *(signed char *)*p_argv; 182 goto putgpr; 183 case FFI_TYPE_UINT16: 184 gprvalue = *(unsigned short *)*p_argv; 185 goto putgpr; 186 case FFI_TYPE_SINT16: 187 gprvalue = *(signed short *)*p_argv; 188 goto putgpr; 189 190 case FFI_TYPE_STRUCT: 191 dest_cpy = (char *) next_arg; 192 193 /* Structures that match the basic modes (QI 1 byte, HI 2 bytes, 194 SI 4 bytes) are aligned as if they were those modes. 195 Structures with 3 byte in size are padded upwards. */ 196 size_al = (*ptr)->size; 197 /* If the first member of the struct is a double, then align 198 the struct to double-word. 199 Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */ 200 if ((*ptr)->elements[0]->type == 3) 201 size_al = ALIGN((*ptr)->size, 8); 202 if (size_al < 3 && ecif->cif->abi == FFI_DARWIN) 203 dest_cpy += 4 - size_al; 204 205 memcpy((char *)dest_cpy, (char *)*p_argv, size_al); 206 next_arg += (size_al + 3) / 4; 207 break; 208 209 case FFI_TYPE_INT: 210 case FFI_TYPE_UINT32: 211 case FFI_TYPE_SINT32: 212 case FFI_TYPE_POINTER: 213 gprvalue = *(unsigned *)*p_argv; 214 putgpr: 215 *next_arg++ = gprvalue; 216 break; 217 default: 218 break; 219 } 220 } 221 222 /* Check that we didn't overrun the stack... */ 223 //FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS); 224 //FFI_ASSERT((unsigned *)fpr_base 225 // <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS); 226 //FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4); 227} 228 229/* Adjust the size of S to be correct for Darwin. 230 On Darwin, the first field of a structure has natural alignment. */ 231 232static void 233darwin_adjust_aggregate_sizes (ffi_type *s) 234{ 235 int i; 236 237 if (s->type != FFI_TYPE_STRUCT) 238 return; 239 240 s->size = 0; 241 for (i = 0; s->elements[i] != NULL; i++) 242 { 243 ffi_type *p; 244 int align; 245 246 p = s->elements[i]; 247 darwin_adjust_aggregate_sizes (p); 248 if (i == 0 249 && (p->type == FFI_TYPE_UINT64 250 || p->type == FFI_TYPE_SINT64 251 || p->type == FFI_TYPE_DOUBLE 252 || p->alignment == 8)) 253 align = 8; 254 else if (p->alignment == 16 || p->alignment < 4) 255 align = p->alignment; 256 else 257 align = 4; 258 s->size = ALIGN(s->size, align) + p->size; 259 } 260 261 s->size = ALIGN(s->size, s->alignment); 262 263 if (s->elements[0]->type == FFI_TYPE_UINT64 264 || s->elements[0]->type == FFI_TYPE_SINT64 265 || s->elements[0]->type == FFI_TYPE_DOUBLE 266 || s->elements[0]->alignment == 8) 267 s->alignment = s->alignment > 8 ? s->alignment : 8; 268 /* Do not add additional tail padding. */ 269} 270 271/* Perform machine dependent cif processing. */ 272ffi_status ffi_prep_cif_machdep(ffi_cif *cif) 273{ 274 /* All this is for the DARWIN ABI. */ 275 int i; 276 ffi_type **ptr; 277 unsigned bytes; 278 int fparg_count = 0, intarg_count = 0; 279 unsigned flags = 0; 280 unsigned size_al = 0; 281 282 /* All the machine-independent calculation of cif->bytes will be wrong. 283 All the calculation of structure sizes will also be wrong. 284 Redo the calculation for DARWIN. */ 285 286 if (cif->abi == FFI_DARWIN) 287 { 288 darwin_adjust_aggregate_sizes (cif->rtype); 289 for (i = 0; i < cif->nargs; i++) 290 darwin_adjust_aggregate_sizes (cif->arg_types[i]); 291 } 292 293 /* Space for the frame pointer, callee's LR, CR, etc, and for 294 the asm's temp regs. */ 295 296 bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long); 297 298 /* Return value handling. The rules are as follows: 299 - 32-bit (or less) integer values are returned in gpr3; 300 - Structures of size <= 4 bytes also returned in gpr3; 301 - 64-bit integer values and structures between 5 and 8 bytes are returned 302 in gpr3 and gpr4; 303 - Single/double FP values are returned in fpr1; 304 - Long double FP (if not equivalent to double) values are returned in 305 fpr1 and fpr2; 306 - Larger structures values are allocated space and a pointer is passed 307 as the first argument. */ 308 switch (cif->rtype->type) 309 { 310 311#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE 312 case FFI_TYPE_LONGDOUBLE: 313 flags |= FLAG_RETURNS_128BITS; 314 flags |= FLAG_RETURNS_FP; 315 break; 316#endif 317 318 case FFI_TYPE_DOUBLE: 319 flags |= FLAG_RETURNS_64BITS; 320 /* Fall through. */ 321 case FFI_TYPE_FLOAT: 322 flags |= FLAG_RETURNS_FP; 323 break; 324 325 case FFI_TYPE_UINT64: 326 case FFI_TYPE_SINT64: 327 flags |= FLAG_RETURNS_64BITS; 328 break; 329 330 case FFI_TYPE_STRUCT: 331 flags |= FLAG_RETVAL_REFERENCE; 332 flags |= FLAG_RETURNS_NOTHING; 333 intarg_count++; 334 break; 335 case FFI_TYPE_VOID: 336 flags |= FLAG_RETURNS_NOTHING; 337 break; 338 339 default: 340 /* Returns 32-bit integer, or similar. Nothing to do here. */ 341 break; 342 } 343 344 /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the 345 first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest 346 goes on the stack. Structures are passed as a pointer to a copy of 347 the structure. Stuff on the stack needs to keep proper alignment. */ 348 for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++) 349 { 350 switch ((*ptr)->type) 351 { 352 case FFI_TYPE_FLOAT: 353 case FFI_TYPE_DOUBLE: 354 fparg_count++; 355 /* If this FP arg is going on the stack, it must be 356 8-byte-aligned. */ 357 if (fparg_count > NUM_FPR_ARG_REGISTERS 358 && intarg_count%2 != 0) 359 intarg_count++; 360 break; 361 362#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE 363 364 case FFI_TYPE_LONGDOUBLE: 365 fparg_count += 2; 366 /* If this FP arg is going on the stack, it must be 367 8-byte-aligned. */ 368 if (fparg_count > NUM_FPR_ARG_REGISTERS 369 && intarg_count%2 != 0) 370 intarg_count++; 371 intarg_count +=2; 372 break; 373#endif 374 375 case FFI_TYPE_UINT64: 376 case FFI_TYPE_SINT64: 377 /* 'long long' arguments are passed as two words, but 378 either both words must fit in registers or both go 379 on the stack. If they go on the stack, they must 380 be 8-byte-aligned. */ 381 if (intarg_count == NUM_GPR_ARG_REGISTERS-1 382 || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0)) 383 intarg_count++; 384 intarg_count += 2; 385 break; 386 387 case FFI_TYPE_STRUCT: 388 size_al = (*ptr)->size; 389 /* If the first member of the struct is a double, then align 390 the struct to double-word. 391 Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */ 392 if ((*ptr)->elements[0]->type == 3) 393 size_al = ALIGN((*ptr)->size, 8); 394 intarg_count += (size_al + 3) / 4; 395 break; 396 397 default: 398 /* Everything else is passed as a 4-byte word in a GPR, either 399 the object itself or a pointer to it. */ 400 intarg_count++; 401 break; 402 } 403 } 404 405 if (fparg_count != 0) 406 flags |= FLAG_FP_ARGUMENTS; 407 408 /* Space for the FPR registers, if needed. */ 409 if (fparg_count != 0) 410 bytes += NUM_FPR_ARG_REGISTERS * sizeof(double); 411 412 /* Stack space. */ 413 if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS) 414 bytes += (intarg_count + 2 * fparg_count) * sizeof(long); 415 else 416 bytes += NUM_GPR_ARG_REGISTERS * sizeof(long); 417 418 /* The stack space allocated needs to be a multiple of 16 bytes. */ 419 bytes = (bytes + 15) & ~0xF; 420 421 cif->flags = flags; 422 cif->bytes = bytes; 423 424 return FFI_OK; 425} 426 427extern void ffi_call_AIX(extended_cif *, unsigned, unsigned, unsigned *, 428 void (*fn)(void), void (*fn2)(void)); 429extern void ffi_call_DARWIN(extended_cif *, unsigned, unsigned, unsigned *, 430 void (*fn)(void), void (*fn2)(void)); 431 432void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) 433{ 434 extended_cif ecif; 435 436 ecif.cif = cif; 437 ecif.avalue = avalue; 438 439 /* If the return value is a struct and we don't have a return 440 value address then we need to make one. */ 441 442 if ((rvalue == NULL) && 443 (cif->rtype->type == FFI_TYPE_STRUCT)) 444 { 445 ecif.rvalue = alloca(cif->rtype->size); 446 } 447 else 448 ecif.rvalue = rvalue; 449 450 switch (cif->abi) 451 { 452 case FFI_AIX: 453 ffi_call_AIX(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn, 454 ffi_prep_args); 455 break; 456 case FFI_DARWIN: 457 ffi_call_DARWIN(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn, 458 ffi_prep_args); 459 break; 460 default: 461 FFI_ASSERT(0); 462 break; 463 } 464} 465 466static void flush_icache(char *); 467static void flush_range(char *, int); 468 469/* The layout of a function descriptor. A C function pointer really 470 points to one of these. */ 471 472typedef struct aix_fd_struct { 473 void *code_pointer; 474 void *toc; 475} aix_fd; 476 477/* here I'd like to add the stack frame layout we use in darwin_closure.S 478 and aix_clsoure.S 479 480 SP previous -> +---------------------------------------+ <--- child frame 481 | back chain to caller 4 | 482 +---------------------------------------+ 4 483 | saved CR 4 | 484 +---------------------------------------+ 8 485 | saved LR 4 | 486 +---------------------------------------+ 12 487 | reserved for compilers 4 | 488 +---------------------------------------+ 16 489 | reserved for binders 4 | 490 +---------------------------------------+ 20 491 | saved TOC pointer 4 | 492 +---------------------------------------+ 24 493 | always reserved 8*4=32 (previous GPRs)| 494 | according to the linkage convention | 495 | from AIX | 496 +---------------------------------------+ 56 497 | our FPR area 13*8=104 | 498 | f1 | 499 | . | 500 | f13 | 501 +---------------------------------------+ 160 502 | result area 8 | 503 +---------------------------------------+ 168 504 | alignement to the next multiple of 16 | 505SP current --> +---------------------------------------+ 176 <- parent frame 506 | back chain to caller 4 | 507 +---------------------------------------+ 180 508 | saved CR 4 | 509 +---------------------------------------+ 184 510 | saved LR 4 | 511 +---------------------------------------+ 188 512 | reserved for compilers 4 | 513 +---------------------------------------+ 192 514 | reserved for binders 4 | 515 +---------------------------------------+ 196 516 | saved TOC pointer 4 | 517 +---------------------------------------+ 200 518 | always reserved 8*4=32 we store our | 519 | GPRs here | 520 | r3 | 521 | . | 522 | r10 | 523 +---------------------------------------+ 232 524 | overflow part | 525 +---------------------------------------+ xxx 526 | ???? | 527 +---------------------------------------+ xxx 528 529*/ 530ffi_status 531ffi_prep_closure_loc (ffi_closure* closure, 532 ffi_cif* cif, 533 void (*fun)(ffi_cif*, void*, void**, void*), 534 void *user_data, 535 void *codeloc) 536{ 537 unsigned int *tramp; 538 struct ffi_aix_trampoline_struct *tramp_aix; 539 aix_fd *fd; 540 541 switch (cif->abi) 542 { 543 case FFI_DARWIN: 544 545 FFI_ASSERT (cif->abi == FFI_DARWIN); 546 547 tramp = (unsigned int *) &closure->tramp[0]; 548 tramp[0] = 0x7c0802a6; /* mflr r0 */ 549 tramp[1] = 0x429f000d; /* bcl- 20,4*cr7+so,0x10 */ 550 tramp[4] = 0x7d6802a6; /* mflr r11 */ 551 tramp[5] = 0x818b0000; /* lwz r12,0(r11) function address */ 552 tramp[6] = 0x7c0803a6; /* mtlr r0 */ 553 tramp[7] = 0x7d8903a6; /* mtctr r12 */ 554 tramp[8] = 0x816b0004; /* lwz r11,4(r11) static chain */ 555 tramp[9] = 0x4e800420; /* bctr */ 556 tramp[2] = (unsigned long) ffi_closure_ASM; /* function */ 557 tramp[3] = (unsigned long) codeloc; /* context */ 558 559 closure->cif = cif; 560 closure->fun = fun; 561 closure->user_data = user_data; 562 563 /* Flush the icache. Only necessary on Darwin. */ 564 flush_range(codeloc, FFI_TRAMPOLINE_SIZE); 565 566 break; 567 568 case FFI_AIX: 569 570 tramp_aix = (struct ffi_aix_trampoline_struct *) (closure->tramp); 571 fd = (aix_fd *)(void *)ffi_closure_ASM; 572 573 FFI_ASSERT (cif->abi == FFI_AIX); 574 575 tramp_aix->code_pointer = fd->code_pointer; 576 tramp_aix->toc = fd->toc; 577 tramp_aix->static_chain = codeloc; 578 closure->cif = cif; 579 closure->fun = fun; 580 closure->user_data = user_data; 581 582 default: 583 584 FFI_ASSERT(0); 585 break; 586 } 587 return FFI_OK; 588} 589 590static void 591flush_icache(char *addr) 592{ 593#ifndef _AIX 594 __asm__ volatile ( 595 "dcbf 0,%0\n" 596 "\tsync\n" 597 "\ticbi 0,%0\n" 598 "\tsync\n" 599 "\tisync" 600 : : "r"(addr) : "memory"); 601#endif 602} 603 604static void 605flush_range(char * addr1, int size) 606{ 607#define MIN_LINE_SIZE 32 608 int i; 609 for (i = 0; i < size; i += MIN_LINE_SIZE) 610 flush_icache(addr1+i); 611 flush_icache(addr1+size-1); 612} 613 614typedef union 615{ 616 float f; 617 double d; 618} ffi_dblfl; 619 620int ffi_closure_helper_DARWIN (ffi_closure*, void*, 621 unsigned long*, ffi_dblfl*); 622 623/* Basically the trampoline invokes ffi_closure_ASM, and on 624 entry, r11 holds the address of the closure. 625 After storing the registers that could possibly contain 626 parameters to be passed into the stack frame and setting 627 up space for a return value, ffi_closure_ASM invokes the 628 following helper function to do most of the work. */ 629 630int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue, 631 unsigned long * pgr, ffi_dblfl * pfr) 632{ 633 /* rvalue is the pointer to space for return value in closure assembly 634 pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM 635 pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM. */ 636 637 typedef double ldbits[2]; 638 639 union ldu 640 { 641 ldbits lb; 642 long double ld; 643 }; 644 645 void ** avalue; 646 ffi_type ** arg_types; 647 long i, avn; 648 long nf; /* number of floating registers already used. */ 649 long ng; /* number of general registers already used. */ 650 ffi_cif * cif; 651 double temp; 652 unsigned size_al; 653 union ldu temp_ld; 654 655 cif = closure->cif; 656 avalue = alloca(cif->nargs * sizeof(void *)); 657 658 nf = 0; 659 ng = 0; 660 661 /* Copy the caller's structure return value address so that the closure 662 returns the data directly to the caller. */ 663 if (cif->rtype->type == FFI_TYPE_STRUCT) 664 { 665 rvalue = (void *) *pgr; 666 pgr++; 667 ng++; 668 } 669 670 i = 0; 671 avn = cif->nargs; 672 arg_types = cif->arg_types; 673 674 /* Grab the addresses of the arguments from the stack frame. */ 675 while (i < avn) 676 { 677 switch (arg_types[i]->type) 678 { 679 case FFI_TYPE_SINT8: 680 case FFI_TYPE_UINT8: 681 avalue[i] = (char *) pgr + 3; 682 ng++; 683 pgr++; 684 break; 685 686 case FFI_TYPE_SINT16: 687 case FFI_TYPE_UINT16: 688 avalue[i] = (char *) pgr + 2; 689 ng++; 690 pgr++; 691 break; 692 693 case FFI_TYPE_SINT32: 694 case FFI_TYPE_UINT32: 695 case FFI_TYPE_POINTER: 696 avalue[i] = pgr; 697 ng++; 698 pgr++; 699 break; 700 701 case FFI_TYPE_STRUCT: 702 /* Structures that match the basic modes (QI 1 byte, HI 2 bytes, 703 SI 4 bytes) are aligned as if they were those modes. */ 704 size_al = arg_types[i]->size; 705 /* If the first member of the struct is a double, then align 706 the struct to double-word. 707 Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */ 708 if (arg_types[i]->elements[0]->type == 3) 709 size_al = ALIGN(arg_types[i]->size, 8); 710 if (size_al < 3 && cif->abi == FFI_DARWIN) 711 avalue[i] = (void*) pgr + 4 - size_al; 712 else 713 avalue[i] = (void*) pgr; 714 ng += (size_al + 3) / 4; 715 pgr += (size_al + 3) / 4; 716 break; 717 718 case FFI_TYPE_SINT64: 719 case FFI_TYPE_UINT64: 720 /* Long long ints are passed in two gpr's. */ 721 avalue[i] = pgr; 722 ng += 2; 723 pgr += 2; 724 break; 725 726 case FFI_TYPE_FLOAT: 727 /* A float value consumes a GPR. 728 There are 13 64bit floating point registers. */ 729 if (nf < NUM_FPR_ARG_REGISTERS) 730 { 731 temp = pfr->d; 732 pfr->f = (float)temp; 733 avalue[i] = pfr; 734 pfr++; 735 } 736 else 737 { 738 avalue[i] = pgr; 739 } 740 nf++; 741 ng++; 742 pgr++; 743 break; 744 745 case FFI_TYPE_DOUBLE: 746 /* A double value consumes two GPRs. 747 There are 13 64bit floating point registers. */ 748 if (nf < NUM_FPR_ARG_REGISTERS) 749 { 750 avalue[i] = pfr; 751 pfr++; 752 } 753 else 754 { 755 avalue[i] = pgr; 756 } 757 nf++; 758 ng += 2; 759 pgr += 2; 760 break; 761 762#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE 763 764 case FFI_TYPE_LONGDOUBLE: 765 /* A long double value consumes four GPRs and two FPRs. 766 There are 13 64bit floating point registers. */ 767 if (nf < NUM_FPR_ARG_REGISTERS - 1) 768 { 769 avalue[i] = pfr; 770 pfr += 2; 771 } 772 /* Here we have the situation where one part of the long double 773 is stored in fpr13 and the other part is already on the stack. 774 We use a union to pass the long double to avalue[i]. */ 775 else if (nf == NUM_FPR_ARG_REGISTERS - 1) 776 { 777 memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits)); 778 memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits)); 779 avalue[i] = &temp_ld.ld; 780 } 781 else 782 { 783 avalue[i] = pgr; 784 } 785 nf += 2; 786 ng += 4; 787 pgr += 4; 788 break; 789#endif 790 default: 791 FFI_ASSERT(0); 792 } 793 i++; 794 } 795 796 (closure->fun) (cif, rvalue, avalue, closure->user_data); 797 798 /* Tell ffi_closure_ASM to perform return type promotions. */ 799 return cif->rtype->type; 800}