source: trunk/gcc/libffi/src/sparc/ffi.c

Last change on this file was 1392, checked in by bird, 21 years ago

This commit was generated by cvs2svn to compensate for changes in r1391,
which included commits to RCS files with non-trunk default branches.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 12.5 KB
Line 
1/* -----------------------------------------------------------------------
2 ffi.c - Copyright (c) 1996, 2003 Cygnus Solutions
3
4 Sparc Foreign Function Interface
5
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:
13
14 The above copyright notice and this permission notice shall be included
15 in all copies or substantial portions of the Software.
16
17 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 OTHER DEALINGS IN THE SOFTWARE.
24 ----------------------------------------------------------------------- */
25
26#include <ffi.h>
27#include <ffi_common.h>
28
29#include <stdlib.h>
30
31#ifdef SPARC64
32extern void ffi_closure_v9(void);
33#else
34extern void ffi_closure_v8(void);
35#endif
36
37/* ffi_prep_args is called by the assembly routine once stack space
38 has been allocated for the function's arguments */
39
40void ffi_prep_args_v8(char *stack, extended_cif *ecif)
41{
42 int i;
43 void **p_argv;
44 char *argp;
45 ffi_type **p_arg;
46
47 /* Skip 16 words for the window save area */
48 argp = stack + 16*sizeof(int);
49
50 /* This should only really be done when we are returning a structure,
51 however, it's faster just to do it all the time...
52
53 if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT ) */
54 *(int *) argp = (long)ecif->rvalue;
55
56 /* And 1 word for the structure return value. */
57 argp += sizeof(int);
58
59#ifdef USING_PURIFY
60 /* Purify will probably complain in our assembly routine, unless we
61 zero out this memory. */
62
63 ((int*)argp)[0] = 0;
64 ((int*)argp)[1] = 0;
65 ((int*)argp)[2] = 0;
66 ((int*)argp)[3] = 0;
67 ((int*)argp)[4] = 0;
68 ((int*)argp)[5] = 0;
69#endif
70
71 p_argv = ecif->avalue;
72
73 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; i; i--, p_arg++)
74 {
75 size_t z;
76
77 if ((*p_arg)->type == FFI_TYPE_STRUCT
78#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
79 || (*p_arg)->type == FFI_TYPE_LONGDOUBLE
80#endif
81 )
82 {
83 *(unsigned int *) argp = (unsigned long)(* p_argv);
84 z = sizeof(int);
85 }
86 else
87 {
88 z = (*p_arg)->size;
89 if (z < sizeof(int))
90 {
91 z = sizeof(int);
92 switch ((*p_arg)->type)
93 {
94 case FFI_TYPE_SINT8:
95 *(signed int *) argp = *(SINT8 *)(* p_argv);
96 break;
97
98 case FFI_TYPE_UINT8:
99 *(unsigned int *) argp = *(UINT8 *)(* p_argv);
100 break;
101
102 case FFI_TYPE_SINT16:
103 *(signed int *) argp = *(SINT16 *)(* p_argv);
104 break;
105
106 case FFI_TYPE_UINT16:
107 *(unsigned int *) argp = *(UINT16 *)(* p_argv);
108 break;
109
110 default:
111 FFI_ASSERT(0);
112 }
113 }
114 else
115 {
116 memcpy(argp, *p_argv, z);
117 }
118 }
119 p_argv++;
120 argp += z;
121 }
122
123 return;
124}
125
126int ffi_prep_args_v9(char *stack, extended_cif *ecif)
127{
128 int i, ret = 0;
129 int tmp;
130 void **p_argv;
131 char *argp;
132 ffi_type **p_arg;
133
134 tmp = 0;
135
136 /* Skip 16 words for the window save area */
137 argp = stack + 16*sizeof(long long);
138
139#ifdef USING_PURIFY
140 /* Purify will probably complain in our assembly routine, unless we
141 zero out this memory. */
142
143 ((long long*)argp)[0] = 0;
144 ((long long*)argp)[1] = 0;
145 ((long long*)argp)[2] = 0;
146 ((long long*)argp)[3] = 0;
147 ((long long*)argp)[4] = 0;
148 ((long long*)argp)[5] = 0;
149#endif
150
151 p_argv = ecif->avalue;
152
153 if (ecif->cif->rtype->type == FFI_TYPE_STRUCT &&
154 ecif->cif->rtype->size > 32)
155 {
156 *(unsigned long long *) argp = (unsigned long)ecif->rvalue;
157 tmp = 1;
158 }
159
160 for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs;
161 i++, p_arg++)
162 {
163 size_t z;
164
165 z = (*p_arg)->size;
166 switch ((*p_arg)->type)
167 {
168 case FFI_TYPE_STRUCT:
169 if (z > 16)
170 {
171 /* For structures larger than 16 bytes we pass reference. */
172 *(unsigned long long *) argp = (unsigned long)* p_argv;
173 argp += sizeof(long long);
174 tmp++;
175 p_argv++;
176 continue;
177 }
178 /* FALLTHROUGH */
179 case FFI_TYPE_FLOAT:
180 case FFI_TYPE_DOUBLE:
181#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
182 case FFI_TYPE_LONGDOUBLE:
183#endif
184 ret = 1; /* We should promote into FP regs as well as integer. */
185 break;
186 }
187 if (z < sizeof(long long))
188 {
189 switch ((*p_arg)->type)
190 {
191 case FFI_TYPE_SINT8:
192 *(signed long long *) argp = *(SINT8 *)(* p_argv);
193 break;
194
195 case FFI_TYPE_UINT8:
196 *(unsigned long long *) argp = *(UINT8 *)(* p_argv);
197 break;
198
199 case FFI_TYPE_SINT16:
200 *(signed long long *) argp = *(SINT16 *)(* p_argv);
201 break;
202
203 case FFI_TYPE_UINT16:
204 *(unsigned long long *) argp = *(UINT16 *)(* p_argv);
205 break;
206
207 case FFI_TYPE_SINT32:
208 *(signed long long *) argp = *(SINT32 *)(* p_argv);
209 break;
210
211 case FFI_TYPE_UINT32:
212 *(unsigned long long *) argp = *(UINT32 *)(* p_argv);
213 break;
214
215 case FFI_TYPE_FLOAT:
216 *(float *) (argp + 4) = *(FLOAT32 *)(* p_argv); /* Right justify */
217 break;
218
219 case FFI_TYPE_STRUCT:
220 memcpy(argp, *p_argv, z);
221 break;
222
223 default:
224 FFI_ASSERT(0);
225 }
226 z = sizeof(long long);
227 tmp++;
228 }
229 else if (z == sizeof(long long))
230 {
231 memcpy(argp, *p_argv, z);
232 z = sizeof(long long);
233 tmp++;
234 }
235 else
236 {
237 if ((tmp & 1) && (*p_arg)->alignment > 8)
238 {
239 tmp++;
240 argp += sizeof(long long);
241 }
242 memcpy(argp, *p_argv, z);
243 z = 2 * sizeof(long long);
244 tmp += 2;
245 }
246 p_argv++;
247 argp += z;
248 }
249
250 return ret;
251}
252
253/* Perform machine dependent cif processing */
254ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
255{
256 int wordsize;
257
258 if (cif->abi != FFI_V9)
259 {
260 wordsize = 4;
261
262 /* If we are returning a struct, this will already have been added.
263 Otherwise we need to add it because it's always got to be there! */
264
265 if (cif->rtype->type != FFI_TYPE_STRUCT)
266 cif->bytes += wordsize;
267
268 /* sparc call frames require that space is allocated for 6 args,
269 even if they aren't used. Make that space if necessary. */
270
271 if (cif->bytes < 4*6+4)
272 cif->bytes = 4*6+4;
273 }
274 else
275 {
276 wordsize = 8;
277
278 /* sparc call frames require that space is allocated for 6 args,
279 even if they aren't used. Make that space if necessary. */
280
281 if (cif->bytes < 8*6)
282 cif->bytes = 8*6;
283 }
284
285 /* Adjust cif->bytes. to include 16 words for the window save area,
286 and maybe the struct/union return pointer area, */
287
288 cif->bytes += 16 * wordsize;
289
290 /* The stack must be 2 word aligned, so round bytes up
291 appropriately. */
292
293 cif->bytes = ALIGN(cif->bytes, 2 * wordsize);
294
295 /* Set the return type flag */
296 switch (cif->rtype->type)
297 {
298 case FFI_TYPE_VOID:
299 case FFI_TYPE_FLOAT:
300 case FFI_TYPE_DOUBLE:
301#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
302 case FFI_TYPE_LONGDOUBLE:
303#endif
304 cif->flags = cif->rtype->type;
305 break;
306
307 case FFI_TYPE_STRUCT:
308 if (cif->abi == FFI_V9 && cif->rtype->size > 32)
309 cif->flags = FFI_TYPE_VOID;
310 else
311 cif->flags = FFI_TYPE_STRUCT;
312 break;
313
314 case FFI_TYPE_SINT64:
315 case FFI_TYPE_UINT64:
316 if (cif->abi != FFI_V9)
317 {
318 cif->flags = FFI_TYPE_SINT64;
319 break;
320 }
321 /* FALLTHROUGH */
322 default:
323 cif->flags = FFI_TYPE_INT;
324 break;
325 }
326 return FFI_OK;
327}
328
329int ffi_V9_return_struct(ffi_type *arg, int off, char *ret, char *intg, char *flt)
330{
331 ffi_type **ptr = &arg->elements[0];
332
333 while (*ptr != NULL)
334 {
335 if (off & ((*ptr)->alignment - 1))
336 off = ALIGN(off, (*ptr)->alignment);
337
338 switch ((*ptr)->type)
339 {
340 case FFI_TYPE_STRUCT:
341 off = ffi_V9_return_struct(*ptr, off, ret, intg, flt);
342 break;
343 case FFI_TYPE_FLOAT:
344 case FFI_TYPE_DOUBLE:
345#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
346 case FFI_TYPE_LONGDOUBLE:
347#endif
348 memcpy(ret + off, flt + off, (*ptr)->size);
349 off += (*ptr)->size;
350 break;
351 default:
352 memcpy(ret + off, intg + off, (*ptr)->size);
353 off += (*ptr)->size;
354 break;
355 }
356 ptr++;
357 }
358 return off;
359}
360
361extern int ffi_call_V8(void *, extended_cif *, unsigned,
362 unsigned, unsigned *, void (*fn)());
363extern int ffi_call_V9(void *, extended_cif *, unsigned,
364 unsigned, unsigned *, void (*fn)());
365
366void ffi_call(ffi_cif *cif, void (*fn)(), void *rvalue, void **avalue)
367{
368 extended_cif ecif;
369 void *rval = rvalue;
370
371 ecif.cif = cif;
372 ecif.avalue = avalue;
373
374 /* If the return value is a struct and we don't have a return */
375 /* value address then we need to make one */
376
377 ecif.rvalue = rvalue;
378 if (cif->rtype->type == FFI_TYPE_STRUCT)
379 {
380 if (cif->rtype->size <= 32)
381 rval = alloca(64);
382 else
383 {
384 rval = NULL;
385 if (rvalue == NULL)
386 ecif.rvalue = alloca(cif->rtype->size);
387 }
388 }
389
390 switch (cif->abi)
391 {
392 case FFI_V8:
393#ifdef SPARC64
394 /* We don't yet support calling 32bit code from 64bit */
395 FFI_ASSERT(0);
396#else
397 ffi_call_V8(ffi_prep_args_v8, &ecif, cif->bytes,
398 cif->flags, rvalue, fn);
399#endif
400 break;
401 case FFI_V9:
402#ifdef SPARC64
403 ffi_call_V9(ffi_prep_args_v9, &ecif, cif->bytes,
404 cif->flags, rval, fn);
405 if (rvalue && rval && cif->rtype->type == FFI_TYPE_STRUCT)
406 ffi_V9_return_struct(cif->rtype, 0, (char *)rvalue, (char *)rval, ((char *)rval)+32);
407#else
408 /* And vice versa */
409 FFI_ASSERT(0);
410#endif
411 break;
412 default:
413 FFI_ASSERT(0);
414 break;
415 }
416
417}
418
419ffi_status
420ffi_prep_closure (ffi_closure* closure,
421 ffi_cif* cif,
422 void (*fun)(ffi_cif*, void*, void**, void*),
423 void *user_data)
424{
425 unsigned int *tramp = (unsigned int *) &closure->tramp[0];
426 unsigned long fn;
427 unsigned long ctx = (unsigned long) closure;
428
429#ifdef SPARC64
430 /* Trampoline address is equal to the closure address. We take advantage
431 of that to reduce the trampoline size by 8 bytes. */
432 FFI_ASSERT (cif->abi == FFI_V9);
433 fn = (unsigned long) ffi_closure_v9;
434 tramp[0] = 0x83414000; /* rd %pc, %g1 */
435 tramp[1] = 0xca586010; /* ldx [%g1+16], %g5 */
436 tramp[2] = 0x81c14000; /* jmp %g5 */
437 tramp[3] = 0x01000000; /* nop */
438 *((unsigned long *) &tramp[4]) = fn;
439#else
440 FFI_ASSERT (cif->abi == FFI_V8);
441 fn = (unsigned long) ffi_closure_v8;
442 tramp[0] = 0x03000000 | fn >> 10; /* sethi %hi(fn), %g1 */
443 tramp[1] = 0x05000000 | ctx >> 10; /* sethi %hi(ctx), %g2 */
444 tramp[2] = 0x81c06000 | (fn & 0x3ff); /* jmp %g1+%lo(fn) */
445 tramp[3] = 0x8410a000 | (ctx & 0x3ff);/* or %g2, %lo(ctx) */
446#endif
447
448 closure->cif = cif;
449 closure->fun = fun;
450 closure->user_data = user_data;
451
452 /* Flush the Icache. FIXME: alignment isn't certain, assume 8 bytes */
453#ifdef SPARC64
454 asm volatile ("flush %0" : : "r" (closure) : "memory");
455 asm volatile ("flush %0" : : "r" (((char *) closure) + 8) : "memory");
456#else
457 asm volatile ("iflush %0" : : "r" (closure) : "memory");
458 asm volatile ("iflush %0" : : "r" (((char *) closure) + 8) : "memory");
459#endif
460
461 return FFI_OK;
462}
463
464int
465ffi_closure_sparc_inner(ffi_closure *closure,
466 void *rvalue, unsigned long *gpr, double *fpr)
467{
468 ffi_cif *cif;
469 void **avalue;
470 ffi_type **arg_types;
471 int i, avn, argn;
472
473 cif = closure->cif;
474 avalue = alloca(cif->nargs * sizeof(void *));
475
476 argn = 0;
477
478 /* Copy the caller's structure return address to that the closure
479 returns the data directly to the caller. */
480 if (cif->flags == FFI_TYPE_STRUCT)
481 {
482 rvalue = (void *) gpr[0];
483 argn = 1;
484 }
485
486 i = 0;
487 avn = cif->nargs;
488 arg_types = cif->arg_types;
489
490 /* Grab the addresses of the arguments from the stack frame. */
491 while (i < avn)
492 {
493 /* Assume big-endian. FIXME */
494 argn += ALIGN(arg_types[i]->size, SIZEOF_ARG) / SIZEOF_ARG;
495
496#ifdef SPARC64
497 if (i < 6 && (arg_types[i]->type == FFI_TYPE_FLOAT
498 || arg_types[i]->type == FFI_TYPE_DOUBLE
499#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
500 || arg_types[i]->type == FFI_TYPE_LONGDOUBLE
501#endif
502 ))
503 avalue[i] = ((char *) &fpr[argn]) - arg_types[i]->size;
504 else
505#endif
506 avalue[i] = ((char *) &gpr[argn]) - arg_types[i]->size;
507 i++;
508 }
509
510 /* Invoke the closure. */
511 (closure->fun) (cif, rvalue, avalue, closure->user_data);
512
513 /* Tell ffi_closure_sparc how to perform return type promotions. */
514 return cif->rtype->type;
515}
Note: See TracBrowser for help on using the repository browser.