1 /* -----------------------------------------------------------------------
2 ffi_darwin.c
3
4 Copyright (C) 1998 Geoffrey Keating
5 Copyright (C) 2001 John Hornkvist
6 Copyright (C) 2002, 2006, 2007, 2009, 2010 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
35 extern void ffi_closure_ASM (void);
36
37 #if defined (FFI_GO_CLOSURES)
38 extern void ffi_go_closure_ASM (void);
39 #endif
40
41 enum {
42 /* The assembly depends on these exact flags.
43 For Darwin64 (when FLAG_RETURNS_STRUCT is set):
44 FLAG_RETURNS_FP indicates that the structure embeds FP data.
45 FLAG_RETURNS_128BITS signals a special struct size that is not
46 expanded for float content. */
47 FLAG_RETURNS_128BITS = 1 << (31-31), /* These go in cr7 */
48 FLAG_RETURNS_NOTHING = 1 << (31-30),
49 FLAG_RETURNS_FP = 1 << (31-29),
50 FLAG_RETURNS_64BITS = 1 << (31-28),
51
52 FLAG_RETURNS_STRUCT = 1 << (31-27), /* This goes in cr6 */
53
54 FLAG_ARG_NEEDS_COPY = 1 << (31- 7),
55 FLAG_FP_ARGUMENTS = 1 << (31- 6), /* cr1.eq; specified by ABI */
56 FLAG_4_GPR_ARGUMENTS = 1 << (31- 5),
57 FLAG_RETVAL_REFERENCE = 1 << (31- 4)
58 };
59
60 /* About the DARWIN ABI. */
61 enum {
62 NUM_GPR_ARG_REGISTERS = 8,
63 NUM_FPR_ARG_REGISTERS = 13,
64 LINKAGE_AREA_GPRS = 6
65 };
66
67 enum { ASM_NEEDS_REGISTERS = 4 }; /* r28-r31 */
68
69 /* ffi_prep_args is called by the assembly routine once stack space
70 has been allocated for the function's arguments.
71
72 m32/m64
73
74 The stack layout we want looks like this:
75
76 | Return address from ffi_call_DARWIN | higher addresses
77 |--------------------------------------------|
78 | Previous backchain pointer 4/8 | stack pointer here
79 |--------------------------------------------|<+ <<< on entry to
80 | ASM_NEEDS_REGISTERS=r28-r31 4*(4/8) | | ffi_call_DARWIN
81 |--------------------------------------------| |
82 | When we have any FP activity... the | |
83 | FPRs occupy NUM_FPR_ARG_REGISTERS slots | |
84 | here fp13 .. fp1 from high to low addr. | |
85 ~ ~ ~
86 | Parameters (at least 8*4/8=32/64) | | NUM_GPR_ARG_REGISTERS
87 |--------------------------------------------| |
88 | TOC=R2 (AIX) Reserved (Darwin) 4/8 | |
89 |--------------------------------------------| | stack |
90 | Reserved 2*4/8 | | grows |
91 |--------------------------------------------| | down V
92 | Space for callee's LR 4/8 | |
93 |--------------------------------------------| | lower addresses
94 | Saved CR [low word for m64] 4/8 | |
95 |--------------------------------------------| | stack pointer here
96 | Current backchain pointer 4/8 |-/ during
97 |--------------------------------------------| <<< ffi_call_DARWIN
98
99 */
100
101 #if defined(POWERPC_DARWIN64)
102 static void
103 darwin64_pass_struct_by_value
104 (ffi_type *, char *, unsigned, unsigned *, double **, unsigned long **);
105 #endif
106
107 /* This depends on GPR_SIZE = sizeof (unsigned long) */
108
109 void
110 ffi_prep_args (extended_cif *ecif, unsigned long *const stack)
111 {
112 const unsigned bytes = ecif->cif->bytes;
113 const unsigned flags = ecif->cif->flags;
114 const unsigned nargs = ecif->cif->nargs;
115 #if !defined(POWERPC_DARWIN64)
116 const ffi_abi abi = ecif->cif->abi;
117 #endif
118
119 /* 'stacktop' points at the previous backchain pointer. */
120 unsigned long *const stacktop = stack + (bytes / sizeof(unsigned long));
121
122 /* 'fpr_base' points at the space for fpr1, and grows upwards as
123 we use FPR registers. */
124 double *fpr_base = (double *) (stacktop - ASM_NEEDS_REGISTERS) - NUM_FPR_ARG_REGISTERS;
125 int gp_count = 0, fparg_count = 0;
126
127 /* 'next_arg' grows up as we put parameters in it. */
128 unsigned long *next_arg = stack + LINKAGE_AREA_GPRS; /* 6 reserved positions. */
129
130 int i;
131 double double_tmp;
132 void **p_argv = ecif->avalue;
133 unsigned long gprvalue;
134 ffi_type** ptr = ecif->cif->arg_types;
135 #if !defined(POWERPC_DARWIN64)
136 char *dest_cpy;
137 #endif
138 unsigned size_al = 0;
139
140 /* Check that everything starts aligned properly. */
141 FFI_ASSERT(((unsigned) (char *) stack & 0xF) == 0);
142 FFI_ASSERT(((unsigned) (char *) stacktop & 0xF) == 0);
143 FFI_ASSERT((bytes & 0xF) == 0);
144
145 /* Deal with return values that are actually pass-by-reference.
146 Rule:
147 Return values are referenced by r3, so r4 is the first parameter. */
148
149 if (flags & FLAG_RETVAL_REFERENCE)
150 *next_arg++ = (unsigned long) (char *) ecif->rvalue;
151
152 /* Now for the arguments. */
153 for (i = nargs; i > 0; i--, ptr++, p_argv++)
154 {
155 switch ((*ptr)->type)
156 {
157 /* If a floating-point parameter appears before all of the general-
158 purpose registers are filled, the corresponding GPRs that match
159 the size of the floating-point parameter are skipped. */
160 case FFI_TYPE_FLOAT:
161 double_tmp = *(float *) *p_argv;
162 if (fparg_count < NUM_FPR_ARG_REGISTERS)
163 *fpr_base++ = double_tmp;
164 #if defined(POWERPC_DARWIN)
165 *(float *)next_arg = *(float *) *p_argv;
166 #else
167 *(double *)next_arg = double_tmp;
168 #endif
169 next_arg++;
170 gp_count++;
171 fparg_count++;
172 FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
173 break;
174
175 case FFI_TYPE_DOUBLE:
176 double_tmp = *(double *) *p_argv;
177 if (fparg_count < NUM_FPR_ARG_REGISTERS)
178 *fpr_base++ = double_tmp;
179 *(double *)next_arg = double_tmp;
180 #ifdef POWERPC64
181 next_arg++;
182 gp_count++;
183 #else
184 next_arg += 2;
185 gp_count += 2;
186 #endif
187 fparg_count++;
188 FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
189 break;
190
191 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
192
193 case FFI_TYPE_LONGDOUBLE:
194 # if defined(POWERPC64) && !defined(POWERPC_DARWIN64)
195 /* ??? This will exceed the regs count when the value starts at fp13
196 and it will not put the extra bit on the stack. */
197 if (fparg_count < NUM_FPR_ARG_REGISTERS)
198 *(long double *) fpr_base++ = *(long double *) *p_argv;
199 else
200 *(long double *) next_arg = *(long double *) *p_argv;
201 next_arg += 2;
202 fparg_count += 2;
203 # else
204 double_tmp = ((double *) *p_argv)[0];
205 if (fparg_count < NUM_FPR_ARG_REGISTERS)
206 *fpr_base++ = double_tmp;
207 *(double *) next_arg = double_tmp;
208 # if defined(POWERPC_DARWIN64)
209 next_arg++;
210 gp_count++;
211 # else
212 next_arg += 2;
213 gp_count += 2;
214 # endif
215 fparg_count++;
216 double_tmp = ((double *) *p_argv)[1];
217 if (fparg_count < NUM_FPR_ARG_REGISTERS)
218 *fpr_base++ = double_tmp;
219 *(double *) next_arg = double_tmp;
220 # if defined(POWERPC_DARWIN64)
221 next_arg++;
222 gp_count++;
223 # else
224 next_arg += 2;
225 gp_count += 2;
226 # endif
227 fparg_count++;
228 # endif
229 FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
230 break;
231 #endif
232 case FFI_TYPE_UINT64:
233 case FFI_TYPE_SINT64:
234 #ifdef POWERPC64
235 gprvalue = *(long long *) *p_argv;
236 goto putgpr;
237 #else
238 *(long long *) next_arg = *(long long *) *p_argv;
239 next_arg += 2;
240 gp_count += 2;
241 #endif
242 break;
243 case FFI_TYPE_POINTER:
244 gprvalue = *(unsigned long *) *p_argv;
245 goto putgpr;
246 case FFI_TYPE_UINT8:
247 gprvalue = *(unsigned char *) *p_argv;
248 goto putgpr;
249 case FFI_TYPE_SINT8:
250 gprvalue = *(signed char *) *p_argv;
251 goto putgpr;
252 case FFI_TYPE_UINT16:
253 gprvalue = *(unsigned short *) *p_argv;
254 goto putgpr;
255 case FFI_TYPE_SINT16:
256 gprvalue = *(signed short *) *p_argv;
257 goto putgpr;
258
259 case FFI_TYPE_STRUCT:
260 size_al = (*ptr)->size;
261 #if defined(POWERPC_DARWIN64)
262 next_arg = (unsigned long *)FFI_ALIGN((char *)next_arg, (*ptr)->alignment);
263 darwin64_pass_struct_by_value (*ptr, (char *) *p_argv,
264 (unsigned) size_al,
265 (unsigned int *) &fparg_count,
266 &fpr_base, &next_arg);
267 #else
268 dest_cpy = (char *) next_arg;
269
270 /* If the first member of the struct is a double, then include enough
271 padding in the struct size to align it to double-word. */
272 if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
273 size_al = FFI_ALIGN((*ptr)->size, 8);
274
275 # if defined(POWERPC64)
276 FFI_ASSERT (abi != FFI_DARWIN);
277 memcpy ((char *) dest_cpy, (char *) *p_argv, size_al);
278 next_arg += (size_al + 7) / 8;
279 # else
280 /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
281 SI 4 bytes) are aligned as if they were those modes.
282 Structures with 3 byte in size are padded upwards. */
283 if (size_al < 3 && abi == FFI_DARWIN)
284 dest_cpy += 4 - size_al;
285
286 memcpy((char *) dest_cpy, (char *) *p_argv, size_al);
287 next_arg += (size_al + 3) / 4;
288 # endif
289 #endif
290 break;
291
292 case FFI_TYPE_INT:
293 case FFI_TYPE_SINT32:
294 gprvalue = *(signed int *) *p_argv;
295 goto putgpr;
296
297 case FFI_TYPE_UINT32:
298 gprvalue = *(unsigned int *) *p_argv;
299 putgpr:
300 *next_arg++ = gprvalue;
301 gp_count++;
302 break;
303 default:
304 break;
305 }
306 }
307
308 /* Check that we didn't overrun the stack... */
309 /* FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
310 FFI_ASSERT((unsigned *)fpr_base
311 <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
312 FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4); */
313 }
314
315 #if defined(POWERPC_DARWIN64)
316
317 /* See if we can put some of the struct into fprs.
318 This should not be called for structures of size 16 bytes, since these are not
319 broken out this way. */
320 static void
321 darwin64_scan_struct_for_floats (ffi_type *s, unsigned *nfpr)
322 {
323 int i;
324
325 FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
326
327 for (i = 0; s->elements[i] != NULL; i++)
328 {
329 ffi_type *p = s->elements[i];
330 switch (p->type)
331 {
332 case FFI_TYPE_STRUCT:
333 darwin64_scan_struct_for_floats (p, nfpr);
334 break;
335 case FFI_TYPE_LONGDOUBLE:
336 (*nfpr) += 2;
337 break;
338 case FFI_TYPE_DOUBLE:
339 case FFI_TYPE_FLOAT:
340 (*nfpr) += 1;
341 break;
342 default:
343 break;
344 }
345 }
346 }
347
348 static int
349 darwin64_struct_size_exceeds_gprs_p (ffi_type *s, char *src, unsigned *nfpr)
350 {
351 unsigned struct_offset=0, i;
352
353 for (i = 0; s->elements[i] != NULL; i++)
354 {
355 char *item_base;
356 ffi_type *p = s->elements[i];
357 /* Find the start of this item (0 for the first one). */
358 if (i > 0)
359 struct_offset = FFI_ALIGN(struct_offset, p->alignment);
360
361 item_base = src + struct_offset;
362
363 switch (p->type)
364 {
365 case FFI_TYPE_STRUCT:
366 if (darwin64_struct_size_exceeds_gprs_p (p, item_base, nfpr))
367 return 1;
368 break;
369 case FFI_TYPE_LONGDOUBLE:
370 if (*nfpr >= NUM_FPR_ARG_REGISTERS)
371 return 1;
372 (*nfpr) += 1;
373 item_base += 8;
374 /* FALL THROUGH */
375 case FFI_TYPE_DOUBLE:
376 if (*nfpr >= NUM_FPR_ARG_REGISTERS)
377 return 1;
378 (*nfpr) += 1;
379 break;
380 case FFI_TYPE_FLOAT:
381 if (*nfpr >= NUM_FPR_ARG_REGISTERS)
382 return 1;
383 (*nfpr) += 1;
384 break;
385 default:
386 /* If we try and place any item, that is non-float, once we've
387 exceeded the 8 GPR mark, then we can't fit the struct. */
388 if ((unsigned long)item_base >= 8*8)
389 return 1;
390 break;
391 }
392 /* now count the size of what we just used. */
393 struct_offset += p->size;
394 }
395 return 0;
396 }
397
398 /* Can this struct be returned by value? */
399 int
400 darwin64_struct_ret_by_value_p (ffi_type *s)
401 {
402 unsigned nfp = 0;
403
404 FFI_ASSERT (s && s->type == FFI_TYPE_STRUCT);
405
406 /* The largest structure we can return is 8long + 13 doubles. */
407 if (s->size > 168)
408 return 0;
409
410 /* We can't pass more than 13 floats. */
411 darwin64_scan_struct_for_floats (s, &nfp);
412 if (nfp > 13)
413 return 0;
414
415 /* If there are not too many floats, and the struct is
416 small enough to accommodate in the GPRs, then it must be OK. */
417 if (s->size <= 64)
418 return 1;
419
420 /* Well, we have to look harder. */
421 nfp = 0;
422 if (darwin64_struct_size_exceeds_gprs_p (s, NULL, &nfp))
423 return 0;
424
425 return 1;
426 }
427
428 void
429 darwin64_pass_struct_floats (ffi_type *s, char *src,
430 unsigned *nfpr, double **fprs)
431 {
432 int i;
433 double *fpr_base = *fprs;
434 unsigned struct_offset = 0;
435
436 /* We don't assume anything about the alignment of the source. */
437 for (i = 0; s->elements[i] != NULL; i++)
438 {
439 char *item_base;
440 ffi_type *p = s->elements[i];
441 /* Find the start of this item (0 for the first one). */
442 if (i > 0)
443 struct_offset = FFI_ALIGN(struct_offset, p->alignment);
444 item_base = src + struct_offset;
445
446 switch (p->type)
447 {
448 case FFI_TYPE_STRUCT:
449 darwin64_pass_struct_floats (p, item_base, nfpr,
450 &fpr_base);
451 break;
452 case FFI_TYPE_LONGDOUBLE:
453 if (*nfpr < NUM_FPR_ARG_REGISTERS)
454 *fpr_base++ = *(double *)item_base;
455 (*nfpr) += 1;
456 item_base += 8;
457 /* FALL THROUGH */
458 case FFI_TYPE_DOUBLE:
459 if (*nfpr < NUM_FPR_ARG_REGISTERS)
460 *fpr_base++ = *(double *)item_base;
461 (*nfpr) += 1;
462 break;
463 case FFI_TYPE_FLOAT:
464 if (*nfpr < NUM_FPR_ARG_REGISTERS)
465 *fpr_base++ = (double) *(float *)item_base;
466 (*nfpr) += 1;
467 break;
468 default:
469 break;
470 }
471 /* now count the size of what we just used. */
472 struct_offset += p->size;
473 }
474 /* Update the scores. */
475 *fprs = fpr_base;
476 }
477
478 /* Darwin64 special rules.
479 Break out a struct into params and float registers. */
480 static void
481 darwin64_pass_struct_by_value (ffi_type *s, char *src, unsigned size,
482 unsigned *nfpr, double **fprs, unsigned long **arg)
483 {
484 unsigned long *next_arg = *arg;
485 char *dest_cpy = (char *)next_arg;
486
487 FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
488
489 if (!size)
490 return;
491
492 /* First... special cases. */
493 if (size < 3
494 || (size == 4
495 && s->elements[0]
496 && s->elements[0]->type != FFI_TYPE_FLOAT))
497 {
498 /* Must be at least one GPR, padding is unspecified in value,
499 let's make it zero. */
500 *next_arg = 0UL;
501 dest_cpy += 8 - size;
502 memcpy ((char *) dest_cpy, src, size);
503 next_arg++;
504 }
505 else if (size == 16)
506 {
507 memcpy ((char *) dest_cpy, src, size);
508 next_arg += 2;
509 }
510 else
511 {
512 /* now the general case, we consider embedded floats. */
513 memcpy ((char *) dest_cpy, src, size);
514 darwin64_pass_struct_floats (s, src, nfpr, fprs);
515 next_arg += (size+7)/8;
516 }
517
518 *arg = next_arg;
519 }
520
521 double *
522 darwin64_struct_floats_to_mem (ffi_type *s, char *dest, double *fprs, unsigned *nf)
523 {
524 int i;
525 unsigned struct_offset = 0;
526
527 /* We don't assume anything about the alignment of the source. */
528 for (i = 0; s->elements[i] != NULL; i++)
529 {
530 char *item_base;
531 ffi_type *p = s->elements[i];
532 /* Find the start of this item (0 for the first one). */
533 if (i > 0)
534 struct_offset = FFI_ALIGN(struct_offset, p->alignment);
535 item_base = dest + struct_offset;
536
537 switch (p->type)
538 {
539 case FFI_TYPE_STRUCT:
540 fprs = darwin64_struct_floats_to_mem (p, item_base, fprs, nf);
541 break;
542 case FFI_TYPE_LONGDOUBLE:
543 if (*nf < NUM_FPR_ARG_REGISTERS)
544 {
545 *(double *)item_base = *fprs++ ;
546 (*nf) += 1;
547 }
548 item_base += 8;
549 /* FALL THROUGH */
550 case FFI_TYPE_DOUBLE:
551 if (*nf < NUM_FPR_ARG_REGISTERS)
552 {
553 *(double *)item_base = *fprs++ ;
554 (*nf) += 1;
555 }
556 break;
557 case FFI_TYPE_FLOAT:
558 if (*nf < NUM_FPR_ARG_REGISTERS)
559 {
560 *(float *)item_base = (float) *fprs++ ;
561 (*nf) += 1;
562 }
563 break;
564 default:
565 break;
566 }
567 /* now count the size of what we just used. */
568 struct_offset += p->size;
569 }
570 return fprs;
571 }
572
573 #endif
574
575 /* Adjust the size of S to be correct for Darwin.
576 On Darwin m32, the first field of a structure has natural alignment.
577 On Darwin m64, all fields have natural alignment. */
578
579 static void
580 darwin_adjust_aggregate_sizes (ffi_type *s)
581 {
582 int i;
583
584 if (s->type != FFI_TYPE_STRUCT)
585 return;
586
587 s->size = 0;
588 for (i = 0; s->elements[i] != NULL; i++)
589 {
590 ffi_type *p;
591 int align;
592
593 p = s->elements[i];
594 if (p->type == FFI_TYPE_STRUCT)
595 darwin_adjust_aggregate_sizes (p);
596 #if defined(POWERPC_DARWIN64)
597 /* Natural alignment for all items. */
598 align = p->alignment;
599 #else
600 /* Natural alignment for the first item... */
601 if (i == 0)
602 align = p->alignment;
603 else if (p->alignment == 16 || p->alignment < 4)
604 /* .. subsequent items with vector or align < 4 have natural align. */
605 align = p->alignment;
606 else
607 /* .. or align is 4. */
608 align = 4;
609 #endif
610 /* Pad, if necessary, before adding the current item. */
611 s->size = FFI_ALIGN(s->size, align) + p->size;
612 }
613
614 s->size = FFI_ALIGN(s->size, s->alignment);
615
616 /* This should not be necessary on m64, but harmless. */
617 if (s->elements[0]->type == FFI_TYPE_UINT64
618 || s->elements[0]->type == FFI_TYPE_SINT64
619 || s->elements[0]->type == FFI_TYPE_DOUBLE
620 || s->elements[0]->alignment == 8)
621 s->alignment = s->alignment > 8 ? s->alignment : 8;
622 /* Do not add additional tail padding. */
623 }
624
625 /* Adjust the size of S to be correct for AIX.
626 Word-align double unless it is the first member of a structure. */
627
628 static void
629 aix_adjust_aggregate_sizes (ffi_type *s)
630 {
631 int i;
632
633 if (s->type != FFI_TYPE_STRUCT)
634 return;
635
636 s->size = 0;
637 for (i = 0; s->elements[i] != NULL; i++)
638 {
639 ffi_type *p;
640 int align;
641
642 p = s->elements[i];
643 aix_adjust_aggregate_sizes (p);
644 align = p->alignment;
645 if (i != 0 && p->type == FFI_TYPE_DOUBLE)
646 align = 4;
647 s->size = FFI_ALIGN(s->size, align) + p->size;
648 }
649
650 s->size = FFI_ALIGN(s->size, s->alignment);
651
652 if (s->elements[0]->type == FFI_TYPE_UINT64
653 || s->elements[0]->type == FFI_TYPE_SINT64
654 || s->elements[0]->type == FFI_TYPE_DOUBLE
655 || s->elements[0]->alignment == 8)
656 s->alignment = s->alignment > 8 ? s->alignment : 8;
657 /* Do not add additional tail padding. */
658 }
659
660 /* Perform machine dependent cif processing. */
661 ffi_status
662 ffi_prep_cif_machdep (ffi_cif *cif)
663 {
664 /* All this is for the DARWIN ABI. */
665 unsigned i;
666 ffi_type **ptr;
667 unsigned bytes;
668 unsigned fparg_count = 0, intarg_count = 0;
669 unsigned flags = 0;
670 unsigned size_al = 0;
671
672 /* All the machine-independent calculation of cif->bytes will be wrong.
673 All the calculation of structure sizes will also be wrong.
674 Redo the calculation for DARWIN. */
675
676 if (cif->abi == FFI_DARWIN)
677 {
678 darwin_adjust_aggregate_sizes (cif->rtype);
679 for (i = 0; i < cif->nargs; i++)
680 darwin_adjust_aggregate_sizes (cif->arg_types[i]);
681 }
682
683 if (cif->abi == FFI_AIX)
684 {
685 aix_adjust_aggregate_sizes (cif->rtype);
686 for (i = 0; i < cif->nargs; i++)
687 aix_adjust_aggregate_sizes (cif->arg_types[i]);
688 }
689
690 /* Space for the frame pointer, callee's LR, CR, etc, and for
691 the asm's temp regs. */
692
693 bytes = (LINKAGE_AREA_GPRS + ASM_NEEDS_REGISTERS) * sizeof(unsigned long);
694
695 /* Return value handling.
696 The rules m32 are as follows:
697 - 32-bit (or less) integer values are returned in gpr3;
698 - structures of size <= 4 bytes also returned in gpr3;
699 - 64-bit integer values [??? and structures between 5 and 8 bytes] are
700 returned in gpr3 and gpr4;
701 - Single/double FP values are returned in fpr1;
702 - Long double FP (if not equivalent to double) values are returned in
703 fpr1 and fpr2;
704 m64:
705 - 64-bit or smaller integral values are returned in GPR3
706 - Single/double FP values are returned in fpr1;
707 - Long double FP values are returned in fpr1 and fpr2;
708 m64 Structures:
709 - If the structure could be accommodated in registers were it to be the
710 first argument to a routine, then it is returned in those registers.
711 m32/m64 structures otherwise:
712 - Larger structures values are allocated space and a pointer is passed
713 as the first argument. */
714 switch (cif->rtype->type)
715 {
716
717 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
718 case FFI_TYPE_LONGDOUBLE:
719 flags |= FLAG_RETURNS_128BITS;
720 flags |= FLAG_RETURNS_FP;
721 break;
722 #endif
723
724 case FFI_TYPE_DOUBLE:
725 flags |= FLAG_RETURNS_64BITS;
726 /* Fall through. */
727 case FFI_TYPE_FLOAT:
728 flags |= FLAG_RETURNS_FP;
729 break;
730
731 case FFI_TYPE_UINT64:
732 case FFI_TYPE_SINT64:
733 #ifdef POWERPC64
734 case FFI_TYPE_POINTER:
735 #endif
736 flags |= FLAG_RETURNS_64BITS;
737 break;
738
739 case FFI_TYPE_STRUCT:
740 #if defined(POWERPC_DARWIN64)
741 {
742 /* Can we fit the struct into regs? */
743 if (darwin64_struct_ret_by_value_p (cif->rtype))
744 {
745 unsigned nfpr = 0;
746 flags |= FLAG_RETURNS_STRUCT;
747 if (cif->rtype->size != 16)
748 darwin64_scan_struct_for_floats (cif->rtype, &nfpr) ;
749 else
750 flags |= FLAG_RETURNS_128BITS;
751 /* Will be 0 for 16byte struct. */
752 if (nfpr)
753 flags |= FLAG_RETURNS_FP;
754 }
755 else /* By ref. */
756 {
757 flags |= FLAG_RETVAL_REFERENCE;
758 flags |= FLAG_RETURNS_NOTHING;
759 intarg_count++;
760 }
761 }
762 #elif defined(DARWIN_PPC)
763 if (cif->rtype->size <= 4)
764 flags |= FLAG_RETURNS_STRUCT;
765 else /* else by reference. */
766 {
767 flags |= FLAG_RETVAL_REFERENCE;
768 flags |= FLAG_RETURNS_NOTHING;
769 intarg_count++;
770 }
771 #else /* assume we pass by ref. */
772 flags |= FLAG_RETVAL_REFERENCE;
773 flags |= FLAG_RETURNS_NOTHING;
774 intarg_count++;
775 #endif
776 break;
777 case FFI_TYPE_VOID:
778 flags |= FLAG_RETURNS_NOTHING;
779 break;
780
781 default:
782 /* Returns 32-bit integer, or similar. Nothing to do here. */
783 break;
784 }
785
786 /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
787 first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
788 goes on the stack.
789 ??? Structures are passed as a pointer to a copy of the structure.
790 Stuff on the stack needs to keep proper alignment.
791 For m64 the count is effectively of half-GPRs. */
792 for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
793 {
794 unsigned align_words;
795 switch ((*ptr)->type)
796 {
797 case FFI_TYPE_FLOAT:
798 case FFI_TYPE_DOUBLE:
799 fparg_count++;
800 #if !defined(POWERPC_DARWIN64)
801 /* If this FP arg is going on the stack, it must be
802 8-byte-aligned. */
803 if (fparg_count > NUM_FPR_ARG_REGISTERS
804 && (intarg_count & 0x01) != 0)
805 intarg_count++;
806 #endif
807 break;
808
809 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
810 case FFI_TYPE_LONGDOUBLE:
811 fparg_count += 2;
812 /* If this FP arg is going on the stack, it must be
813 16-byte-aligned. */
814 if (fparg_count >= NUM_FPR_ARG_REGISTERS)
815 #if defined (POWERPC64)
816 intarg_count = FFI_ALIGN(intarg_count, 2);
817 #else
818 intarg_count = FFI_ALIGN(intarg_count, 4);
819 #endif
820 break;
821 #endif
822
823 case FFI_TYPE_UINT64:
824 case FFI_TYPE_SINT64:
825 #if defined(POWERPC64)
826 intarg_count++;
827 #else
828 /* 'long long' arguments are passed as two words, but
829 either both words must fit in registers or both go
830 on the stack. If they go on the stack, they must
831 be 8-byte-aligned. */
832 if (intarg_count == NUM_GPR_ARG_REGISTERS-1
833 || (intarg_count >= NUM_GPR_ARG_REGISTERS
834 && (intarg_count & 0x01) != 0))
835 intarg_count++;
836 intarg_count += 2;
837 #endif
838 break;
839
840 case FFI_TYPE_STRUCT:
841 size_al = (*ptr)->size;
842 #if defined(POWERPC_DARWIN64)
843 align_words = (*ptr)->alignment >> 3;
844 if (align_words)
845 intarg_count = FFI_ALIGN(intarg_count, align_words);
846 /* Base size of the struct. */
847 intarg_count += (size_al + 7) / 8;
848 /* If 16 bytes then don't worry about floats. */
849 if (size_al != 16)
850 /* Scan through for floats to be placed in regs. */
851 darwin64_scan_struct_for_floats (*ptr, &fparg_count) ;
852 #else
853 align_words = (*ptr)->alignment >> 2;
854 if (align_words)
855 intarg_count = FFI_ALIGN(intarg_count, align_words);
856 /* If the first member of the struct is a double, then align
857 the struct to double-word.
858 if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
859 size_al = FFI_ALIGN((*ptr)->size, 8); */
860 # ifdef POWERPC64
861 intarg_count += (size_al + 7) / 8;
862 # else
863 intarg_count += (size_al + 3) / 4;
864 # endif
865 #endif
866 break;
867
868 default:
869 /* Everything else is passed as a 4-byte word in a GPR, either
870 the object itself or a pointer to it. */
871 intarg_count++;
872 break;
873 }
874 }
875
876 if (fparg_count != 0)
877 flags |= FLAG_FP_ARGUMENTS;
878
879 #if defined(POWERPC_DARWIN64)
880 /* Space to image the FPR registers, if needed - which includes when they might be
881 used in a struct return. */
882 if (fparg_count != 0
883 || ((flags & FLAG_RETURNS_STRUCT)
884 && (flags & FLAG_RETURNS_FP)))
885 bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
886 #else
887 /* Space for the FPR registers, if needed. */
888 if (fparg_count != 0)
889 bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
890 #endif
891
892 /* Stack space. */
893 #ifdef POWERPC64
894 if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
895 bytes += (intarg_count + fparg_count) * sizeof(long);
896 #else
897 if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
898 bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
899 #endif
900 else
901 bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
902
903 /* The stack space allocated needs to be a multiple of 16 bytes. */
904 bytes = FFI_ALIGN(bytes, 16) ;
905
906 cif->flags = flags;
907 cif->bytes = bytes;
908
909 return FFI_OK;
910 }
911
912 extern void ffi_call_AIX(extended_cif *, long, unsigned, unsigned *,
913 void (*fn)(void), void (*fn2)(void));
914
915 #if defined (FFI_GO_CLOSURES)
916 extern void ffi_call_go_AIX(extended_cif *, long, unsigned, unsigned *,
917 void (*fn)(void), void (*fn2)(void), void *closure);
918 #endif
919
920 extern void ffi_call_DARWIN(extended_cif *, long, unsigned, unsigned *,
921 void (*fn)(void), void (*fn2)(void), ffi_type*);
922
923 void
924 ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
925 {
926 extended_cif ecif;
927
928 ecif.cif = cif;
929 ecif.avalue = avalue;
930
931 /* If the return value is a struct and we don't have a return
932 value address then we need to make one. */
933
934 if ((rvalue == NULL) &&
935 (cif->rtype->type == FFI_TYPE_STRUCT))
936 {
937 ecif.rvalue = alloca (cif->rtype->size);
938 }
939 else
940 ecif.rvalue = rvalue;
941
942 switch (cif->abi)
943 {
944 case FFI_AIX:
945 ffi_call_AIX(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
946 FFI_FN(ffi_prep_args));
947 break;
948 case FFI_DARWIN:
949 ffi_call_DARWIN(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
950 FFI_FN(ffi_prep_args), cif->rtype);
951 break;
952 default:
953 FFI_ASSERT(0);
954 break;
955 }
956 }
957
958 #if defined (FFI_GO_CLOSURES)
959 void
960 ffi_call_go (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue,
961 void *closure)
962 {
963 extended_cif ecif;
964
965 ecif.cif = cif;
966 ecif.avalue = avalue;
967
968 /* If the return value is a struct and we don't have a return
969 value address then we need to make one. */
970
971 if ((rvalue == NULL) &&
972 (cif->rtype->type == FFI_TYPE_STRUCT))
973 {
974 ecif.rvalue = alloca (cif->rtype->size);
975 }
976 else
977 ecif.rvalue = rvalue;
978
979 switch (cif->abi)
980 {
981 case FFI_AIX:
982 ffi_call_go_AIX(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
983 FFI_FN(ffi_prep_args), closure);
984 break;
985 default:
986 FFI_ASSERT(0);
987 break;
988 }
989 }
990 #endif
991
992 static void flush_icache(char *);
993 static void flush_range(char *, int);
994
995 /* The layout of a function descriptor. A C function pointer really
996 points to one of these. */
997
998 typedef struct aix_fd_struct {
999 void *code_pointer;
1000 void *toc;
1001 } aix_fd;
1002
1003 /* here I'd like to add the stack frame layout we use in darwin_closure.S
1004 and aix_closure.S
1005
1006 m32/m64
1007
1008 The stack layout looks like this:
1009
1010 | Additional params... | | Higher address
1011 ~ ~ ~
1012 | Parameters (at least 8*4/8=32/64) | | NUM_GPR_ARG_REGISTERS
1013 |--------------------------------------------| |
1014 | TOC=R2 (AIX) Reserved (Darwin) 4/8 | |
1015 |--------------------------------------------| |
1016 | Reserved 2*4/8 | |
1017 |--------------------------------------------| |
1018 | Space for callee's LR 4/8 | |
1019 |--------------------------------------------| |
1020 | Saved CR [low word for m64] 4/8 | |
1021 |--------------------------------------------| |
1022 | Current backchain pointer 4/8 |-/ Parent's frame.
1023 |--------------------------------------------| <+ <<< on entry to ffi_closure_ASM
1024 | Result Bytes 16 | |
1025 |--------------------------------------------| |
1026 ~ padding to 16-byte alignment ~ ~
1027 |--------------------------------------------| |
1028 | NUM_FPR_ARG_REGISTERS slots | |
1029 | here fp13 .. fp1 13*8 | |
1030 |--------------------------------------------| |
1031 | R3..R10 8*4/8=32/64 | | NUM_GPR_ARG_REGISTERS
1032 |--------------------------------------------| |
1033 | TOC=R2 (AIX) Reserved (Darwin) 4/8 | |
1034 |--------------------------------------------| | stack |
1035 | Reserved [compiler,binder] 2*4/8 | | grows |
1036 |--------------------------------------------| | down V
1037 | Space for callee's LR 4/8 | |
1038 |--------------------------------------------| | lower addresses
1039 | Saved CR [low word for m64] 4/8 | |
1040 |--------------------------------------------| | stack pointer here
1041 | Current backchain pointer 4/8 |-/ during
1042 |--------------------------------------------| <<< ffi_closure_ASM.
1043
1044 */
1045
1046 ffi_status
1047 ffi_prep_closure_loc (ffi_closure* closure,
1048 ffi_cif* cif,
1049 void (*fun)(ffi_cif*, void*, void**, void*),
1050 void *user_data,
1051 void *codeloc)
1052 {
1053 unsigned int *tramp;
1054 struct ffi_aix_trampoline_struct *tramp_aix;
1055 aix_fd *fd;
1056
1057 switch (cif->abi)
1058 {
1059 case FFI_DARWIN:
1060
1061 FFI_ASSERT (cif->abi == FFI_DARWIN);
1062
1063 tramp = (unsigned int *) &closure->tramp[0];
1064 #if defined(POWERPC_DARWIN64)
1065 tramp[0] = 0x7c0802a6; /* mflr r0 */
1066 tramp[1] = 0x429f0015; /* bcl- 20,4*cr7+so, +0x18 (L1) */
1067 /* We put the addresses here. */
1068 tramp[6] = 0x7d6802a6; /*L1: mflr r11 */
1069 tramp[7] = 0xe98b0000; /* ld r12,0(r11) function address */
1070 tramp[8] = 0x7c0803a6; /* mtlr r0 */
1071 tramp[9] = 0x7d8903a6; /* mtctr r12 */
1072 tramp[10] = 0xe96b0008; /* lwz r11,8(r11) static chain */
1073 tramp[11] = 0x4e800420; /* bctr */
1074
1075 *((unsigned long *)&tramp[2]) = (unsigned long) ffi_closure_ASM; /* function */
1076 *((unsigned long *)&tramp[4]) = (unsigned long) codeloc; /* context */
1077 #else
1078 tramp[0] = 0x7c0802a6; /* mflr r0 */
1079 tramp[1] = 0x429f000d; /* bcl- 20,4*cr7+so,0x10 */
1080 tramp[4] = 0x7d6802a6; /* mflr r11 */
1081 tramp[5] = 0x818b0000; /* lwz r12,0(r11) function address */
1082 tramp[6] = 0x7c0803a6; /* mtlr r0 */
1083 tramp[7] = 0x7d8903a6; /* mtctr r12 */
1084 tramp[8] = 0x816b0004; /* lwz r11,4(r11) static chain */
1085 tramp[9] = 0x4e800420; /* bctr */
1086 tramp[2] = (unsigned long) ffi_closure_ASM; /* function */
1087 tramp[3] = (unsigned long) codeloc; /* context */
1088 #endif
1089 closure->cif = cif;
1090 closure->fun = fun;
1091 closure->user_data = user_data;
1092
1093 /* Flush the icache. Only necessary on Darwin. */
1094 flush_range(codeloc, FFI_TRAMPOLINE_SIZE);
1095
1096 break;
1097
1098 case FFI_AIX:
1099
1100 tramp_aix = (struct ffi_aix_trampoline_struct *) (closure->tramp);
1101 fd = (aix_fd *)(void *)ffi_closure_ASM;
1102
1103 FFI_ASSERT (cif->abi == FFI_AIX);
1104
1105 tramp_aix->code_pointer = fd->code_pointer;
1106 tramp_aix->toc = fd->toc;
1107 tramp_aix->static_chain = codeloc;
1108 closure->cif = cif;
1109 closure->fun = fun;
1110 closure->user_data = user_data;
1111 break;
1112
1113 default:
1114 return FFI_BAD_ABI;
1115 break;
1116 }
1117 return FFI_OK;
1118 }
1119
1120 #if defined (FFI_GO_CLOSURES)
1121 ffi_status
1122 ffi_prep_go_closure (ffi_go_closure* closure,
1123 ffi_cif* cif,
1124 void (*fun)(ffi_cif*, void*, void**, void*))
1125 {
1126 switch (cif->abi)
1127 {
1128 case FFI_AIX:
1129
1130 FFI_ASSERT (cif->abi == FFI_AIX);
1131
1132 closure->tramp = (void *)ffi_go_closure_ASM;
1133 closure->cif = cif;
1134 closure->fun = fun;
1135 return FFI_OK;
1136
1137 // For now, ffi_prep_go_closure is only implemented for AIX, not for Darwin
1138 default:
1139 return FFI_BAD_ABI;
1140 break;
1141 }
1142 return FFI_OK;
1143 }
1144 #endif
1145
1146 static void
1147 flush_icache(char *addr)
1148 {
1149 #ifndef _AIX
1150 __asm__ volatile (
1151 "dcbf 0,%0\n"
1152 "\tsync\n"
1153 "\ticbi 0,%0\n"
1154 "\tsync\n"
1155 "\tisync"
1156 : : "r"(addr) : "memory");
1157 #endif
1158 }
1159
1160 static void
1161 flush_range(char * addr1, int size)
1162 {
1163 #define MIN_LINE_SIZE 32
1164 int i;
1165 for (i = 0; i < size; i += MIN_LINE_SIZE)
1166 flush_icache(addr1+i);
1167 flush_icache(addr1+size-1);
1168 }
1169
1170 typedef union
1171 {
1172 float f;
1173 double d;
1174 } ffi_dblfl;
1175
1176 ffi_type *
1177 ffi_closure_helper_DARWIN (ffi_closure *, void *,
1178 unsigned long *, ffi_dblfl *);
1179
1180 #if defined (FFI_GO_CLOSURES)
1181 ffi_type *
1182 ffi_go_closure_helper_DARWIN (ffi_go_closure*, void *,
1183 unsigned long *, ffi_dblfl *);
1184 #endif
1185
1186 /* Basically the trampoline invokes ffi_closure_ASM, and on
1187 entry, r11 holds the address of the closure.
1188 After storing the registers that could possibly contain
1189 parameters to be passed into the stack frame and setting
1190 up space for a return value, ffi_closure_ASM invokes the
1191 following helper function to do most of the work. */
1192
1193 static ffi_type *
1194 ffi_closure_helper_common (ffi_cif* cif,
1195 void (*fun)(ffi_cif*, void*, void**, void*),
1196 void *user_data, void *rvalue,
1197 unsigned long *pgr, ffi_dblfl *pfr)
1198 {
1199 /* rvalue is the pointer to space for return value in closure assembly
1200 pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
1201 pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM. */
1202
1203 typedef double ldbits[2];
1204
1205 union ldu
1206 {
1207 ldbits lb;
1208 long double ld;
1209 };
1210
1211 void ** avalue;
1212 ffi_type ** arg_types;
1213 long i, avn;
1214 ffi_dblfl * end_pfr = pfr + NUM_FPR_ARG_REGISTERS;
1215 unsigned size_al;
1216 #if defined(POWERPC_DARWIN64)
1217 unsigned fpsused = 0;
1218 #endif
1219
1220 avalue = alloca (cif->nargs * sizeof(void *));
1221
1222 if (cif->rtype->type == FFI_TYPE_STRUCT)
1223 {
1224 #if defined(POWERPC_DARWIN64)
1225 if (!darwin64_struct_ret_by_value_p (cif->rtype))
1226 {
1227 /* Won't fit into the regs - return by ref. */
1228 rvalue = (void *) *pgr;
1229 pgr++;
1230 }
1231 #elif defined(DARWIN_PPC)
1232 if (cif->rtype->size > 4)
1233 {
1234 rvalue = (void *) *pgr;
1235 pgr++;
1236 }
1237 #else /* assume we return by ref. */
1238 rvalue = (void *) *pgr;
1239 pgr++;
1240 #endif
1241 }
1242
1243 i = 0;
1244 avn = cif->nargs;
1245 arg_types = cif->arg_types;
1246
1247 /* Grab the addresses of the arguments from the stack frame. */
1248 while (i < avn)
1249 {
1250 switch (arg_types[i]->type)
1251 {
1252 case FFI_TYPE_SINT8:
1253 case FFI_TYPE_UINT8:
1254 #if defined(POWERPC64)
1255 avalue[i] = (char *) pgr + 7;
1256 #else
1257 avalue[i] = (char *) pgr + 3;
1258 #endif
1259 pgr++;
1260 break;
1261
1262 case FFI_TYPE_SINT16:
1263 case FFI_TYPE_UINT16:
1264 #if defined(POWERPC64)
1265 avalue[i] = (char *) pgr + 6;
1266 #else
1267 avalue[i] = (char *) pgr + 2;
1268 #endif
1269 pgr++;
1270 break;
1271
1272 case FFI_TYPE_SINT32:
1273 case FFI_TYPE_UINT32:
1274 #if defined(POWERPC64)
1275 avalue[i] = (char *) pgr + 4;
1276 #else
1277 case FFI_TYPE_POINTER:
1278 avalue[i] = pgr;
1279 #endif
1280 pgr++;
1281 break;
1282
1283 case FFI_TYPE_STRUCT:
1284 size_al = arg_types[i]->size;
1285 #if defined(POWERPC_DARWIN64)
1286 pgr = (unsigned long *)FFI_ALIGN((char *)pgr, arg_types[i]->alignment);
1287 if (size_al < 3 || size_al == 4)
1288 {
1289 avalue[i] = ((char *)pgr)+8-size_al;
1290 if (arg_types[i]->elements[0]->type == FFI_TYPE_FLOAT
1291 && fpsused < NUM_FPR_ARG_REGISTERS)
1292 {
1293 *(float *)pgr = (float) *(double *)pfr;
1294 pfr++;
1295 fpsused++;
1296 }
1297 }
1298 else
1299 {
1300 if (size_al != 16)
1301 pfr = (ffi_dblfl *)
1302 darwin64_struct_floats_to_mem (arg_types[i], (char *)pgr,
1303 (double *)pfr, &fpsused);
1304 avalue[i] = pgr;
1305 }
1306 pgr += (size_al + 7) / 8;
1307 #else
1308 /* If the first member of the struct is a double, then align
1309 the struct to double-word. */
1310 if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
1311 size_al = FFI_ALIGN(arg_types[i]->size, 8);
1312 # if defined(POWERPC64)
1313 FFI_ASSERT (cif->abi != FFI_DARWIN);
1314 avalue[i] = pgr;
1315 pgr += (size_al + 7) / 8;
1316 # else
1317 /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
1318 SI 4 bytes) are aligned as if they were those modes. */
1319 if (size_al < 3 && cif->abi == FFI_DARWIN)
1320 avalue[i] = (char*) pgr + 4 - size_al;
1321 else
1322 avalue[i] = pgr;
1323 pgr += (size_al + 3) / 4;
1324 # endif
1325 #endif
1326 break;
1327
1328 case FFI_TYPE_SINT64:
1329 case FFI_TYPE_UINT64:
1330 #if defined(POWERPC64)
1331 case FFI_TYPE_POINTER:
1332 avalue[i] = pgr;
1333 pgr++;
1334 break;
1335 #else
1336 /* Long long ints are passed in two gpr's. */
1337 avalue[i] = pgr;
1338 pgr += 2;
1339 break;
1340 #endif
1341
1342 case FFI_TYPE_FLOAT:
1343 /* A float value consumes a GPR.
1344 There are 13 64bit floating point registers. */
1345 if (pfr < end_pfr)
1346 {
1347 double temp = pfr->d;
1348 pfr->f = (float) temp;
1349 avalue[i] = pfr;
1350 pfr++;
1351 }
1352 else
1353 {
1354 avalue[i] = pgr;
1355 }
1356 pgr++;
1357 break;
1358
1359 case FFI_TYPE_DOUBLE:
1360 /* A double value consumes two GPRs.
1361 There are 13 64bit floating point registers. */
1362 if (pfr < end_pfr)
1363 {
1364 avalue[i] = pfr;
1365 pfr++;
1366 }
1367 else
1368 {
1369 avalue[i] = pgr;
1370 }
1371 #ifdef POWERPC64
1372 pgr++;
1373 #else
1374 pgr += 2;
1375 #endif
1376 break;
1377
1378 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
1379
1380 case FFI_TYPE_LONGDOUBLE:
1381 #ifdef POWERPC64
1382 if (pfr + 1 < end_pfr)
1383 {
1384 avalue[i] = pfr;
1385 pfr += 2;
1386 }
1387 else
1388 {
1389 if (pfr < end_pfr)
1390 {
1391 *pgr = *(unsigned long *) pfr;
1392 pfr++;
1393 }
1394 avalue[i] = pgr;
1395 }
1396 pgr += 2;
1397 #else /* POWERPC64 */
1398 /* A long double value consumes four GPRs and two FPRs.
1399 There are 13 64bit floating point registers. */
1400 if (pfr + 1 < end_pfr)
1401 {
1402 avalue[i] = pfr;
1403 pfr += 2;
1404 }
1405 /* Here we have the situation where one part of the long double
1406 is stored in fpr13 and the other part is already on the stack.
1407 We use a union to pass the long double to avalue[i]. */
1408 else if (pfr + 1 == end_pfr)
1409 {
1410 union ldu temp_ld;
1411 memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
1412 memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
1413 avalue[i] = &temp_ld.ld;
1414 pfr++;
1415 }
1416 else
1417 {
1418 avalue[i] = pgr;
1419 }
1420 pgr += 4;
1421 #endif /* POWERPC64 */
1422 break;
1423 #endif
1424 default:
1425 FFI_ASSERT(0);
1426 }
1427 i++;
1428 }
1429
1430 (fun) (cif, rvalue, avalue, user_data);
1431
1432 /* Tell ffi_closure_ASM to perform return type promotions. */
1433 return cif->rtype;
1434 }
1435
1436 ffi_type *
1437 ffi_closure_helper_DARWIN (ffi_closure *closure, void *rvalue,
1438 unsigned long *pgr, ffi_dblfl *pfr)
1439 {
1440 return ffi_closure_helper_common (closure->cif, closure->fun,
1441 closure->user_data, rvalue, pgr, pfr);
1442 }
1443
1444 #if defined (FFI_GO_CLOSURES)
1445 ffi_type *
1446 ffi_go_closure_helper_DARWIN (ffi_go_closure *closure, void *rvalue,
1447 unsigned long *pgr, ffi_dblfl *pfr)
1448 {
1449 return ffi_closure_helper_common (closure->cif, closure->fun,
1450 closure, rvalue, pgr, pfr);
1451 }
1452 #endif