1 /* -----------------------------------------------------------------------
4 Copyright (C) 1998 Geoffrey Keating
5 Copyright (C) 2001 John Hornkvist
6 Copyright (C) 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
8 FFI support for Darwin and AIX.
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:
18 The above copyright notice and this permission notice shall be included
19 in all copies or substantial portions of the Software.
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 ----------------------------------------------------------------------- */
31 #include <ffi_common.h>
35 extern void ffi_closure_ASM (void);
36 extern void ffi_go_closure_ASM (void);
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),
49 FLAG_RETURNS_STRUCT
= 1 << (31-27), /* This goes in cr6 */
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)
57 /* About the DARWIN ABI. */
59 NUM_GPR_ARG_REGISTERS
= 8,
60 NUM_FPR_ARG_REGISTERS
= 13,
64 enum { ASM_NEEDS_REGISTERS
= 4 }; /* r28-r31 */
66 /* ffi_prep_args is called by the assembly routine once stack space
67 has been allocated for the function's arguments.
71 The stack layout we want looks like this:
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. | |
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
98 #if defined(POWERPC_DARWIN64)
100 darwin64_pass_struct_by_value
101 (ffi_type
*, char *, unsigned, unsigned *, double **, unsigned long **);
104 /* This depends on GPR_SIZE = sizeof (unsigned long) */
107 ffi_prep_args (extended_cif
*ecif
, unsigned long *const stack
)
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
;
116 /* 'stacktop' points at the previous backchain pointer. */
117 unsigned long *const stacktop
= stack
+ (bytes
/ sizeof(unsigned long));
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;
124 /* 'next_arg' grows up as we put parameters in it. */
125 unsigned long *next_arg
= stack
+ LINKAGE_AREA_GPRS
; /* 6 reserved positions. */
129 void **p_argv
= ecif
->avalue
;
130 unsigned long gprvalue
;
131 ffi_type
** ptr
= ecif
->cif
->arg_types
;
132 #if !defined(POWERPC_DARWIN64)
135 unsigned size_al
= 0;
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);
142 /* Deal with return values that are actually pass-by-reference.
144 Return values are referenced by r3, so r4 is the first parameter. */
146 if (flags
& FLAG_RETVAL_REFERENCE
)
147 *next_arg
++ = (unsigned long) (char *) ecif
->rvalue
;
149 /* Now for the arguments. */
150 for (i
= nargs
; i
> 0; i
--, ptr
++, p_argv
++)
152 switch ((*ptr
)->type
)
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. */
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
;
164 *(double *)next_arg
= double_tmp
;
169 FFI_ASSERT(flags
& FLAG_FP_ARGUMENTS
);
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
;
185 FFI_ASSERT(flags
& FLAG_FP_ARGUMENTS
);
188 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
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
;
197 *(long double *) next_arg
= *(long double *) *p_argv
;
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)
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)
226 FFI_ASSERT(flags
& FLAG_FP_ARGUMENTS
);
229 case FFI_TYPE_UINT64
:
230 case FFI_TYPE_SINT64
:
232 gprvalue
= *(long long *) *p_argv
;
235 *(long long *) next_arg
= *(long long *) *p_argv
;
240 case FFI_TYPE_POINTER
:
241 gprvalue
= *(unsigned long *) *p_argv
;
244 gprvalue
= *(unsigned char *) *p_argv
;
247 gprvalue
= *(signed char *) *p_argv
;
249 case FFI_TYPE_UINT16
:
250 gprvalue
= *(unsigned short *) *p_argv
;
252 case FFI_TYPE_SINT16
:
253 gprvalue
= *(signed short *) *p_argv
;
256 case FFI_TYPE_STRUCT
:
257 size_al
= (*ptr
)->size
;
258 #if defined(POWERPC_DARWIN64)
259 next_arg
= (unsigned long *)ALIGN((char *)next_arg
, (*ptr
)->alignment
);
260 darwin64_pass_struct_by_value (*ptr
, (char *) *p_argv
,
262 (unsigned int *) &fparg_count
,
263 &fpr_base
, &next_arg
);
265 dest_cpy
= (char *) next_arg
;
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
= ALIGN((*ptr
)->size
, 8);
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;
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
;
283 memcpy((char *) dest_cpy
, (char *) *p_argv
, size_al
);
284 next_arg
+= (size_al
+ 3) / 4;
290 case FFI_TYPE_SINT32
:
291 gprvalue
= *(signed int *) *p_argv
;
294 case FFI_TYPE_UINT32
:
295 gprvalue
= *(unsigned int *) *p_argv
;
297 *next_arg
++ = gprvalue
;
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); */
312 #if defined(POWERPC_DARWIN64)
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. */
318 darwin64_scan_struct_for_floats (ffi_type
*s
, unsigned *nfpr
)
322 FFI_ASSERT (s
->type
== FFI_TYPE_STRUCT
)
324 for (i
= 0; s
->elements
[i
] != NULL
; i
++)
326 ffi_type
*p
= s
->elements
[i
];
329 case FFI_TYPE_STRUCT
:
330 darwin64_scan_struct_for_floats (p
, nfpr
);
332 case FFI_TYPE_LONGDOUBLE
:
335 case FFI_TYPE_DOUBLE
:
346 darwin64_struct_size_exceeds_gprs_p (ffi_type
*s
, char *src
, unsigned *nfpr
)
348 unsigned struct_offset
=0, i
;
350 for (i
= 0; s
->elements
[i
] != NULL
; i
++)
353 ffi_type
*p
= s
->elements
[i
];
354 /* Find the start of this item (0 for the first one). */
356 struct_offset
= ALIGN(struct_offset
, p
->alignment
);
358 item_base
= src
+ struct_offset
;
362 case FFI_TYPE_STRUCT
:
363 if (darwin64_struct_size_exceeds_gprs_p (p
, item_base
, nfpr
))
366 case FFI_TYPE_LONGDOUBLE
:
367 if (*nfpr
>= NUM_FPR_ARG_REGISTERS
)
372 case FFI_TYPE_DOUBLE
:
373 if (*nfpr
>= NUM_FPR_ARG_REGISTERS
)
378 if (*nfpr
>= NUM_FPR_ARG_REGISTERS
)
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)
389 /* now count the size of what we just used. */
390 struct_offset
+= p
->size
;
395 /* Can this struct be returned by value? */
397 darwin64_struct_ret_by_value_p (ffi_type
*s
)
401 FFI_ASSERT (s
&& s
->type
== FFI_TYPE_STRUCT
);
403 /* The largest structure we can return is 8long + 13 doubles. */
407 /* We can't pass more than 13 floats. */
408 darwin64_scan_struct_for_floats (s
, &nfp
);
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. */
417 /* Well, we have to look harder. */
419 if (darwin64_struct_size_exceeds_gprs_p (s
, NULL
, &nfp
))
426 darwin64_pass_struct_floats (ffi_type
*s
, char *src
,
427 unsigned *nfpr
, double **fprs
)
430 double *fpr_base
= *fprs
;
431 unsigned struct_offset
= 0;
433 /* We don't assume anything about the alignment of the source. */
434 for (i
= 0; s
->elements
[i
] != NULL
; i
++)
437 ffi_type
*p
= s
->elements
[i
];
438 /* Find the start of this item (0 for the first one). */
440 struct_offset
= ALIGN(struct_offset
, p
->alignment
);
441 item_base
= src
+ struct_offset
;
445 case FFI_TYPE_STRUCT
:
446 darwin64_pass_struct_floats (p
, item_base
, nfpr
,
449 case FFI_TYPE_LONGDOUBLE
:
450 if (*nfpr
< NUM_FPR_ARG_REGISTERS
)
451 *fpr_base
++ = *(double *)item_base
;
455 case FFI_TYPE_DOUBLE
:
456 if (*nfpr
< NUM_FPR_ARG_REGISTERS
)
457 *fpr_base
++ = *(double *)item_base
;
461 if (*nfpr
< NUM_FPR_ARG_REGISTERS
)
462 *fpr_base
++ = (double) *(float *)item_base
;
468 /* now count the size of what we just used. */
469 struct_offset
+= p
->size
;
471 /* Update the scores. */
475 /* Darwin64 special rules.
476 Break out a struct into params and float registers. */
478 darwin64_pass_struct_by_value (ffi_type
*s
, char *src
, unsigned size
,
479 unsigned *nfpr
, double **fprs
, unsigned long **arg
)
481 unsigned long *next_arg
= *arg
;
482 char *dest_cpy
= (char *)next_arg
;
484 FFI_ASSERT (s
->type
== FFI_TYPE_STRUCT
)
489 /* First... special cases. */
493 && s
->elements
[0]->type
!= FFI_TYPE_FLOAT
))
495 /* Must be at least one GPR, padding is unspecified in value,
496 let's make it zero. */
498 dest_cpy
+= 8 - size
;
499 memcpy ((char *) dest_cpy
, src
, size
);
504 memcpy ((char *) dest_cpy
, src
, size
);
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;
519 darwin64_struct_floats_to_mem (ffi_type
*s
, char *dest
, double *fprs
, unsigned *nf
)
522 unsigned struct_offset
= 0;
524 /* We don't assume anything about the alignment of the source. */
525 for (i
= 0; s
->elements
[i
] != NULL
; i
++)
528 ffi_type
*p
= s
->elements
[i
];
529 /* Find the start of this item (0 for the first one). */
531 struct_offset
= ALIGN(struct_offset
, p
->alignment
);
532 item_base
= dest
+ struct_offset
;
536 case FFI_TYPE_STRUCT
:
537 fprs
= darwin64_struct_floats_to_mem (p
, item_base
, fprs
, nf
);
539 case FFI_TYPE_LONGDOUBLE
:
540 if (*nf
< NUM_FPR_ARG_REGISTERS
)
542 *(double *)item_base
= *fprs
++ ;
547 case FFI_TYPE_DOUBLE
:
548 if (*nf
< NUM_FPR_ARG_REGISTERS
)
550 *(double *)item_base
= *fprs
++ ;
555 if (*nf
< NUM_FPR_ARG_REGISTERS
)
557 *(float *)item_base
= (float) *fprs
++ ;
564 /* now count the size of what we just used. */
565 struct_offset
+= p
->size
;
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. */
577 darwin_adjust_aggregate_sizes (ffi_type
*s
)
581 if (s
->type
!= FFI_TYPE_STRUCT
)
585 for (i
= 0; s
->elements
[i
] != NULL
; 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
;
597 /* Natural alignment for the first item... */
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
;
604 /* .. or align is 4. */
607 /* Pad, if necessary, before adding the current item. */
608 s
->size
= ALIGN(s
->size
, align
) + p
->size
;
611 s
->size
= ALIGN(s
->size
, s
->alignment
);
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. */
622 /* Adjust the size of S to be correct for AIX.
623 Word-align double unless it is the first member of a structure. */
626 aix_adjust_aggregate_sizes (ffi_type
*s
)
630 if (s
->type
!= FFI_TYPE_STRUCT
)
634 for (i
= 0; s
->elements
[i
] != NULL
; i
++)
640 aix_adjust_aggregate_sizes (p
);
641 align
= p
->alignment
;
642 if (i
!= 0 && p
->type
== FFI_TYPE_DOUBLE
)
644 s
->size
= ALIGN(s
->size
, align
) + p
->size
;
647 s
->size
= ALIGN(s
->size
, s
->alignment
);
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. */
657 /* Perform machine dependent cif processing. */
659 ffi_prep_cif_machdep (ffi_cif
*cif
)
661 /* All this is for the DARWIN ABI. */
665 unsigned fparg_count
= 0, intarg_count
= 0;
667 unsigned size_al
= 0;
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. */
673 if (cif
->abi
== FFI_DARWIN
)
675 darwin_adjust_aggregate_sizes (cif
->rtype
);
676 for (i
= 0; i
< cif
->nargs
; i
++)
677 darwin_adjust_aggregate_sizes (cif
->arg_types
[i
]);
680 if (cif
->abi
== FFI_AIX
)
682 aix_adjust_aggregate_sizes (cif
->rtype
);
683 for (i
= 0; i
< cif
->nargs
; i
++)
684 aix_adjust_aggregate_sizes (cif
->arg_types
[i
]);
687 /* Space for the frame pointer, callee's LR, CR, etc, and for
688 the asm's temp regs. */
690 bytes
= (LINKAGE_AREA_GPRS
+ ASM_NEEDS_REGISTERS
) * sizeof(unsigned long);
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
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;
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
)
714 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
715 case FFI_TYPE_LONGDOUBLE
:
716 flags
|= FLAG_RETURNS_128BITS
;
717 flags
|= FLAG_RETURNS_FP
;
721 case FFI_TYPE_DOUBLE
:
722 flags
|= FLAG_RETURNS_64BITS
;
725 flags
|= FLAG_RETURNS_FP
;
728 case FFI_TYPE_UINT64
:
729 case FFI_TYPE_SINT64
:
731 case FFI_TYPE_POINTER
:
733 flags
|= FLAG_RETURNS_64BITS
;
736 case FFI_TYPE_STRUCT
:
737 #if defined(POWERPC_DARWIN64)
739 /* Can we fit the struct into regs? */
740 if (darwin64_struct_ret_by_value_p (cif
->rtype
))
743 flags
|= FLAG_RETURNS_STRUCT
;
744 if (cif
->rtype
->size
!= 16)
745 darwin64_scan_struct_for_floats (cif
->rtype
, &nfpr
) ;
747 flags
|= FLAG_RETURNS_128BITS
;
748 /* Will be 0 for 16byte struct. */
750 flags
|= FLAG_RETURNS_FP
;
754 flags
|= FLAG_RETVAL_REFERENCE
;
755 flags
|= FLAG_RETURNS_NOTHING
;
759 #elif defined(DARWIN_PPC)
760 if (cif
->rtype
->size
<= 4)
761 flags
|= FLAG_RETURNS_STRUCT
;
762 else /* else by reference. */
764 flags
|= FLAG_RETVAL_REFERENCE
;
765 flags
|= FLAG_RETURNS_NOTHING
;
768 #else /* assume we pass by ref. */
769 flags
|= FLAG_RETVAL_REFERENCE
;
770 flags
|= FLAG_RETURNS_NOTHING
;
775 flags
|= FLAG_RETURNS_NOTHING
;
779 /* Returns 32-bit integer, or similar. Nothing to do here. */
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
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
++)
791 unsigned align_words
;
792 switch ((*ptr
)->type
)
795 case FFI_TYPE_DOUBLE
:
797 #if !defined(POWERPC_DARWIN64)
798 /* If this FP arg is going on the stack, it must be
800 if (fparg_count
> NUM_FPR_ARG_REGISTERS
801 && (intarg_count
& 0x01) != 0)
806 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
807 case FFI_TYPE_LONGDOUBLE
:
809 /* If this FP arg is going on the stack, it must be
811 if (fparg_count
>= NUM_FPR_ARG_REGISTERS
)
812 #if defined (POWERPC64)
813 intarg_count
= ALIGN(intarg_count
, 2);
815 intarg_count
= ALIGN(intarg_count
, 4);
820 case FFI_TYPE_UINT64
:
821 case FFI_TYPE_SINT64
:
822 #if defined(POWERPC64)
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))
837 case FFI_TYPE_STRUCT
:
838 size_al
= (*ptr
)->size
;
839 #if defined(POWERPC_DARWIN64)
840 align_words
= (*ptr
)->alignment
>> 3;
842 intarg_count
= 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. */
847 /* Scan through for floats to be placed in regs. */
848 darwin64_scan_struct_for_floats (*ptr
, &fparg_count
) ;
850 align_words
= (*ptr
)->alignment
>> 2;
852 intarg_count
= 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 = ALIGN((*ptr)->size, 8); */
858 intarg_count
+= (size_al
+ 7) / 8;
860 intarg_count
+= (size_al
+ 3) / 4;
866 /* Everything else is passed as a 4-byte word in a GPR, either
867 the object itself or a pointer to it. */
873 if (fparg_count
!= 0)
874 flags
|= FLAG_FP_ARGUMENTS
;
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. */
880 || ((flags
& FLAG_RETURNS_STRUCT
)
881 && (flags
& FLAG_RETURNS_FP
)))
882 bytes
+= NUM_FPR_ARG_REGISTERS
* sizeof(double);
884 /* Space for the FPR registers, if needed. */
885 if (fparg_count
!= 0)
886 bytes
+= NUM_FPR_ARG_REGISTERS
* sizeof(double);
891 if ((intarg_count
+ fparg_count
) > NUM_GPR_ARG_REGISTERS
)
892 bytes
+= (intarg_count
+ fparg_count
) * sizeof(long);
894 if ((intarg_count
+ 2 * fparg_count
) > NUM_GPR_ARG_REGISTERS
)
895 bytes
+= (intarg_count
+ 2 * fparg_count
) * sizeof(long);
898 bytes
+= NUM_GPR_ARG_REGISTERS
* sizeof(long);
900 /* The stack space allocated needs to be a multiple of 16 bytes. */
901 bytes
= ALIGN(bytes
, 16) ;
909 extern void ffi_call_AIX(extended_cif
*, long, unsigned, unsigned *,
910 void (*fn
)(void), void (*fn2
)(void));
912 extern void ffi_call_go_AIX(extended_cif
*, long, unsigned, unsigned *,
913 void (*fn
)(void), void (*fn2
)(void), void *closure
);
915 extern void ffi_call_DARWIN(extended_cif
*, long, unsigned, unsigned *,
916 void (*fn
)(void), void (*fn2
)(void), ffi_type
*);
919 ffi_call (ffi_cif
*cif
, void (*fn
)(void), void *rvalue
, void **avalue
)
924 ecif
.avalue
= avalue
;
926 /* If the return value is a struct and we don't have a return
927 value address then we need to make one. */
929 if ((rvalue
== NULL
) &&
930 (cif
->rtype
->type
== FFI_TYPE_STRUCT
))
932 ecif
.rvalue
= alloca (cif
->rtype
->size
);
935 ecif
.rvalue
= rvalue
;
940 ffi_call_AIX(&ecif
, -(long)cif
->bytes
, cif
->flags
, ecif
.rvalue
, fn
,
941 FFI_FN(ffi_prep_args
));
944 ffi_call_DARWIN(&ecif
, -(long)cif
->bytes
, cif
->flags
, ecif
.rvalue
, fn
,
945 FFI_FN(ffi_prep_args
), cif
->rtype
);
954 ffi_call_go (ffi_cif
*cif
, void (*fn
) (void), void *rvalue
, void **avalue
,
960 ecif
.avalue
= avalue
;
962 /* If the return value is a struct and we don't have a return
963 value address then we need to make one. */
965 if ((rvalue
== NULL
) &&
966 (cif
->rtype
->type
== FFI_TYPE_STRUCT
))
968 ecif
.rvalue
= alloca (cif
->rtype
->size
);
971 ecif
.rvalue
= rvalue
;
976 ffi_call_go_AIX(&ecif
, -(long)cif
->bytes
, cif
->flags
, ecif
.rvalue
, fn
,
977 FFI_FN(ffi_prep_args
), closure
);
985 static void flush_icache(char *);
986 static void flush_range(char *, int);
988 /* The layout of a function descriptor. A C function pointer really
989 points to one of these. */
991 typedef struct aix_fd_struct
{
996 /* here I'd like to add the stack frame layout we use in darwin_closure.S
1001 The stack layout looks like this:
1003 | Additional params... | | Higher address
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.
1040 ffi_prep_closure_loc (ffi_closure
* closure
,
1042 void (*fun
)(ffi_cif
*, void*, void**, void*),
1046 unsigned int *tramp
;
1047 struct ffi_aix_trampoline_struct
*tramp_aix
;
1054 FFI_ASSERT (cif
->abi
== FFI_DARWIN
);
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 */
1068 *((unsigned long *)&tramp
[2]) = (unsigned long) ffi_closure_ASM
; /* function */
1069 *((unsigned long *)&tramp
[4]) = (unsigned long) codeloc
; /* context */
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 */
1084 closure
->user_data
= user_data
;
1086 /* Flush the icache. Only necessary on Darwin. */
1087 flush_range(codeloc
, FFI_TRAMPOLINE_SIZE
);
1093 tramp_aix
= (struct ffi_aix_trampoline_struct
*) (closure
->tramp
);
1094 fd
= (aix_fd
*)(void *)ffi_closure_ASM
;
1096 FFI_ASSERT (cif
->abi
== FFI_AIX
);
1098 tramp_aix
->code_pointer
= fd
->code_pointer
;
1099 tramp_aix
->toc
= fd
->toc
;
1100 tramp_aix
->static_chain
= codeloc
;
1103 closure
->user_data
= user_data
;
1114 ffi_prep_go_closure (ffi_go_closure
* closure
,
1116 void (*fun
)(ffi_cif
*, void*, void**, void*))
1122 FFI_ASSERT (cif
->abi
== FFI_AIX
);
1124 closure
->tramp
= (void *)ffi_go_closure_ASM
;
1129 // For now, ffi_prep_go_closure is only implemented for AIX, not for Darwin
1138 flush_icache(char *addr
)
1147 : : "r"(addr
) : "memory");
1152 flush_range(char * addr1
, int size
)
1154 #define MIN_LINE_SIZE 32
1156 for (i
= 0; i
< size
; i
+= MIN_LINE_SIZE
)
1157 flush_icache(addr1
+i
);
1158 flush_icache(addr1
+size
-1);
1168 ffi_closure_helper_DARWIN (ffi_closure
*, void *,
1169 unsigned long *, ffi_dblfl
*);
1172 ffi_go_closure_helper_DARWIN (ffi_go_closure
*, void *,
1173 unsigned long *, ffi_dblfl
*);
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. */
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
)
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. */
1192 typedef double ldbits
[2];
1201 ffi_type
** arg_types
;
1203 ffi_dblfl
* end_pfr
= pfr
+ NUM_FPR_ARG_REGISTERS
;
1205 #if defined(POWERPC_DARWIN64)
1206 unsigned fpsused
= 0;
1209 avalue
= alloca (cif
->nargs
* sizeof(void *));
1211 if (cif
->rtype
->type
== FFI_TYPE_STRUCT
)
1213 #if defined(POWERPC_DARWIN64)
1214 if (!darwin64_struct_ret_by_value_p (cif
->rtype
))
1216 /* Won't fit into the regs - return by ref. */
1217 rvalue
= (void *) *pgr
;
1220 #elif defined(DARWIN_PPC)
1221 if (cif
->rtype
->size
> 4)
1223 rvalue
= (void *) *pgr
;
1226 #else /* assume we return by ref. */
1227 rvalue
= (void *) *pgr
;
1234 arg_types
= cif
->arg_types
;
1236 /* Grab the addresses of the arguments from the stack frame. */
1239 switch (arg_types
[i
]->type
)
1241 case FFI_TYPE_SINT8
:
1242 case FFI_TYPE_UINT8
:
1243 #if defined(POWERPC64)
1244 avalue
[i
] = (char *) pgr
+ 7;
1246 avalue
[i
] = (char *) pgr
+ 3;
1251 case FFI_TYPE_SINT16
:
1252 case FFI_TYPE_UINT16
:
1253 #if defined(POWERPC64)
1254 avalue
[i
] = (char *) pgr
+ 6;
1256 avalue
[i
] = (char *) pgr
+ 2;
1261 case FFI_TYPE_SINT32
:
1262 case FFI_TYPE_UINT32
:
1263 #if defined(POWERPC64)
1264 avalue
[i
] = (char *) pgr
+ 4;
1266 case FFI_TYPE_POINTER
:
1272 case FFI_TYPE_STRUCT
:
1273 size_al
= arg_types
[i
]->size
;
1274 #if defined(POWERPC_DARWIN64)
1275 pgr
= (unsigned long *)ALIGN((char *)pgr
, arg_types
[i
]->alignment
);
1276 if (size_al
< 3 || size_al
== 4)
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
)
1282 *(float *)pgr
= (float) *(double *)pfr
;
1291 darwin64_struct_floats_to_mem (arg_types
[i
], (char *)pgr
,
1292 (double *)pfr
, &fpsused
);
1295 pgr
+= (size_al
+ 7) / 8;
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
= ALIGN(arg_types
[i
]->size
, 8);
1301 # if defined(POWERPC64)
1302 FFI_ASSERT (cif
->abi
!= FFI_DARWIN
);
1304 pgr
+= (size_al
+ 7) / 8;
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
;
1312 pgr
+= (size_al
+ 3) / 4;
1317 case FFI_TYPE_SINT64
:
1318 case FFI_TYPE_UINT64
:
1319 #if defined(POWERPC64)
1320 case FFI_TYPE_POINTER
:
1325 /* Long long ints are passed in two gpr's. */
1331 case FFI_TYPE_FLOAT
:
1332 /* A float value consumes a GPR.
1333 There are 13 64bit floating point registers. */
1336 double temp
= pfr
->d
;
1337 pfr
->f
= (float) temp
;
1348 case FFI_TYPE_DOUBLE
:
1349 /* A double value consumes two GPRs.
1350 There are 13 64bit floating point registers. */
1367 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
1369 case FFI_TYPE_LONGDOUBLE
:
1371 if (pfr
+ 1 < end_pfr
)
1380 *pgr
= *(unsigned long *) pfr
;
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
)
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
)
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
;
1410 #endif /* POWERPC64 */
1419 (fun
) (cif
, rvalue
, avalue
, user_data
);
1421 /* Tell ffi_closure_ASM to perform return type promotions. */
1426 ffi_closure_helper_DARWIN (ffi_closure
*closure
, void *rvalue
,
1427 unsigned long *pgr
, ffi_dblfl
*pfr
)
1429 return ffi_closure_helper_common (closure
->cif
, closure
->fun
,
1430 closure
->user_data
, rvalue
, pgr
, pfr
);
1434 ffi_go_closure_helper_DARWIN (ffi_go_closure
*closure
, void *rvalue
,
1435 unsigned long *pgr
, ffi_dblfl
*pfr
)
1437 return ffi_closure_helper_common (closure
->cif
, closure
->fun
,
1438 closure
, rvalue
, pgr
, pfr
);