1 /* -----------------------------------------------------------------------
2 ffi.c - Copyright (c) 1996, 2003, 2004, 2007 Red Hat, Inc.
4 SPARC Foreign Function Interface
6 Permission is hereby granted, free of charge, to any person obtaining
7 a copy of this software and associated documentation files (the
8 ``Software''), to deal in the Software without restriction, including
9 without limitation the rights to use, copy, modify, merge, publish,
10 distribute, sublicense, and/or sell copies of the Software, and to
11 permit persons to whom the Software is furnished to do so, subject to
12 the following conditions:
14 The above copyright notice and this permission notice shall be included
15 in all copies or substantial portions of the Software.
17 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
18 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 DEALINGS IN THE SOFTWARE.
25 ----------------------------------------------------------------------- */
28 #include <ffi_common.h>
33 /* ffi_prep_args is called by the assembly routine once stack space
34 has been allocated for the function's arguments */
36 void ffi_prep_args_v8(char *stack
, extended_cif
*ecif
)
43 /* Skip 16 words for the window save area */
44 argp
= stack
+ 16*sizeof(int);
46 /* This should only really be done when we are returning a structure,
47 however, it's faster just to do it all the time...
49 if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT ) */
50 *(int *) argp
= (long)ecif
->rvalue
;
52 /* And 1 word for the structure return value. */
56 /* Purify will probably complain in our assembly routine, unless we
57 zero out this memory. */
67 p_argv
= ecif
->avalue
;
69 for (i
= ecif
->cif
->nargs
, p_arg
= ecif
->cif
->arg_types
; i
; i
--, p_arg
++)
73 if ((*p_arg
)->type
== FFI_TYPE_STRUCT
74 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
75 || (*p_arg
)->type
== FFI_TYPE_LONGDOUBLE
79 *(unsigned int *) argp
= (unsigned long)(* p_argv
);
88 switch ((*p_arg
)->type
)
91 *(signed int *) argp
= *(SINT8
*)(* p_argv
);
95 *(unsigned int *) argp
= *(UINT8
*)(* p_argv
);
99 *(signed int *) argp
= *(SINT16
*)(* p_argv
);
102 case FFI_TYPE_UINT16
:
103 *(unsigned int *) argp
= *(UINT16
*)(* p_argv
);
112 memcpy(argp
, *p_argv
, z
);
122 int ffi_prep_args_v9(char *stack
, extended_cif
*ecif
)
132 /* Skip 16 words for the window save area */
133 argp
= stack
+ 16*sizeof(long long);
136 /* Purify will probably complain in our assembly routine, unless we
137 zero out this memory. */
139 ((long long*)argp
)[0] = 0;
140 ((long long*)argp
)[1] = 0;
141 ((long long*)argp
)[2] = 0;
142 ((long long*)argp
)[3] = 0;
143 ((long long*)argp
)[4] = 0;
144 ((long long*)argp
)[5] = 0;
147 p_argv
= ecif
->avalue
;
149 if (ecif
->cif
->rtype
->type
== FFI_TYPE_STRUCT
&&
150 ecif
->cif
->rtype
->size
> 32)
152 *(unsigned long long *) argp
= (unsigned long)ecif
->rvalue
;
153 argp
+= sizeof(long long);
157 for (i
= 0, p_arg
= ecif
->cif
->arg_types
; i
< ecif
->cif
->nargs
;
163 switch ((*p_arg
)->type
)
165 case FFI_TYPE_STRUCT
:
168 /* For structures larger than 16 bytes we pass reference. */
169 *(unsigned long long *) argp
= (unsigned long)* p_argv
;
170 argp
+= sizeof(long long);
177 case FFI_TYPE_DOUBLE
:
178 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
179 case FFI_TYPE_LONGDOUBLE
:
181 ret
= 1; /* We should promote into FP regs as well as integer. */
184 if (z
< sizeof(long long))
186 switch ((*p_arg
)->type
)
189 *(signed long long *) argp
= *(SINT8
*)(* p_argv
);
193 *(unsigned long long *) argp
= *(UINT8
*)(* p_argv
);
196 case FFI_TYPE_SINT16
:
197 *(signed long long *) argp
= *(SINT16
*)(* p_argv
);
200 case FFI_TYPE_UINT16
:
201 *(unsigned long long *) argp
= *(UINT16
*)(* p_argv
);
204 case FFI_TYPE_SINT32
:
205 *(signed long long *) argp
= *(SINT32
*)(* p_argv
);
208 case FFI_TYPE_UINT32
:
209 *(unsigned long long *) argp
= *(UINT32
*)(* p_argv
);
213 *(float *) (argp
+ 4) = *(FLOAT32
*)(* p_argv
); /* Right justify */
216 case FFI_TYPE_STRUCT
:
217 memcpy(argp
, *p_argv
, z
);
223 z
= sizeof(long long);
226 else if (z
== sizeof(long long))
228 memcpy(argp
, *p_argv
, z
);
229 z
= sizeof(long long);
234 if ((tmp
& 1) && (*p_arg
)->alignment
> 8)
237 argp
+= sizeof(long long);
239 memcpy(argp
, *p_argv
, z
);
240 z
= 2 * sizeof(long long);
250 /* Perform machine dependent cif processing */
251 ffi_status
ffi_prep_cif_machdep(ffi_cif
*cif
)
255 if (cif
->abi
!= FFI_V9
)
259 /* If we are returning a struct, this will already have been added.
260 Otherwise we need to add it because it's always got to be there! */
262 if (cif
->rtype
->type
!= FFI_TYPE_STRUCT
)
263 cif
->bytes
+= wordsize
;
265 /* sparc call frames require that space is allocated for 6 args,
266 even if they aren't used. Make that space if necessary. */
268 if (cif
->bytes
< 4*6+4)
275 /* sparc call frames require that space is allocated for 6 args,
276 even if they aren't used. Make that space if necessary. */
278 if (cif
->bytes
< 8*6)
282 /* Adjust cif->bytes. to include 16 words for the window save area,
283 and maybe the struct/union return pointer area, */
285 cif
->bytes
+= 16 * wordsize
;
287 /* The stack must be 2 word aligned, so round bytes up
290 cif
->bytes
= ALIGN(cif
->bytes
, 2 * wordsize
);
292 /* Set the return type flag */
293 switch (cif
->rtype
->type
)
297 case FFI_TYPE_DOUBLE
:
298 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
299 case FFI_TYPE_LONGDOUBLE
:
301 cif
->flags
= cif
->rtype
->type
;
304 case FFI_TYPE_STRUCT
:
305 if (cif
->abi
== FFI_V9
&& cif
->rtype
->size
> 32)
306 cif
->flags
= FFI_TYPE_VOID
;
308 cif
->flags
= FFI_TYPE_STRUCT
;
313 case FFI_TYPE_SINT16
:
314 case FFI_TYPE_UINT16
:
315 if (cif
->abi
== FFI_V9
)
316 cif
->flags
= FFI_TYPE_INT
;
318 cif
->flags
= cif
->rtype
->type
;
321 case FFI_TYPE_SINT64
:
322 case FFI_TYPE_UINT64
:
323 if (cif
->abi
== FFI_V9
)
324 cif
->flags
= FFI_TYPE_INT
;
326 cif
->flags
= FFI_TYPE_SINT64
;
330 cif
->flags
= FFI_TYPE_INT
;
336 int ffi_v9_layout_struct(ffi_type
*arg
, int off
, char *ret
, char *intg
, char *flt
)
338 ffi_type
**ptr
= &arg
->elements
[0];
342 if (off
& ((*ptr
)->alignment
- 1))
343 off
= ALIGN(off
, (*ptr
)->alignment
);
345 switch ((*ptr
)->type
)
347 case FFI_TYPE_STRUCT
:
348 off
= ffi_v9_layout_struct(*ptr
, off
, ret
, intg
, flt
);
349 off
= ALIGN(off
, FFI_SIZEOF_ARG
);
352 case FFI_TYPE_DOUBLE
:
353 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
354 case FFI_TYPE_LONGDOUBLE
:
356 memmove(ret
+ off
, flt
+ off
, (*ptr
)->size
);
360 memmove(ret
+ off
, intg
+ off
, (*ptr
)->size
);
371 extern int ffi_call_v9(void *, extended_cif
*, unsigned,
372 unsigned, unsigned *, void (*fn
)());
374 extern int ffi_call_v8(void *, extended_cif
*, unsigned,
375 unsigned, unsigned *, void (*fn
)());
378 void ffi_call(ffi_cif
*cif
, void (*fn
)(), void *rvalue
, void **avalue
)
384 ecif
.avalue
= avalue
;
386 /* If the return value is a struct and we don't have a return */
387 /* value address then we need to make one */
389 ecif
.rvalue
= rvalue
;
390 if (cif
->rtype
->type
== FFI_TYPE_STRUCT
)
392 if (cif
->rtype
->size
<= 32)
398 ecif
.rvalue
= alloca(cif
->rtype
->size
);
406 /* We don't yet support calling 32bit code from 64bit */
409 ffi_call_v8(ffi_prep_args_v8
, &ecif
, cif
->bytes
,
410 cif
->flags
, rvalue
, fn
);
415 ffi_call_v9(ffi_prep_args_v9
, &ecif
, cif
->bytes
,
416 cif
->flags
, rval
, fn
);
417 if (rvalue
&& rval
&& cif
->rtype
->type
== FFI_TYPE_STRUCT
)
418 ffi_v9_layout_struct(cif
->rtype
, 0, (char *)rvalue
, (char *)rval
, ((char *)rval
)+32);
433 extern void ffi_closure_v9(void);
435 extern void ffi_closure_v8(void);
439 ffi_prep_closure_loc (ffi_closure
* closure
,
441 void (*fun
)(ffi_cif
*, void*, void**, void*),
445 unsigned int *tramp
= (unsigned int *) &closure
->tramp
[0];
448 /* Trampoline address is equal to the closure address. We take advantage
449 of that to reduce the trampoline size by 8 bytes. */
450 FFI_ASSERT (cif
->abi
== FFI_V9
);
451 fn
= (unsigned long) ffi_closure_v9
;
452 tramp
[0] = 0x83414000; /* rd %pc, %g1 */
453 tramp
[1] = 0xca586010; /* ldx [%g1+16], %g5 */
454 tramp
[2] = 0x81c14000; /* jmp %g5 */
455 tramp
[3] = 0x01000000; /* nop */
456 *((unsigned long *) &tramp
[4]) = fn
;
458 unsigned long ctx
= (unsigned long) codeloc
;
459 FFI_ASSERT (cif
->abi
== FFI_V8
);
460 fn
= (unsigned long) ffi_closure_v8
;
461 tramp
[0] = 0x03000000 | fn
>> 10; /* sethi %hi(fn), %g1 */
462 tramp
[1] = 0x05000000 | ctx
>> 10; /* sethi %hi(ctx), %g2 */
463 tramp
[2] = 0x81c06000 | (fn
& 0x3ff); /* jmp %g1+%lo(fn) */
464 tramp
[3] = 0x8410a000 | (ctx
& 0x3ff);/* or %g2, %lo(ctx) */
469 closure
->user_data
= user_data
;
471 /* Flush the Icache. FIXME: alignment isn't certain, assume 8 bytes */
473 asm volatile ("flush %0" : : "r" (closure
) : "memory");
474 asm volatile ("flush %0" : : "r" (((char *) closure
) + 8) : "memory");
476 asm volatile ("iflush %0" : : "r" (closure
) : "memory");
477 asm volatile ("iflush %0" : : "r" (((char *) closure
) + 8) : "memory");
484 ffi_closure_sparc_inner_v8(ffi_closure
*closure
,
485 void *rvalue
, unsigned long *gpr
, unsigned long *scratch
)
488 ffi_type
**arg_types
;
493 arg_types
= cif
->arg_types
;
494 avalue
= alloca(cif
->nargs
* sizeof(void *));
496 /* Copy the caller's structure return address so that the closure
497 returns the data directly to the caller. */
498 if (cif
->flags
== FFI_TYPE_STRUCT
499 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
500 || cif
->flags
== FFI_TYPE_LONGDOUBLE
503 rvalue
= (void *) gpr
[0];
505 /* Always skip the structure return address. */
508 /* Grab the addresses of the arguments from the stack frame. */
509 for (i
= 0; i
< cif
->nargs
; i
++)
511 if (arg_types
[i
]->type
== FFI_TYPE_STRUCT
512 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
513 || arg_types
[i
]->type
== FFI_TYPE_LONGDOUBLE
517 /* Straight copy of invisible reference. */
518 avalue
[i
] = (void *)gpr
[argn
++];
520 else if ((arg_types
[i
]->type
== FFI_TYPE_DOUBLE
521 || arg_types
[i
]->type
== FFI_TYPE_SINT64
522 || arg_types
[i
]->type
== FFI_TYPE_UINT64
)
523 /* gpr is 8-byte aligned. */
526 /* Align on a 8-byte boundary. */
527 scratch
[0] = gpr
[argn
];
528 scratch
[1] = gpr
[argn
+1];
535 /* Always right-justify. */
536 argn
+= ALIGN(arg_types
[i
]->size
, FFI_SIZEOF_ARG
) / FFI_SIZEOF_ARG
;
537 avalue
[i
] = ((char *) &gpr
[argn
]) - arg_types
[i
]->size
;
541 /* Invoke the closure. */
542 (closure
->fun
) (cif
, rvalue
, avalue
, closure
->user_data
);
544 /* Tell ffi_closure_sparc how to perform return type promotions. */
545 return cif
->rtype
->type
;
549 ffi_closure_sparc_inner_v9(ffi_closure
*closure
,
550 void *rvalue
, unsigned long *gpr
, double *fpr
)
553 ffi_type
**arg_types
;
555 int i
, argn
, fp_slot_max
;
558 arg_types
= cif
->arg_types
;
559 avalue
= alloca(cif
->nargs
* sizeof(void *));
561 /* Copy the caller's structure return address so that the closure
562 returns the data directly to the caller. */
563 if (cif
->flags
== FFI_TYPE_VOID
564 && cif
->rtype
->type
== FFI_TYPE_STRUCT
)
566 rvalue
= (void *) gpr
[0];
567 /* Skip the structure return address. */
573 fp_slot_max
= 16 - argn
;
575 /* Grab the addresses of the arguments from the stack frame. */
576 for (i
= 0; i
< cif
->nargs
; i
++)
578 if (arg_types
[i
]->type
== FFI_TYPE_STRUCT
)
580 if (arg_types
[i
]->size
> 16)
582 /* Straight copy of invisible reference. */
583 avalue
[i
] = (void *)gpr
[argn
++];
588 ffi_v9_layout_struct(arg_types
[i
],
592 (char *) &fpr
[argn
]);
593 avalue
[i
] = &gpr
[argn
];
594 argn
+= ALIGN(arg_types
[i
]->size
, FFI_SIZEOF_ARG
) / FFI_SIZEOF_ARG
;
600 argn
+= ALIGN(arg_types
[i
]->size
, FFI_SIZEOF_ARG
) / FFI_SIZEOF_ARG
;
603 && (arg_types
[i
]->type
== FFI_TYPE_FLOAT
604 || arg_types
[i
]->type
== FFI_TYPE_DOUBLE
605 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
606 || arg_types
[i
]->type
== FFI_TYPE_LONGDOUBLE
609 avalue
[i
] = ((char *) &fpr
[argn
]) - arg_types
[i
]->size
;
611 avalue
[i
] = ((char *) &gpr
[argn
]) - arg_types
[i
]->size
;
615 /* Invoke the closure. */
616 (closure
->fun
) (cif
, rvalue
, avalue
, closure
->user_data
);
618 /* Tell ffi_closure_sparc how to perform return type promotions. */
619 return cif
->rtype
->type
;