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