OSDN Git Service

fd2a37104345b822707e39aee3d2799e5909b229
[pf3gnuchains/gcc-fork.git] / libffi / src / powerpc / ffi_darwin.c
1 /* -----------------------------------------------------------------------
2    ffi_darwin.c
3
4    Copyright (C) 1998 Geoffrey Keating
5    Copyright (C) 2001 John Hornkvist
6    Copyright (C) 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
7
8    FFI support for Darwin and AIX.
9    
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:
17
18    The above copyright notice and this permission notice shall be included
19    in all copies or substantial portions of the Software.
20
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    ----------------------------------------------------------------------- */
29
30 #include <ffi.h>
31 #include <ffi_common.h>
32
33 #include <stdlib.h>
34
35 extern void ffi_closure_ASM(void);
36
37 enum {
38   /* The assembly depends on these exact flags.  */
39   FLAG_RETURNS_NOTHING  = 1 << (31-30), /* These go in cr7  */
40   FLAG_RETURNS_FP       = 1 << (31-29),
41   FLAG_RETURNS_64BITS   = 1 << (31-28),
42   FLAG_RETURNS_128BITS  = 1 << (31-31),
43
44   FLAG_ARG_NEEDS_COPY   = 1 << (31- 7),
45   FLAG_FP_ARGUMENTS     = 1 << (31- 6), /* cr1.eq; specified by ABI  */
46   FLAG_4_GPR_ARGUMENTS  = 1 << (31- 5),
47   FLAG_RETVAL_REFERENCE = 1 << (31- 4)
48 };
49
50 /* About the DARWIN ABI.  */
51 enum {
52   NUM_GPR_ARG_REGISTERS = 8,
53   NUM_FPR_ARG_REGISTERS = 13
54 };
55 enum { ASM_NEEDS_REGISTERS = 4 };
56
57 /* ffi_prep_args is called by the assembly routine once stack space
58    has been allocated for the function's arguments.
59
60    The stack layout we want looks like this:
61
62    |   Return address from ffi_call_DARWIN      |       higher addresses
63    |--------------------------------------------|
64    |   Previous backchain pointer       4       |       stack pointer here
65    |--------------------------------------------|<+ <<< on entry to
66    |   Saved r28-r31                    4*4     | |     ffi_call_DARWIN
67    |--------------------------------------------| |
68    |   Parameters             (at least 8*4=32) | |
69    |--------------------------------------------| |
70    |   Space for GPR2                   4       | |
71    |--------------------------------------------| |     stack   |
72    |   Reserved                       2*4       | |     grows   |
73    |--------------------------------------------| |     down    V
74    |   Space for callee's LR            4       | |
75    |--------------------------------------------| |     lower addresses
76    |   Saved CR                         4       | |
77    |--------------------------------------------| |     stack pointer here
78    |   Current backchain pointer        4       |-/     during
79    |--------------------------------------------|   <<< ffi_call_DARWIN
80
81    */
82
83 void ffi_prep_args(extended_cif *ecif, unsigned long *const stack)
84 {
85   const unsigned bytes = ecif->cif->bytes;
86   const unsigned flags = ecif->cif->flags;
87
88   /* 'stacktop' points at the previous backchain pointer.  */
89   unsigned long *const stacktop = stack + (bytes / sizeof(unsigned long));
90
91   /* 'fpr_base' points at the space for fpr1, and grows upwards as
92      we use FPR registers.  */
93   double *fpr_base = (double *) ((stacktop - ASM_NEEDS_REGISTERS)
94                                  - NUM_FPR_ARG_REGISTERS);
95   int fparg_count = 0;
96
97
98   /* 'next_arg' grows up as we put parameters in it.  */
99   unsigned long *next_arg = (unsigned long *) stack + 6; /* 6 reserved positions.  */
100
101   int i;
102   double double_tmp;
103   void **p_argv = ecif->avalue;
104   unsigned long gprvalue;
105   ffi_type** ptr = ecif->cif->arg_types;
106   char *dest_cpy;
107   unsigned size_al = 0;
108
109   /* Check that everything starts aligned properly.  */
110   FFI_ASSERT(((unsigned)(char *)stack & 0xF) == 0);
111   FFI_ASSERT(((unsigned)(char *)stacktop & 0xF) == 0);
112   FFI_ASSERT((bytes & 0xF) == 0);
113
114   /* Deal with return values that are actually pass-by-reference.
115      Rule:
116      Return values are referenced by r3, so r4 is the first parameter.  */
117
118   if (flags & FLAG_RETVAL_REFERENCE)
119     *next_arg++ = (unsigned long)(char *)ecif->rvalue;
120
121   /* Now for the arguments.  */
122   for (i = ecif->cif->nargs; i > 0; i--, ptr++, p_argv++)
123     {
124       switch ((*ptr)->type)
125         {
126         /* If a floating-point parameter appears before all of the general-
127            purpose registers are filled, the corresponding GPRs that match
128            the size of the floating-point parameter are skipped.  */
129         case FFI_TYPE_FLOAT:
130           double_tmp = *(float *)*p_argv;
131           if (fparg_count >= NUM_FPR_ARG_REGISTERS)
132             *(double *)next_arg = double_tmp;
133           else
134             *fpr_base++ = double_tmp;
135 #ifdef POWERPC64
136           next_arg++;
137 #else
138           next_arg += 2;
139 #endif
140           fparg_count++;
141           FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
142           break;
143
144         case FFI_TYPE_DOUBLE:
145           double_tmp = *(double *)*p_argv;
146           if (fparg_count >= NUM_FPR_ARG_REGISTERS)
147             *(double *)next_arg = double_tmp;
148           else
149             *fpr_base++ = double_tmp;
150           next_arg += 2;
151           fparg_count++;
152           FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
153           break;
154
155 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
156
157         case FFI_TYPE_LONGDOUBLE:
158 #ifdef POWERPC64
159           if (fparg_count < NUM_FPR_ARG_REGISTERS)
160             *((long double *) fpr_base)++ = *(long double *) *p_argv;
161           else
162             *(long double *) next_arg = *(long double *) *p_argv;
163           next_arg += 2;
164           fparg_count += 2;
165 #else
166           double_tmp = *((double *) *p_argv);
167           if (fparg_count < NUM_FPR_ARG_REGISTERS)
168             *fpr_base++ = double_tmp;
169           else
170             *(double *) next_arg = double_tmp;
171
172           double_tmp = ((double *) *p_argv)[1];
173           if (fparg_count < NUM_FPR_ARG_REGISTERS)
174             *fpr_base++ = double_tmp;
175           else
176             *(double *) next_arg = double_tmp;
177           next_arg += 2;
178           fparg_count++;
179 #endif
180           FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
181           break;
182 #endif
183         case FFI_TYPE_UINT64:
184         case FFI_TYPE_SINT64:
185 #ifdef POWERPC64
186           gprvalue = *(long long *) p_argv;
187           goto putgpr;
188 #else
189           *(long long *) next_arg = *(long long *) *p_argv;
190           next_arg+=2;
191 #endif
192           break;
193         case FFI_TYPE_POINTER:
194           gprvalue = *(unsigned long *) *p_argv;
195           goto putgpr;
196         case FFI_TYPE_UINT8:
197           gprvalue = *(unsigned char *) *p_argv;
198           goto putgpr;
199         case FFI_TYPE_SINT8:
200           gprvalue = *(signed char *) *p_argv;
201           goto putgpr;
202         case FFI_TYPE_UINT16:
203           gprvalue = *(unsigned short *) *p_argv;
204           goto putgpr;
205         case FFI_TYPE_SINT16:
206           gprvalue = *(signed short *) *p_argv;
207           goto putgpr;
208
209         case FFI_TYPE_STRUCT:
210 #ifdef POWERPC64
211           dest_cpy = (char *) next_arg;
212           size_al = (*ptr)->size;
213           if ((*ptr)->elements[0]->type == 3)
214             size_al = ALIGN((*ptr)->size, 8);
215           if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
216             dest_cpy += 4 - size_al;
217
218           memcpy ((char *) dest_cpy, (char *) *p_argv, size_al);
219           next_arg += (size_al + 7) / 8;
220 #else
221           dest_cpy = (char *) next_arg;
222
223           /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
224              SI 4 bytes) are aligned as if they were those modes.
225              Structures with 3 byte in size are padded upwards.  */
226           size_al = (*ptr)->size;
227           /* If the first member of the struct is a double, then align
228              the struct to double-word.
229              Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3.  */
230           if ((*ptr)->elements[0]->type == 3)
231             size_al = ALIGN((*ptr)->size, 8);
232           if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
233             dest_cpy += 4 - size_al;
234
235           memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
236           next_arg += (size_al + 3) / 4;
237 #endif
238           break;
239
240         case FFI_TYPE_INT:
241         case FFI_TYPE_UINT32:
242         case FFI_TYPE_SINT32:
243           gprvalue = *(unsigned *)*p_argv;
244         putgpr:
245           *next_arg++ = gprvalue;
246           break;
247         default:
248           break;
249         }
250     }
251
252   /* Check that we didn't overrun the stack...  */
253   //FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
254   //FFI_ASSERT((unsigned *)fpr_base
255   //         <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
256   //FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
257 }
258
259 /* Adjust the size of S to be correct for Darwin.
260    On Darwin, the first field of a structure has natural alignment.  */
261
262 static void
263 darwin_adjust_aggregate_sizes (ffi_type *s)
264 {
265   int i;
266
267   if (s->type != FFI_TYPE_STRUCT)
268     return;
269
270   s->size = 0;
271   for (i = 0; s->elements[i] != NULL; i++)
272     {
273       ffi_type *p;
274       int align;
275       
276       p = s->elements[i];
277       darwin_adjust_aggregate_sizes (p);
278       if (i == 0
279           && (p->type == FFI_TYPE_UINT64
280               || p->type == FFI_TYPE_SINT64
281               || p->type == FFI_TYPE_DOUBLE
282               || p->alignment == 8))
283         align = 8;
284       else if (p->alignment == 16 || p->alignment < 4)
285         align = p->alignment;
286       else
287         align = 4;
288       s->size = ALIGN(s->size, align) + p->size;
289     }
290   
291   s->size = ALIGN(s->size, s->alignment);
292   
293   if (s->elements[0]->type == FFI_TYPE_UINT64
294       || s->elements[0]->type == FFI_TYPE_SINT64
295       || s->elements[0]->type == FFI_TYPE_DOUBLE
296       || s->elements[0]->alignment == 8)
297     s->alignment = s->alignment > 8 ? s->alignment : 8;
298   /* Do not add additional tail padding.  */
299 }
300
301 /* Perform machine dependent cif processing.  */
302 ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
303 {
304   /* All this is for the DARWIN ABI.  */
305   int i;
306   ffi_type **ptr;
307   unsigned bytes;
308   int fparg_count = 0, intarg_count = 0;
309   unsigned flags = 0;
310   unsigned size_al = 0;
311
312   /* All the machine-independent calculation of cif->bytes will be wrong.
313      All the calculation of structure sizes will also be wrong.
314      Redo the calculation for DARWIN.  */
315
316   if (cif->abi == FFI_DARWIN)
317     {
318       darwin_adjust_aggregate_sizes (cif->rtype);
319       for (i = 0; i < cif->nargs; i++)
320         darwin_adjust_aggregate_sizes (cif->arg_types[i]);
321     }
322
323   /* Space for the frame pointer, callee's LR, CR, etc, and for
324      the asm's temp regs.  */
325
326   bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long);
327
328   /* Return value handling.  The rules are as follows:
329      - 32-bit (or less) integer values are returned in gpr3;
330      - Structures of size <= 4 bytes also returned in gpr3;
331      - 64-bit integer values and structures between 5 and 8 bytes are returned
332        in gpr3 and gpr4;
333      - Single/double FP values are returned in fpr1;
334      - Long double FP (if not equivalent to double) values are returned in
335        fpr1 and fpr2;
336      - Larger structures values are allocated space and a pointer is passed
337        as the first argument.  */
338   switch (cif->rtype->type)
339     {
340
341 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
342     case FFI_TYPE_LONGDOUBLE:
343       flags |= FLAG_RETURNS_128BITS;
344       flags |= FLAG_RETURNS_FP;
345       break;
346 #endif
347
348     case FFI_TYPE_DOUBLE:
349       flags |= FLAG_RETURNS_64BITS;
350       /* Fall through.  */
351     case FFI_TYPE_FLOAT:
352       flags |= FLAG_RETURNS_FP;
353       break;
354
355     case FFI_TYPE_UINT64:
356     case FFI_TYPE_SINT64:
357 #ifdef POWERPC64
358     case FFI_TYPE_POINTER:
359 #endif
360       flags |= FLAG_RETURNS_64BITS;
361       break;
362
363     case FFI_TYPE_STRUCT:
364       flags |= FLAG_RETVAL_REFERENCE;
365       flags |= FLAG_RETURNS_NOTHING;
366       intarg_count++;
367       break;
368     case FFI_TYPE_VOID:
369       flags |= FLAG_RETURNS_NOTHING;
370       break;
371
372     default:
373       /* Returns 32-bit integer, or similar.  Nothing to do here.  */
374       break;
375     }
376
377   /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
378      first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
379      goes on the stack.  Structures are passed as a pointer to a copy of
380      the structure. Stuff on the stack needs to keep proper alignment.  */
381   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
382     {
383       switch ((*ptr)->type)
384         {
385         case FFI_TYPE_FLOAT:
386         case FFI_TYPE_DOUBLE:
387           fparg_count++;
388           /* If this FP arg is going on the stack, it must be
389              8-byte-aligned.  */
390           if (fparg_count > NUM_FPR_ARG_REGISTERS
391               && intarg_count%2 != 0)
392             intarg_count++;
393           break;
394
395 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
396
397         case FFI_TYPE_LONGDOUBLE:
398           fparg_count += 2;
399           /* If this FP arg is going on the stack, it must be
400              8-byte-aligned.  */
401           if (fparg_count > NUM_FPR_ARG_REGISTERS
402               && intarg_count%2 != 0)
403             intarg_count++;
404           intarg_count +=2;
405           break;
406 #endif
407
408         case FFI_TYPE_UINT64:
409         case FFI_TYPE_SINT64:
410           /* 'long long' arguments are passed as two words, but
411              either both words must fit in registers or both go
412              on the stack.  If they go on the stack, they must
413              be 8-byte-aligned.  */
414           if (intarg_count == NUM_GPR_ARG_REGISTERS-1
415               || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
416             intarg_count++;
417           intarg_count += 2;
418           break;
419
420         case FFI_TYPE_STRUCT:
421           size_al = (*ptr)->size;
422           /* If the first member of the struct is a double, then align
423              the struct to double-word.  */
424           if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
425             size_al = ALIGN((*ptr)->size, 8);
426 #ifdef POWERPC64
427           intarg_count += (size_al + 7) / 8;
428 #else
429           intarg_count += (size_al + 3) / 4;
430 #endif
431           break;
432
433         default:
434           /* Everything else is passed as a 4-byte word in a GPR, either
435              the object itself or a pointer to it.  */
436           intarg_count++;
437           break;
438         }
439     }
440
441   if (fparg_count != 0)
442     flags |= FLAG_FP_ARGUMENTS;
443
444   /* Space for the FPR registers, if needed.  */
445   if (fparg_count != 0)
446     bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
447
448   /* Stack space.  */
449 #ifdef POWERPC64
450   if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
451     bytes += (intarg_count + fparg_count) * sizeof(long);
452 #else
453   if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
454     bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
455 #endif
456   else
457     bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
458
459   /* The stack space allocated needs to be a multiple of 16 bytes.  */
460 #ifdef POWERPC64
461   bytes = (bytes + 31) & -0x1F;
462 #else
463   bytes = (bytes + 15) & ~0xF;
464 #endif
465
466   cif->flags = flags;
467   cif->bytes = bytes;
468
469   return FFI_OK;
470 }
471
472 extern void ffi_call_AIX(extended_cif *, long, unsigned, unsigned *,
473                          void (*fn)(void), void (*fn2)(void));
474 extern void ffi_call_DARWIN(extended_cif *, long, unsigned, unsigned *,
475                             void (*fn)(void), void (*fn2)(void));
476
477 void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
478 {
479   extended_cif ecif;
480
481   ecif.cif = cif;
482   ecif.avalue = avalue;
483
484   /* If the return value is a struct and we don't have a return
485      value address then we need to make one.  */
486
487   if ((rvalue == NULL) &&
488       (cif->rtype->type == FFI_TYPE_STRUCT))
489     {
490       ecif.rvalue = alloca(cif->rtype->size);
491     }
492   else
493     ecif.rvalue = rvalue;
494
495   switch (cif->abi)
496     {
497     case FFI_AIX:
498       ffi_call_AIX(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
499                    ffi_prep_args);
500       break;
501     case FFI_DARWIN:
502       ffi_call_DARWIN(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
503                       ffi_prep_args);
504       break;
505     default:
506       FFI_ASSERT(0);
507       break;
508     }
509 }
510
511 static void flush_icache(char *);
512 static void flush_range(char *, int);
513
514 /* The layout of a function descriptor.  A C function pointer really
515    points to one of these.  */
516
517 typedef struct aix_fd_struct {
518   void *code_pointer;
519   void *toc;
520 } aix_fd;
521
522 /* here I'd like to add the stack frame layout we use in darwin_closure.S
523    and aix_clsoure.S
524
525    SP previous -> +---------------------------------------+ <--- child frame
526                   | back chain to caller 4                |
527                   +---------------------------------------+ 4
528                   | saved CR 4                            |
529                   +---------------------------------------+ 8
530                   | saved LR 4                            |
531                   +---------------------------------------+ 12
532                   | reserved for compilers 4              |
533                   +---------------------------------------+ 16
534                   | reserved for binders 4                |
535                   +---------------------------------------+ 20
536                   | saved TOC pointer 4                   |
537                   +---------------------------------------+ 24
538                   | always reserved 8*4=32 (previous GPRs)|
539                   | according to the linkage convention   |
540                   | from AIX                              |
541                   +---------------------------------------+ 56
542                   | our FPR area 13*8=104                 |
543                   | f1                                    |
544                   | .                                     |
545                   | f13                                   |
546                   +---------------------------------------+ 160
547                   | result area 8                         |
548                   +---------------------------------------+ 168
549                   | alignement to the next multiple of 16 |
550 SP current -->    +---------------------------------------+ 176 <- parent frame
551                   | back chain to caller 4                |
552                   +---------------------------------------+ 180
553                   | saved CR 4                            |
554                   +---------------------------------------+ 184
555                   | saved LR 4                            |
556                   +---------------------------------------+ 188
557                   | reserved for compilers 4              |
558                   +---------------------------------------+ 192
559                   | reserved for binders 4                |
560                   +---------------------------------------+ 196
561                   | saved TOC pointer 4                   |
562                   +---------------------------------------+ 200
563                   | always reserved 8*4=32  we store our  |
564                   | GPRs here                             |
565                   | r3                                    |
566                   | .                                     |
567                   | r10                                   |
568                   +---------------------------------------+ 232
569                   | overflow part                         |
570                   +---------------------------------------+ xxx
571                   | ????                                  |
572                   +---------------------------------------+ xxx
573
574 */
575 ffi_status
576 ffi_prep_closure_loc (ffi_closure* closure,
577                       ffi_cif* cif,
578                       void (*fun)(ffi_cif*, void*, void**, void*),
579                       void *user_data,
580                       void *codeloc)
581 {
582   unsigned int *tramp;
583   struct ffi_aix_trampoline_struct *tramp_aix;
584   aix_fd *fd;
585
586   switch (cif->abi)
587     {
588     case FFI_DARWIN:
589
590       FFI_ASSERT (cif->abi == FFI_DARWIN);
591
592       tramp = (unsigned int *) &closure->tramp[0];
593       tramp[0] = 0x7c0802a6;  /*   mflr    r0  */
594       tramp[1] = 0x429f000d;  /*   bcl-    20,4*cr7+so,0x10  */
595       tramp[4] = 0x7d6802a6;  /*   mflr    r11  */
596       tramp[5] = 0x818b0000;  /*   lwz     r12,0(r11) function address  */
597       tramp[6] = 0x7c0803a6;  /*   mtlr    r0   */
598       tramp[7] = 0x7d8903a6;  /*   mtctr   r12  */
599       tramp[8] = 0x816b0004;  /*   lwz     r11,4(r11) static chain  */
600       tramp[9] = 0x4e800420;  /*   bctr  */
601       tramp[2] = (unsigned long) ffi_closure_ASM; /* function  */
602       tramp[3] = (unsigned long) codeloc; /* context  */
603
604       closure->cif = cif;
605       closure->fun = fun;
606       closure->user_data = user_data;
607
608       /* Flush the icache. Only necessary on Darwin.  */
609       flush_range(codeloc, FFI_TRAMPOLINE_SIZE);
610
611       break;
612
613     case FFI_AIX:
614
615       tramp_aix = (struct ffi_aix_trampoline_struct *) (closure->tramp);
616       fd = (aix_fd *)(void *)ffi_closure_ASM;
617
618       FFI_ASSERT (cif->abi == FFI_AIX);
619
620       tramp_aix->code_pointer = fd->code_pointer;
621       tramp_aix->toc = fd->toc;
622       tramp_aix->static_chain = codeloc;
623       closure->cif = cif;
624       closure->fun = fun;
625       closure->user_data = user_data;
626
627     default:
628
629       FFI_ASSERT(0);
630       break;
631     }
632   return FFI_OK;
633 }
634
635 static void
636 flush_icache(char *addr)
637 {
638 #ifndef _AIX
639   __asm__ volatile (
640                 "dcbf 0,%0\n"
641                 "\tsync\n"
642                 "\ticbi 0,%0\n"
643                 "\tsync\n"
644                 "\tisync"
645                 : : "r"(addr) : "memory");
646 #endif
647 }
648
649 static void
650 flush_range(char * addr1, int size)
651 {
652 #define MIN_LINE_SIZE 32
653   int i;
654   for (i = 0; i < size; i += MIN_LINE_SIZE)
655     flush_icache(addr1+i);
656   flush_icache(addr1+size-1);
657 }
658
659 typedef union
660 {
661   float f;
662   double d;
663 } ffi_dblfl;
664
665 int ffi_closure_helper_DARWIN (ffi_closure*, void*,
666                                unsigned long*, ffi_dblfl*);
667
668 /* Basically the trampoline invokes ffi_closure_ASM, and on
669    entry, r11 holds the address of the closure.
670    After storing the registers that could possibly contain
671    parameters to be passed into the stack frame and setting
672    up space for a return value, ffi_closure_ASM invokes the
673    following helper function to do most of the work.  */
674
675 int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue,
676                                unsigned long * pgr, ffi_dblfl * pfr)
677 {
678   /* rvalue is the pointer to space for return value in closure assembly
679      pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
680      pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM.  */
681
682   typedef double ldbits[2];
683
684   union ldu
685   {
686     ldbits lb;
687     long double ld;
688   };
689
690   void **          avalue;
691   ffi_type **      arg_types;
692   long             i, avn;
693   long             nf;   /* number of floating registers already used.  */
694   long             ng;   /* number of general registers already used.  */
695   ffi_cif *        cif;
696   double           temp;
697   unsigned         size_al;
698
699   cif = closure->cif;
700   avalue = alloca(cif->nargs * sizeof(void *));
701
702   nf = 0;
703   ng = 0;
704
705   /* Copy the caller's structure return value address so that the closure
706      returns the data directly to the caller.  */
707   if (cif->rtype->type == FFI_TYPE_STRUCT)
708     {
709       rvalue = (void *) *pgr;
710       pgr++;
711       ng++;
712     }
713
714   i = 0;
715   avn = cif->nargs;
716   arg_types = cif->arg_types;
717
718   /* Grab the addresses of the arguments from the stack frame.  */
719   while (i < avn)
720     {
721       switch (arg_types[i]->type)
722         {
723         case FFI_TYPE_SINT8:
724         case FFI_TYPE_UINT8:
725 #ifdef POWERPC64
726           avalue[i] = (char *) pgr + 7;
727 #else
728           avalue[i] = (char *) pgr + 3;
729 #endif
730           ng++;
731           pgr++;
732           break;
733
734         case FFI_TYPE_SINT16:
735         case FFI_TYPE_UINT16:
736 #ifdef POWERPC64
737           avalue[i] = (char *) pgr + 6;
738 #else
739           avalue[i] = (char *) pgr + 2;
740 #endif
741           ng++;
742           pgr++;
743           break;
744
745         case FFI_TYPE_SINT32:
746         case FFI_TYPE_UINT32:
747 #ifdef POWERPC64
748           avalue[i] = (char *) pgr + 4;
749 #else
750         case FFI_TYPE_POINTER:
751           avalue[i] = pgr;
752 #endif
753           ng++;
754           pgr++;
755           break;
756
757         case FFI_TYPE_STRUCT:
758 #ifdef POWERPC64
759           size_al = arg_types[i]->size;
760           if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
761             size_al = ALIGN (arg_types[i]->size, 8);
762           if (size_al < 3 && cif->abi == FFI_DARWIN)
763             avalue[i] = (void *) pgr + 8 - size_al;
764           else
765             avalue[i] = (void *) pgr;
766           ng += (size_al + 7) / 8;
767           pgr += (size_al + 7) / 8;
768 #else
769           /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
770              SI 4 bytes) are aligned as if they were those modes.  */
771           size_al = arg_types[i]->size;
772           /* If the first member of the struct is a double, then align
773              the struct to double-word.  */
774           if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
775             size_al = ALIGN(arg_types[i]->size, 8);
776           if (size_al < 3 && cif->abi == FFI_DARWIN)
777             avalue[i] = (void*) pgr + 4 - size_al;
778           else
779             avalue[i] = (void*) pgr;
780           ng += (size_al + 3) / 4;
781           pgr += (size_al + 3) / 4;
782 #endif
783           break;
784
785         case FFI_TYPE_SINT64:
786         case FFI_TYPE_UINT64:
787 #ifdef POWERPC64
788         case FFI_TYPE_POINTER:
789           avalue[i] = pgr;
790           ng++;
791           pgr++;
792           break;
793 #else
794           /* Long long ints are passed in two gpr's.  */
795           avalue[i] = pgr;
796           ng += 2;
797           pgr += 2;
798           break;
799 #endif
800
801         case FFI_TYPE_FLOAT:
802           /* A float value consumes a GPR.
803              There are 13 64bit floating point registers.  */
804           if (nf < NUM_FPR_ARG_REGISTERS)
805             {
806               temp = pfr->d;
807               pfr->f = (float)temp;
808               avalue[i] = pfr;
809               pfr++;
810             }
811           else
812             {
813               avalue[i] = pgr;
814             }
815           nf++;
816           ng++;
817           pgr++;
818           break;
819
820         case FFI_TYPE_DOUBLE:
821           /* A double value consumes two GPRs.
822              There are 13 64bit floating point registers.  */
823           if (nf < NUM_FPR_ARG_REGISTERS)
824             {
825               avalue[i] = pfr;
826               pfr++;
827             }
828           else
829             {
830               avalue[i] = pgr;
831             }
832           nf++;
833 #ifdef POWERPC64
834           ng++;
835           pgr++;
836 #else
837           ng += 2;
838           pgr += 2;
839 #endif
840           break;
841
842 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
843
844         case FFI_TYPE_LONGDOUBLE:
845 #ifdef POWERPC64
846           if (nf < NUM_FPR_ARG_REGISTERS)
847             {
848               avalue[i] = pfr;
849               pfr += 2;
850             }
851           else
852             {
853               avalue[i] = pgr;
854             }
855           nf += 2;
856           ng += 2;
857           pgr += 2;
858 #else  /* POWERPC64 */
859           /* A long double value consumes four GPRs and two FPRs.
860              There are 13 64bit floating point registers.  */
861           if (nf < NUM_FPR_ARG_REGISTERS - 1)
862             {
863               avalue[i] = pfr;
864               pfr += 2;
865             }
866           /* Here we have the situation where one part of the long double
867              is stored in fpr13 and the other part is already on the stack.
868              We use a union to pass the long double to avalue[i].  */
869           else if (nf == NUM_FPR_ARG_REGISTERS - 1)
870             {
871               union ldu temp_ld;
872               memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
873               memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
874               avalue[i] = &temp_ld.ld;
875             }
876           else
877             {
878               avalue[i] = pgr;
879             }
880           nf += 2;
881           ng += 4;
882           pgr += 4;
883 #endif  /* POWERPC64 */
884           break;
885 #endif
886         default:
887           FFI_ASSERT(0);
888         }
889       i++;
890     }
891
892   (closure->fun) (cif, rvalue, avalue, closure->user_data);
893
894   /* Tell ffi_closure_ASM to perform return type promotions.  */
895   return cif->rtype->type;
896 }