]> git.ipfire.org Git - thirdparty/gcc.git/blame_incremental - libffi/src/sparc/ffi.c
[vxworks] [ppc] match TARGET_VXWORKS64 to TARGET_64BIT
[thirdparty/gcc.git] / libffi / src / sparc / ffi.c
... / ...
CommitLineData
1/* -----------------------------------------------------------------------
2 ffi.c - Copyright (c) 2011, 2013 Anthony Green
3 Copyright (c) 1996, 2003-2004, 2007-2008 Red Hat, Inc.
4
5 SPARC Foreign Function Interface
6
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 ``Software''), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
14
15 The above copyright notice and this permission notice shall be included
16 in all copies or substantial portions of the Software.
17
18 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25 DEALINGS IN THE SOFTWARE.
26 ----------------------------------------------------------------------- */
27
28#include <ffi.h>
29#include <ffi_common.h>
30#include <stdlib.h>
31#include "internal.h"
32
33#ifndef SPARC64
34
35/* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
36 all further uses in this file will refer to the 128-bit type. */
37#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
38# if FFI_TYPE_LONGDOUBLE != 4
39# error FFI_TYPE_LONGDOUBLE out of date
40# endif
41#else
42# undef FFI_TYPE_LONGDOUBLE
43# define FFI_TYPE_LONGDOUBLE 4
44#endif
45
46/* Perform machine dependent cif processing */
47ffi_status FFI_HIDDEN
48ffi_prep_cif_machdep(ffi_cif *cif)
49{
50 ffi_type *rtype = cif->rtype;
51 int rtt = rtype->type;
52 size_t bytes;
53 int i, n, flags;
54
55 /* Set the return type flag */
56 switch (rtt)
57 {
58 case FFI_TYPE_VOID:
59 flags = SPARC_RET_VOID;
60 break;
61 case FFI_TYPE_FLOAT:
62 flags = SPARC_RET_F_1;
63 break;
64 case FFI_TYPE_DOUBLE:
65 flags = SPARC_RET_F_2;
66 break;
67 case FFI_TYPE_LONGDOUBLE:
68 case FFI_TYPE_STRUCT:
69 flags = (rtype->size & 0xfff) << SPARC_SIZEMASK_SHIFT;
70 flags |= SPARC_RET_STRUCT;
71 break;
72 case FFI_TYPE_SINT8:
73 flags = SPARC_RET_SINT8;
74 break;
75 case FFI_TYPE_UINT8:
76 flags = SPARC_RET_UINT8;
77 break;
78 case FFI_TYPE_SINT16:
79 flags = SPARC_RET_SINT16;
80 break;
81 case FFI_TYPE_UINT16:
82 flags = SPARC_RET_UINT16;
83 break;
84 case FFI_TYPE_INT:
85 case FFI_TYPE_SINT32:
86 case FFI_TYPE_UINT32:
87 case FFI_TYPE_POINTER:
88 flags = SPARC_RET_UINT32;
89 break;
90 case FFI_TYPE_SINT64:
91 case FFI_TYPE_UINT64:
92 flags = SPARC_RET_INT64;
93 break;
94 case FFI_TYPE_COMPLEX:
95 rtt = rtype->elements[0]->type;
96 switch (rtt)
97 {
98 case FFI_TYPE_FLOAT:
99 flags = SPARC_RET_F_2;
100 break;
101 case FFI_TYPE_DOUBLE:
102 flags = SPARC_RET_F_4;
103 break;
104 case FFI_TYPE_LONGDOUBLE:
105 flags = SPARC_RET_F_8;
106 break;
107 case FFI_TYPE_SINT64:
108 case FFI_TYPE_UINT64:
109 flags = SPARC_RET_INT128;
110 break;
111 case FFI_TYPE_INT:
112 case FFI_TYPE_SINT32:
113 case FFI_TYPE_UINT32:
114 flags = SPARC_RET_INT64;
115 break;
116 case FFI_TYPE_SINT16:
117 case FFI_TYPE_UINT16:
118 flags = SP_V8_RET_CPLX16;
119 break;
120 case FFI_TYPE_SINT8:
121 case FFI_TYPE_UINT8:
122 flags = SP_V8_RET_CPLX8;
123 break;
124 default:
125 abort();
126 }
127 break;
128 default:
129 abort();
130 }
131 cif->flags = flags;
132
133 bytes = 0;
134 for (i = 0, n = cif->nargs; i < n; ++i)
135 {
136 ffi_type *ty = cif->arg_types[i];
137 size_t z = ty->size;
138 int tt = ty->type;
139
140 switch (tt)
141 {
142 case FFI_TYPE_STRUCT:
143 case FFI_TYPE_LONGDOUBLE:
144 by_reference:
145 /* Passed by reference. */
146 z = 4;
147 break;
148
149 case FFI_TYPE_COMPLEX:
150 tt = ty->elements[0]->type;
151 if (tt == FFI_TYPE_FLOAT || z > 8)
152 goto by_reference;
153 /* FALLTHRU */
154
155 default:
156 z = FFI_ALIGN(z, 4);
157 }
158 bytes += z;
159 }
160
161 /* Sparc call frames require that space is allocated for 6 args,
162 even if they aren't used. Make that space if necessary. */
163 if (bytes < 6 * 4)
164 bytes = 6 * 4;
165
166 /* The ABI always requires space for the struct return pointer. */
167 bytes += 4;
168
169 /* The stack must be 2 word aligned, so round bytes up appropriately. */
170 bytes = FFI_ALIGN(bytes, 2 * 4);
171
172 /* Include the call frame to prep_args. */
173 bytes += 4*16 + 4*8;
174 cif->bytes = bytes;
175
176 return FFI_OK;
177}
178
179extern void ffi_call_v8(ffi_cif *cif, void (*fn)(void), void *rvalue,
180 void **avalue, size_t bytes, void *closure) FFI_HIDDEN;
181
182int FFI_HIDDEN
183ffi_prep_args_v8(ffi_cif *cif, unsigned long *argp, void *rvalue, void **avalue)
184{
185 ffi_type **p_arg;
186 int flags = cif->flags;
187 int i, nargs;
188
189 if (rvalue == NULL)
190 {
191 if ((flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
192 {
193 /* Since we pass the pointer to the callee, we need a value.
194 We allowed for this space in ffi_call, before ffi_call_v8
195 alloca'd the space. */
196 rvalue = (char *)argp + cif->bytes;
197 }
198 else
199 {
200 /* Otherwise, we can ignore the return value. */
201 flags = SPARC_RET_VOID;
202 }
203 }
204
205 /* This could only really be done when we are returning a structure.
206 However, the space is reserved so we can do it unconditionally. */
207 *argp++ = (unsigned long)rvalue;
208
209#ifdef USING_PURIFY
210 /* Purify will probably complain in our assembly routine,
211 unless we zero out this memory. */
212 memset(argp, 0, 6*4);
213#endif
214
215 p_arg = cif->arg_types;
216 for (i = 0, nargs = cif->nargs; i < nargs; i++)
217 {
218 ffi_type *ty = p_arg[i];
219 void *a = avalue[i];
220 int tt = ty->type;
221 size_t z;
222
223 switch (tt)
224 {
225 case FFI_TYPE_STRUCT:
226 case FFI_TYPE_LONGDOUBLE:
227 by_reference:
228 *argp++ = (unsigned long)a;
229 break;
230
231 case FFI_TYPE_DOUBLE:
232 case FFI_TYPE_UINT64:
233 case FFI_TYPE_SINT64:
234 memcpy(argp, a, 8);
235 argp += 2;
236 break;
237
238 case FFI_TYPE_INT:
239 case FFI_TYPE_FLOAT:
240 case FFI_TYPE_UINT32:
241 case FFI_TYPE_SINT32:
242 case FFI_TYPE_POINTER:
243 *argp++ = *(unsigned *)a;
244 break;
245
246 case FFI_TYPE_UINT8:
247 *argp++ = *(UINT8 *)a;
248 break;
249 case FFI_TYPE_SINT8:
250 *argp++ = *(SINT8 *)a;
251 break;
252 case FFI_TYPE_UINT16:
253 *argp++ = *(UINT16 *)a;
254 break;
255 case FFI_TYPE_SINT16:
256 *argp++ = *(SINT16 *)a;
257 break;
258
259 case FFI_TYPE_COMPLEX:
260 tt = ty->elements[0]->type;
261 z = ty->size;
262 if (tt == FFI_TYPE_FLOAT || z > 8)
263 goto by_reference;
264 if (z < 4)
265 {
266 memcpy((char *)argp + 4 - z, a, z);
267 argp++;
268 }
269 else
270 {
271 memcpy(argp, a, z);
272 argp += z / 4;
273 }
274 break;
275
276 default:
277 abort();
278 }
279 }
280
281 return flags;
282}
283
284static void
285ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
286 void **avalue, void *closure)
287{
288 size_t bytes = cif->bytes;
289 size_t i, nargs = cif->nargs;
290 ffi_type **arg_types = cif->arg_types;
291
292 FFI_ASSERT (cif->abi == FFI_V8);
293
294 /* If we've not got a return value, we need to create one if we've
295 got to pass the return value to the callee. Otherwise ignore it. */
296 if (rvalue == NULL
297 && (cif->flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
298 bytes += FFI_ALIGN (cif->rtype->size, 8);
299
300 /* If we have any structure arguments, make a copy so we are passing
301 by value. */
302 for (i = 0; i < nargs; i++)
303 {
304 ffi_type *at = arg_types[i];
305 int size = at->size;
306 if (at->type == FFI_TYPE_STRUCT)
307 {
308 char *argcopy = alloca (size);
309 memcpy (argcopy, avalue[i], size);
310 avalue[i] = argcopy;
311 }
312 }
313
314 ffi_call_v8(cif, fn, rvalue, avalue, -bytes, closure);
315}
316
317void
318ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
319{
320 ffi_call_int (cif, fn, rvalue, avalue, NULL);
321}
322
323void
324ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue,
325 void **avalue, void *closure)
326{
327 ffi_call_int (cif, fn, rvalue, avalue, closure);
328}
329
330#ifdef __GNUC__
331static inline void
332ffi_flush_icache (void *p)
333{
334 /* SPARC v8 requires 5 instructions for flush to be visible */
335 asm volatile ("iflush %0; iflush %0+8; nop; nop; nop; nop; nop"
336 : : "r" (p) : "memory");
337}
338#else
339extern void ffi_flush_icache (void *) FFI_HIDDEN;
340#endif
341
342extern void ffi_closure_v8(void) FFI_HIDDEN;
343extern void ffi_go_closure_v8(void) FFI_HIDDEN;
344
345ffi_status
346ffi_prep_closure_loc (ffi_closure *closure,
347 ffi_cif *cif,
348 void (*fun)(ffi_cif*, void*, void**, void*),
349 void *user_data,
350 void *codeloc)
351{
352 unsigned int *tramp = (unsigned int *) &closure->tramp[0];
353 unsigned long ctx = (unsigned long) closure;
354 unsigned long fn = (unsigned long) ffi_closure_v8;
355
356 if (cif->abi != FFI_V8)
357 return FFI_BAD_ABI;
358
359 tramp[0] = 0x03000000 | fn >> 10; /* sethi %hi(fn), %g1 */
360 tramp[1] = 0x05000000 | ctx >> 10; /* sethi %hi(ctx), %g2 */
361 tramp[2] = 0x81c06000 | (fn & 0x3ff); /* jmp %g1+%lo(fn) */
362 tramp[3] = 0x8410a000 | (ctx & 0x3ff);/* or %g2, %lo(ctx) */
363
364 closure->cif = cif;
365 closure->fun = fun;
366 closure->user_data = user_data;
367
368 ffi_flush_icache (closure);
369
370 return FFI_OK;
371}
372
373ffi_status
374ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif *cif,
375 void (*fun)(ffi_cif*, void*, void**, void*))
376{
377 if (cif->abi != FFI_V8)
378 return FFI_BAD_ABI;
379
380 closure->tramp = ffi_go_closure_v8;
381 closure->cif = cif;
382 closure->fun = fun;
383
384 return FFI_OK;
385}
386
387int FFI_HIDDEN
388ffi_closure_sparc_inner_v8(ffi_cif *cif,
389 void (*fun)(ffi_cif*, void*, void**, void*),
390 void *user_data, void *rvalue,
391 unsigned long *argp)
392{
393 ffi_type **arg_types;
394 void **avalue;
395 int i, nargs, flags;
396
397 arg_types = cif->arg_types;
398 nargs = cif->nargs;
399 flags = cif->flags;
400 avalue = alloca(nargs * sizeof(void *));
401
402 /* Copy the caller's structure return address so that the closure
403 returns the data directly to the caller. Also install it so we
404 can return the address in %o0. */
405 if ((flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
406 {
407 void *new_rvalue = (void *)*argp;
408 *(void **)rvalue = new_rvalue;
409 rvalue = new_rvalue;
410 }
411
412 /* Always skip the structure return address. */
413 argp++;
414
415 /* Grab the addresses of the arguments from the stack frame. */
416 for (i = 0; i < nargs; i++)
417 {
418 ffi_type *ty = arg_types[i];
419 int tt = ty->type;
420 void *a = argp;
421 size_t z;
422
423 switch (tt)
424 {
425 case FFI_TYPE_STRUCT:
426 case FFI_TYPE_LONGDOUBLE:
427 by_reference:
428 /* Straight copy of invisible reference. */
429 a = (void *)*argp;
430 break;
431
432 case FFI_TYPE_DOUBLE:
433 case FFI_TYPE_SINT64:
434 case FFI_TYPE_UINT64:
435 if ((unsigned long)a & 7)
436 {
437 /* Align on a 8-byte boundary. */
438 UINT64 *tmp = alloca(8);
439 *tmp = ((UINT64)argp[0] << 32) | argp[1];
440 a = tmp;
441 }
442 argp++;
443 break;
444
445 case FFI_TYPE_INT:
446 case FFI_TYPE_FLOAT:
447 case FFI_TYPE_UINT32:
448 case FFI_TYPE_SINT32:
449 case FFI_TYPE_POINTER:
450 break;
451 case FFI_TYPE_UINT16:
452 case FFI_TYPE_SINT16:
453 a += 2;
454 break;
455 case FFI_TYPE_UINT8:
456 case FFI_TYPE_SINT8:
457 a += 3;
458 break;
459
460 case FFI_TYPE_COMPLEX:
461 tt = ty->elements[0]->type;
462 z = ty->size;
463 if (tt == FFI_TYPE_FLOAT || z > 8)
464 goto by_reference;
465 if (z < 4)
466 a += 4 - z;
467 else if (z > 4)
468 argp++;
469 break;
470
471 default:
472 abort();
473 }
474 argp++;
475 avalue[i] = a;
476 }
477
478 /* Invoke the closure. */
479 fun (cif, rvalue, avalue, user_data);
480
481 /* Tell ffi_closure_sparc how to perform return type promotions. */
482 return flags;
483}
484#endif /* !SPARC64 */