Debian Codegraph @

src/sparc/ffi64.c

raw
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 /* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
34 all further uses in this file will refer to the 128-bit type. */
35 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
36 # if FFI_TYPE_LONGDOUBLE != 4
37 # error FFI_TYPE_LONGDOUBLE out of date
38 # endif
39 #else
40 # undef FFI_TYPE_LONGDOUBLE
41 # define FFI_TYPE_LONGDOUBLE 4
42 #endif
43
44 #ifdef SPARC64
45
46 /* Flatten the contents of a structure to the parts that are passed in
47 floating point registers. The return is a bit mask wherein bit N
48 set means bytes [4*n, 4*n+3] are passed in %fN.
49
50 We encode both the (running) size (maximum 32) and mask (maxumum 255)
51 into one integer. The size is placed in the low byte, so that align
52 and addition work correctly. The mask is placed in the second byte. */
53
54 static int
55 ffi_struct_float_mask (ffi_type *outer_type, int size_mask)
56 {
57 ffi_type **elts;
58 ffi_type *t;
59
60 if (outer_type->type == FFI_TYPE_COMPLEX)
61 {
62 int m = 0, tt = outer_type->elements[0]->type;
63 size_t z = outer_type->size;
64
65 if (tt == FFI_TYPE_FLOAT
66 || tt == FFI_TYPE_DOUBLE
67 || tt == FFI_TYPE_LONGDOUBLE)
68 m = (1 << (z / 4)) - 1;
69 return (m << 8) | z;
70 }
71 FFI_ASSERT (outer_type->type == FFI_TYPE_STRUCT);
72
73 for (elts = outer_type->elements; (t = *elts) != NULL; elts++)
74 {
75 size_t z = t->size;
76 int o, m, tt;
77
78 size_mask = FFI_ALIGN(size_mask, t->alignment);
79 switch (t->type)
80 {
81 case FFI_TYPE_STRUCT:
82 size_mask = ffi_struct_float_mask (t, size_mask);
83 continue;
84 case FFI_TYPE_COMPLEX:
85 tt = t->elements[0]->type;
86 if (tt != FFI_TYPE_FLOAT
87 && tt != FFI_TYPE_DOUBLE
88 && tt != FFI_TYPE_LONGDOUBLE)
89 break;
90 /* FALLTHRU */
91 case FFI_TYPE_FLOAT:
92 case FFI_TYPE_DOUBLE:
93 case FFI_TYPE_LONGDOUBLE:
94 m = (1 << (z / 4)) - 1; /* compute mask for type */
95 o = (size_mask >> 2) & 0x3f; /* extract word offset */
96 size_mask |= m << (o + 8); /* insert mask into place */
97 break;
98 }
99 size_mask += z;
100 }
101
102 size_mask = FFI_ALIGN(size_mask, outer_type->alignment);
103 FFI_ASSERT ((size_mask & 0xff) == outer_type->size);
104
105 return size_mask;
106 }
107
108 /* Merge floating point data into integer data. If the structure is
109 entirely floating point, simply return a pointer to the fp data. */
110
111 static void *
112 ffi_struct_float_merge (int size_mask, void *vi, void *vf)
113 {
114 int size = size_mask & 0xff;
115 int mask = size_mask >> 8;
116 int n = size >> 2;
117
118 if (mask == 0)
119 return vi;
120 else if (mask == (1 << n) - 1)
121 return vf;
122 else
123 {
124 unsigned int *wi = vi, *wf = vf;
125 int i;
126
127 for (i = 0; i < n; ++i)
128 if ((mask >> i) & 1)
129 wi[i] = wf[i];
130
131 return vi;
132 }
133 }
134
135 /* Similar, but place the data into VD in the end. */
136
137 void FFI_HIDDEN
138 ffi_struct_float_copy (int size_mask, void *vd, void *vi, void *vf)
139 {
140 int size = size_mask & 0xff;
141 int mask = size_mask >> 8;
142 int n = size >> 2;
143
144 if (mask == 0)
145 ;
146 else if (mask == (1 << n) - 1)
147 vi = vf;
148 else
149 {
150 unsigned int *wd = vd, *wi = vi, *wf = vf;
151 int i;
152
153 for (i = 0; i < n; ++i)
154 wd[i] = ((mask >> i) & 1 ? wf : wi)[i];
155 return;
156 }
157 memcpy (vd, vi, size);
158 }
159
160 /* Perform machine dependent cif processing */
161
162 static ffi_status
163 ffi_prep_cif_machdep_core(ffi_cif *cif)
164 {
165 ffi_type *rtype = cif->rtype;
166 int rtt = rtype->type;
167 size_t bytes = 0;
168 int i, n, flags;
169
170 /* Set the return type flag */
171 switch (rtt)
172 {
173 case FFI_TYPE_VOID:
174 flags = SPARC_RET_VOID;
175 break;
176 case FFI_TYPE_FLOAT:
177 flags = SPARC_RET_F_1;
178 break;
179 case FFI_TYPE_DOUBLE:
180 flags = SPARC_RET_F_2;
181 break;
182 case FFI_TYPE_LONGDOUBLE:
183 flags = SPARC_RET_F_4;
184 break;
185
186 case FFI_TYPE_COMPLEX:
187 case FFI_TYPE_STRUCT:
188 if (rtype->size > 32)
189 {
190 flags = SPARC_RET_VOID | SPARC_FLAG_RET_IN_MEM;
191 bytes = 8;
192 }
193 else
194 {
195 int size_mask = ffi_struct_float_mask (rtype, 0);
196 int word_size = (size_mask >> 2) & 0x3f;
197 int all_mask = (1 << word_size) - 1;
198 int fp_mask = size_mask >> 8;
199
200 flags = (size_mask << SPARC_SIZEMASK_SHIFT) | SPARC_RET_STRUCT;
201
202 /* For special cases of all-int or all-fp, we can return
203 the value directly without popping through a struct copy. */
204 if (fp_mask == 0)
205 {
206 if (rtype->alignment >= 8)
207 {
208 if (rtype->size == 8)
209 flags = SPARC_RET_INT64;
210 else if (rtype->size == 16)
211 flags = SPARC_RET_INT128;
212 }
213 }
214 else if (fp_mask == all_mask)
215 switch (word_size)
216 {
217 case 1: flags = SPARC_RET_F_1; break;
218 case 2: flags = SPARC_RET_F_2; break;
219 case 3: flags = SP_V9_RET_F_3; break;
220 case 4: flags = SPARC_RET_F_4; break;
221 /* 5 word structures skipped; handled via RET_STRUCT. */
222 case 6: flags = SPARC_RET_F_6; break;
223 /* 7 word structures skipped; handled via RET_STRUCT. */
224 case 8: flags = SPARC_RET_F_8; break;
225 }
226 }
227 break;
228
229 case FFI_TYPE_SINT8:
230 flags = SPARC_RET_SINT8;
231 break;
232 case FFI_TYPE_UINT8:
233 flags = SPARC_RET_UINT8;
234 break;
235 case FFI_TYPE_SINT16:
236 flags = SPARC_RET_SINT16;
237 break;
238 case FFI_TYPE_UINT16:
239 flags = SPARC_RET_UINT16;
240 break;
241 case FFI_TYPE_INT:
242 case FFI_TYPE_SINT32:
243 flags = SP_V9_RET_SINT32;
244 break;
245 case FFI_TYPE_UINT32:
246 flags = SPARC_RET_UINT32;
247 break;
248 case FFI_TYPE_SINT64:
249 case FFI_TYPE_UINT64:
250 case FFI_TYPE_POINTER:
251 flags = SPARC_RET_INT64;
252 break;
253
254 default:
255 abort();
256 }
257
258 bytes = 0;
259 for (i = 0, n = cif->nargs; i < n; ++i)
260 {
261 ffi_type *ty = cif->arg_types[i];
262 size_t z = ty->size;
263 size_t a = ty->alignment;
264
265 switch (ty->type)
266 {
267 case FFI_TYPE_COMPLEX:
268 case FFI_TYPE_STRUCT:
269 /* Large structs passed by reference. */
270 if (z > 16)
271 {
272 a = z = 8;
273 break;
274 }
275 /* Small structs may be passed in integer or fp regs or both. */
276 if (bytes >= 16*8)
277 break;
278 if ((ffi_struct_float_mask (ty, 0) & 0xff00) == 0)
279 break;
280 /* FALLTHRU */
281 case FFI_TYPE_FLOAT:
282 case FFI_TYPE_DOUBLE:
283 case FFI_TYPE_LONGDOUBLE:
284 flags |= SPARC_FLAG_FP_ARGS;
285 break;
286 }
287 bytes = FFI_ALIGN(bytes, a);
288 bytes += FFI_ALIGN(z, 8);
289 }
290
291 /* Sparc call frames require that space is allocated for 6 args,
292 even if they aren't used. Make that space if necessary. */
293 if (bytes < 6 * 8)
294 bytes = 6 * 8;
295
296 /* The stack must be 2 word aligned, so round bytes up appropriately. */
297 bytes = FFI_ALIGN(bytes, 16);
298
299 /* Include the call frame to prep_args. */
300 bytes += 8*16 + 8*8;
301
302 cif->bytes = bytes;
303 cif->flags = flags;
304 return FFI_OK;
305 }
306
307 ffi_status FFI_HIDDEN
308 ffi_prep_cif_machdep(ffi_cif *cif)
309 {
310 cif->nfixedargs = cif->nargs;
311 return ffi_prep_cif_machdep_core(cif);
312 }
313
314 ffi_status FFI_HIDDEN
315 ffi_prep_cif_machdep_var(ffi_cif *cif, unsigned nfixedargs, unsigned ntotalargs)
316 {
317 cif->nfixedargs = nfixedargs;
318 return ffi_prep_cif_machdep_core(cif);
319 }
320
321 extern void ffi_call_v9(ffi_cif *cif, void (*fn)(void), void *rvalue,
322 void **avalue, size_t bytes, void *closure) FFI_HIDDEN;
323
324 /* ffi_prep_args is called by the assembly routine once stack space
325 has been allocated for the function's arguments */
326
327 int FFI_HIDDEN
328 ffi_prep_args_v9(ffi_cif *cif, unsigned long *argp, void *rvalue, void **avalue)
329 {
330 ffi_type **p_arg;
331 int flags = cif->flags;
332 int i, nargs;
333
334 if (rvalue == NULL)
335 {
336 if (flags & SPARC_FLAG_RET_IN_MEM)
337 {
338 /* Since we pass the pointer to the callee, we need a value.
339 We allowed for this space in ffi_call, before ffi_call_v8
340 alloca'd the space. */
341 rvalue = (char *)argp + cif->bytes;
342 }
343 else
344 {
345 /* Otherwise, we can ignore the return value. */
346 flags = SPARC_RET_VOID;
347 }
348 }
349
350 #ifdef USING_PURIFY
351 /* Purify will probably complain in our assembly routine,
352 unless we zero out this memory. */
353 memset(argp, 0, 6*8);
354 #endif
355
356 if (flags & SPARC_FLAG_RET_IN_MEM)
357 *argp++ = (unsigned long)rvalue;
358
359 p_arg = cif->arg_types;
360 for (i = 0, nargs = cif->nargs; i < nargs; i++)
361 {
362 ffi_type *ty = p_arg[i];
363 void *a = avalue[i];
364 size_t z;
365
366 switch (ty->type)
367 {
368 case FFI_TYPE_SINT8:
369 *argp++ = *(SINT8 *)a;
370 break;
371 case FFI_TYPE_UINT8:
372 *argp++ = *(UINT8 *)a;
373 break;
374 case FFI_TYPE_SINT16:
375 *argp++ = *(SINT16 *)a;
376 break;
377 case FFI_TYPE_UINT16:
378 *argp++ = *(UINT16 *)a;
379 break;
380 case FFI_TYPE_INT:
381 case FFI_TYPE_SINT32:
382 *argp++ = *(SINT32 *)a;
383 break;
384 case FFI_TYPE_UINT32:
385 *argp++ = *(UINT32 *)a;
386 break;
387 case FFI_TYPE_SINT64:
388 case FFI_TYPE_UINT64:
389 case FFI_TYPE_POINTER:
390 *argp++ = *(UINT64 *)a;
391 break;
392 case FFI_TYPE_FLOAT:
393 flags |= SPARC_FLAG_FP_ARGS;
394 *argp++ = *(UINT32 *)a;
395 break;
396 case FFI_TYPE_DOUBLE:
397 flags |= SPARC_FLAG_FP_ARGS;
398 *argp++ = *(UINT64 *)a;
399 break;
400
401 case FFI_TYPE_LONGDOUBLE:
402 case FFI_TYPE_COMPLEX:
403 case FFI_TYPE_STRUCT:
404 z = ty->size;
405 if (z > 16)
406 {
407 /* For structures larger than 16 bytes we pass reference. */
408 *argp++ = (unsigned long)a;
409 break;
410 }
411 if (((unsigned long)argp & 15) && ty->alignment > 8)
412 argp++;
413 memcpy(argp, a, z);
414 argp += FFI_ALIGN(z, 8) / 8;
415 break;
416
417 default:
418 abort();
419 }
420 }
421
422 return flags;
423 }
424
425 static void
426 ffi_call_int(ffi_cif *cif, void (*fn)(void), void *rvalue,
427 void **avalue, void *closure)
428 {
429 size_t bytes = cif->bytes;
430 size_t i, nargs = cif->nargs;
431 ffi_type **arg_types = cif->arg_types;
432
433 FFI_ASSERT (cif->abi == FFI_V9);
434
435 if (rvalue == NULL && (cif->flags & SPARC_FLAG_RET_IN_MEM))
436 bytes += FFI_ALIGN (cif->rtype->size, 16);
437
438 /* If we have any large structure arguments, make a copy so we are passing
439 by value. */
440 for (i = 0; i < nargs; i++)
441 {
442 ffi_type *at = arg_types[i];
443 int size = at->size;
444 if (at->type == FFI_TYPE_STRUCT && size > 4)
445 {
446 char *argcopy = alloca (size);
447 memcpy (argcopy, avalue[i], size);
448 avalue[i] = argcopy;
449 }
450 }
451
452 ffi_call_v9(cif, fn, rvalue, avalue, -bytes, closure);
453 }
454
455 void
456 ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
457 {
458 ffi_call_int(cif, fn, rvalue, avalue, NULL);
459 }
460
461 void
462 ffi_call_go(ffi_cif *cif, void (*fn)(void), void *rvalue,
463 void **avalue, void *closure)
464 {
465 ffi_call_int(cif, fn, rvalue, avalue, closure);
466 }
467
468 #ifdef __GNUC__
469 static inline void
470 ffi_flush_icache (void *p)
471 {
472 asm volatile ("flush %0; flush %0+8" : : "r" (p) : "memory");
473 }
474 #else
475 extern void ffi_flush_icache (void *) FFI_HIDDEN;
476 #endif
477
478 extern void ffi_closure_v9(void) FFI_HIDDEN;
479 extern void ffi_go_closure_v9(void) FFI_HIDDEN;
480
481 ffi_status
482 ffi_prep_closure_loc (ffi_closure* closure,
483 ffi_cif* cif,
484 void (*fun)(ffi_cif*, void*, void**, void*),
485 void *user_data,
486 void *codeloc)
487 {
488 unsigned int *tramp = (unsigned int *) &closure->tramp[0];
489 unsigned long fn;
490
491 if (cif->abi != FFI_V9)
492 return FFI_BAD_ABI;
493
494 /* Trampoline address is equal to the closure address. We take advantage
495 of that to reduce the trampoline size by 8 bytes. */
496 fn = (unsigned long) ffi_closure_v9;
497 tramp[0] = 0x83414000; /* rd %pc, %g1 */
498 tramp[1] = 0xca586010; /* ldx [%g1+16], %g5 */
499 tramp[2] = 0x81c14000; /* jmp %g5 */
500 tramp[3] = 0x01000000; /* nop */
501 *((unsigned long *) &tramp[4]) = fn;
502
503 closure->cif = cif;
504 closure->fun = fun;
505 closure->user_data = user_data;
506
507 ffi_flush_icache (closure);
508
509 return FFI_OK;
510 }
511
512 ffi_status
513 ffi_prep_go_closure (ffi_go_closure* closure, ffi_cif* cif,
514 void (*fun)(ffi_cif*, void*, void**, void*))
515 {
516 if (cif->abi != FFI_V9)
517 return FFI_BAD_ABI;
518
519 closure->tramp = ffi_go_closure_v9;
520 closure->cif = cif;
521 closure->fun = fun;
522
523 return FFI_OK;
524 }
525
526 int FFI_HIDDEN
527 ffi_closure_sparc_inner_v9(ffi_cif *cif,
528 void (*fun)(ffi_cif*, void*, void**, void*),
529 void *user_data, void *rvalue,
530 unsigned long *gpr, unsigned long *fpr)
531 {
532 ffi_type **arg_types;
533 void **avalue;
534 int i, argn, argx, nargs, flags, nfixedargs;
535
536 arg_types = cif->arg_types;
537 nargs = cif->nargs;
538 flags = cif->flags;
539 nfixedargs = cif->nfixedargs;
540
541 avalue = alloca(nargs * sizeof(void *));
542
543 /* Copy the caller's structure return address so that the closure
544 returns the data directly to the caller. */
545 if (flags & SPARC_FLAG_RET_IN_MEM)
546 {
547 rvalue = (void *) gpr[0];
548 /* Skip the structure return address. */
549 argn = 1;
550 }
551 else
552 argn = 0;
553
554 /* Grab the addresses of the arguments from the stack frame. */
555 for (i = 0; i < nargs; i++, argn = argx)
556 {
557 int named = i < nfixedargs;
558 ffi_type *ty = arg_types[i];
559 void *a = &gpr[argn];
560 size_t z;
561
562 argx = argn + 1;
563 switch (ty->type)
564 {
565 case FFI_TYPE_COMPLEX:
566 case FFI_TYPE_STRUCT:
567 z = ty->size;
568 if (z > 16)
569 a = *(void **)a;
570 else
571 {
572 argx = argn + FFI_ALIGN (z, 8) / 8;
573 if (named && argn < 16)
574 {
575 int size_mask = ffi_struct_float_mask (ty, 0);
576 int argn_mask = (0xffff00 >> argn) & 0xff00;
577
578 /* Eliminate fp registers off the end. */
579 size_mask = (size_mask & 0xff) | (size_mask & argn_mask);
580 a = ffi_struct_float_merge (size_mask, gpr+argn, fpr+argn);
581 }
582 }
583 break;
584
585 case FFI_TYPE_LONGDOUBLE:
586 argn = FFI_ALIGN (argn, 2);
587 a = (named && argn < 16 ? fpr : gpr) + argn;
588 argx = argn + 2;
589 break;
590 case FFI_TYPE_DOUBLE:
591 if (named && argn < 16)
592 a = fpr + argn;
593 break;
594 case FFI_TYPE_FLOAT:
595 if (named && argn < 16)
596 a = fpr + argn;
597 a += 4;
598 break;
599
600 case FFI_TYPE_UINT64:
601 case FFI_TYPE_SINT64:
602 case FFI_TYPE_POINTER:
603 break;
604 case FFI_TYPE_INT:
605 case FFI_TYPE_UINT32:
606 case FFI_TYPE_SINT32:
607 a += 4;
608 break;
609 case FFI_TYPE_UINT16:
610 case FFI_TYPE_SINT16:
611 a += 6;
612 break;
613 case FFI_TYPE_UINT8:
614 case FFI_TYPE_SINT8:
615 a += 7;
616 break;
617
618 default:
619 abort();
620 }
621 avalue[i] = a;
622 }
623
624 /* Invoke the closure. */
625 fun (cif, rvalue, avalue, user_data);
626
627 /* Tell ffi_closure_sparc how to perform return type promotions. */
628 return flags;
629 }
630 #endif /* SPARC64 */