Ruby  2.7.0p0(2019-12-25revision647ee6f091eafcce70ffb75ddf7e121e192ab217)
ffi_darwin.c
Go to the documentation of this file.
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, 2010 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  For Darwin64 (when FLAG_RETURNS_STRUCT is set):
40  FLAG_RETURNS_FP indicates that the structure embeds FP data.
41  FLAG_RETURNS_128BITS signals a special struct size that is not
42  expanded for float content. */
43  FLAG_RETURNS_128BITS = 1 << (31-31), /* These go in cr7 */
44  FLAG_RETURNS_NOTHING = 1 << (31-30),
45  FLAG_RETURNS_FP = 1 << (31-29),
46  FLAG_RETURNS_64BITS = 1 << (31-28),
47 
48  FLAG_RETURNS_STRUCT = 1 << (31-27), /* This goes in cr6 */
49 
50  FLAG_ARG_NEEDS_COPY = 1 << (31- 7),
51  FLAG_FP_ARGUMENTS = 1 << (31- 6), /* cr1.eq; specified by ABI */
52  FLAG_4_GPR_ARGUMENTS = 1 << (31- 5),
53  FLAG_RETVAL_REFERENCE = 1 << (31- 4)
54 };
55 
56 /* About the DARWIN ABI. */
57 enum {
61 };
62 
63 enum { ASM_NEEDS_REGISTERS = 4 }; /* r28-r31 */
64 
65 /* ffi_prep_args is called by the assembly routine once stack space
66  has been allocated for the function's arguments.
67 
68  m32/m64
69 
70  The stack layout we want looks like this:
71 
72  | Return address from ffi_call_DARWIN | higher addresses
73  |--------------------------------------------|
74  | Previous backchain pointer 4/8 | stack pointer here
75  |--------------------------------------------|<+ <<< on entry to
76  | ASM_NEEDS_REGISTERS=r28-r31 4*(4/8) | | ffi_call_DARWIN
77  |--------------------------------------------| |
78  | When we have any FP activity... the | |
79  | FPRs occupy NUM_FPR_ARG_REGISTERS slots | |
80  | here fp13 .. fp1 from high to low addr. | |
81  ~ ~ ~
82  | Parameters (at least 8*4/8=32/64) | | NUM_GPR_ARG_REGISTERS
83  |--------------------------------------------| |
84  | TOC=R2 (AIX) Reserved (Darwin) 4/8 | |
85  |--------------------------------------------| | stack |
86  | Reserved 2*4/8 | | grows |
87  |--------------------------------------------| | down V
88  | Space for callee's LR 4/8 | |
89  |--------------------------------------------| | lower addresses
90  | Saved CR [low word for m64] 4/8 | |
91  |--------------------------------------------| | stack pointer here
92  | Current backchain pointer 4/8 |-/ during
93  |--------------------------------------------| <<< ffi_call_DARWIN
94 
95  */
96 
97 #if defined(POWERPC_DARWIN64)
98 static void
99 darwin64_pass_struct_by_value
100  (ffi_type *, char *, unsigned, unsigned *, double **, unsigned long **);
101 #endif
102 
103 /* This depends on GPR_SIZE = sizeof (unsigned long) */
104 
105 void
106 ffi_prep_args (extended_cif *ecif, unsigned long *const stack)
107 {
108  const unsigned bytes = ecif->cif->bytes;
109  const unsigned flags = ecif->cif->flags;
110  const unsigned nargs = ecif->cif->nargs;
111 #if !defined(POWERPC_DARWIN64)
112  const ffi_abi abi = ecif->cif->abi;
113 #endif
114 
115  /* 'stacktop' points at the previous backchain pointer. */
116  unsigned long *const stacktop = stack + (bytes / sizeof(unsigned long));
117 
118  /* 'fpr_base' points at the space for fpr1, and grows upwards as
119  we use FPR registers. */
120  double *fpr_base = (double *) (stacktop - ASM_NEEDS_REGISTERS) - NUM_FPR_ARG_REGISTERS;
121  int gp_count = 0, fparg_count = 0;
122 
123  /* 'next_arg' grows up as we put parameters in it. */
124  unsigned long *next_arg = stack + LINKAGE_AREA_GPRS; /* 6 reserved positions. */
125 
126  int i;
127  double double_tmp;
128  void **p_argv = ecif->avalue;
129  unsigned long gprvalue;
130  ffi_type** ptr = ecif->cif->arg_types;
131 #if !defined(POWERPC_DARWIN64)
132  char *dest_cpy;
133 #endif
134  unsigned size_al = 0;
135 
136  /* Check that everything starts aligned properly. */
137  FFI_ASSERT(((unsigned) (char *) stack & 0xF) == 0);
138  FFI_ASSERT(((unsigned) (char *) stacktop & 0xF) == 0);
139  FFI_ASSERT((bytes & 0xF) == 0);
140 
141  /* Deal with return values that are actually pass-by-reference.
142  Rule:
143  Return values are referenced by r3, so r4 is the first parameter. */
144 
145  if (flags & FLAG_RETVAL_REFERENCE)
146  *next_arg++ = (unsigned long) (char *) ecif->rvalue;
147 
148  /* Now for the arguments. */
149  for (i = nargs; i > 0; i--, ptr++, p_argv++)
150  {
151  switch ((*ptr)->type)
152  {
153  /* If a floating-point parameter appears before all of the general-
154  purpose registers are filled, the corresponding GPRs that match
155  the size of the floating-point parameter are skipped. */
156  case FFI_TYPE_FLOAT:
157  double_tmp = *(float *) *p_argv;
158  if (fparg_count < NUM_FPR_ARG_REGISTERS)
159  *fpr_base++ = double_tmp;
160 #if defined(POWERPC_DARWIN)
161  *(float *)next_arg = *(float *) *p_argv;
162 #else
163  *(double *)next_arg = double_tmp;
164 #endif
165  next_arg++;
166  gp_count++;
167  fparg_count++;
168  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
169  break;
170 
171  case FFI_TYPE_DOUBLE:
172  double_tmp = *(double *) *p_argv;
173  if (fparg_count < NUM_FPR_ARG_REGISTERS)
174  *fpr_base++ = double_tmp;
175  *(double *)next_arg = double_tmp;
176 #ifdef POWERPC64
177  next_arg++;
178  gp_count++;
179 #else
180  next_arg += 2;
181  gp_count += 2;
182 #endif
183  fparg_count++;
184  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
185  break;
186 
187 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
188 
189  case FFI_TYPE_LONGDOUBLE:
190 # if defined(POWERPC64) && !defined(POWERPC_DARWIN64)
191  /* ??? This will exceed the regs count when the value starts at fp13
192  and it will not put the extra bit on the stack. */
193  if (fparg_count < NUM_FPR_ARG_REGISTERS)
194  *(long double *) fpr_base++ = *(long double *) *p_argv;
195  else
196  *(long double *) next_arg = *(long double *) *p_argv;
197  next_arg += 2;
198  fparg_count += 2;
199 # else
200  double_tmp = ((double *) *p_argv)[0];
201  if (fparg_count < NUM_FPR_ARG_REGISTERS)
202  *fpr_base++ = double_tmp;
203  *(double *) next_arg = double_tmp;
204 # if defined(POWERPC_DARWIN64)
205  next_arg++;
206  gp_count++;
207 # else
208  next_arg += 2;
209  gp_count += 2;
210 # endif
211  fparg_count++;
212  double_tmp = ((double *) *p_argv)[1];
213  if (fparg_count < NUM_FPR_ARG_REGISTERS)
214  *fpr_base++ = double_tmp;
215  *(double *) next_arg = double_tmp;
216 # if defined(POWERPC_DARWIN64)
217  next_arg++;
218  gp_count++;
219 # else
220  next_arg += 2;
221  gp_count += 2;
222 # endif
223  fparg_count++;
224 # endif
225  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
226  break;
227 #endif
228  case FFI_TYPE_UINT64:
229  case FFI_TYPE_SINT64:
230 #ifdef POWERPC64
231  gprvalue = *(long long *) *p_argv;
232  goto putgpr;
233 #else
234  *(long long *) next_arg = *(long long *) *p_argv;
235  next_arg += 2;
236  gp_count += 2;
237 #endif
238  break;
239  case FFI_TYPE_POINTER:
240  gprvalue = *(unsigned long *) *p_argv;
241  goto putgpr;
242  case FFI_TYPE_UINT8:
243  gprvalue = *(unsigned char *) *p_argv;
244  goto putgpr;
245  case FFI_TYPE_SINT8:
246  gprvalue = *(signed char *) *p_argv;
247  goto putgpr;
248  case FFI_TYPE_UINT16:
249  gprvalue = *(unsigned short *) *p_argv;
250  goto putgpr;
251  case FFI_TYPE_SINT16:
252  gprvalue = *(signed short *) *p_argv;
253  goto putgpr;
254 
255  case FFI_TYPE_STRUCT:
256  size_al = (*ptr)->size;
257 #if defined(POWERPC_DARWIN64)
258  next_arg = (unsigned long *)ALIGN((char *)next_arg, (*ptr)->alignment);
259  darwin64_pass_struct_by_value (*ptr, (char *) *p_argv,
260  (unsigned) size_al,
261  (unsigned int *) &fparg_count,
262  &fpr_base, &next_arg);
263 #else
264  dest_cpy = (char *) next_arg;
265 
266  /* If the first member of the struct is a double, then include enough
267  padding in the struct size to align it to double-word. */
268  if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
269  size_al = ALIGN((*ptr)->size, 8);
270 
271 # if defined(POWERPC64)
272  FFI_ASSERT (abi != FFI_DARWIN);
273  memcpy ((char *) dest_cpy, (char *) *p_argv, size_al);
274  next_arg += (size_al + 7) / 8;
275 # else
276  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
277  SI 4 bytes) are aligned as if they were those modes.
278  Structures with 3 byte in size are padded upwards. */
279  if (size_al < 3 && abi == FFI_DARWIN)
280  dest_cpy += 4 - size_al;
281 
282  memcpy((char *) dest_cpy, (char *) *p_argv, size_al);
283  next_arg += (size_al + 3) / 4;
284 # endif
285 #endif
286  break;
287 
288  case FFI_TYPE_INT:
289  case FFI_TYPE_SINT32:
290  gprvalue = *(signed int *) *p_argv;
291  goto putgpr;
292 
293  case FFI_TYPE_UINT32:
294  gprvalue = *(unsigned int *) *p_argv;
295  putgpr:
296  *next_arg++ = gprvalue;
297  gp_count++;
298  break;
299  default:
300  break;
301  }
302  }
303 
304  /* Check that we didn't overrun the stack... */
305  /* FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
306  FFI_ASSERT((unsigned *)fpr_base
307  <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
308  FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4); */
309 }
310 
311 #if defined(POWERPC_DARWIN64)
312 
313 /* See if we can put some of the struct into fprs.
314  This should not be called for structures of size 16 bytes, since these are not
315  broken out this way. */
316 static void
317 darwin64_scan_struct_for_floats (ffi_type *s, unsigned *nfpr)
318 {
319  int i;
320 
321  FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
322 
323  for (i = 0; s->elements[i] != NULL; i++)
324  {
325  ffi_type *p = s->elements[i];
326  switch (p->type)
327  {
328  case FFI_TYPE_STRUCT:
329  darwin64_scan_struct_for_floats (p, nfpr);
330  break;
331  case FFI_TYPE_LONGDOUBLE:
332  (*nfpr) += 2;
333  break;
334  case FFI_TYPE_DOUBLE:
335  case FFI_TYPE_FLOAT:
336  (*nfpr) += 1;
337  break;
338  default:
339  break;
340  }
341  }
342 }
343 
344 static int
345 darwin64_struct_size_exceeds_gprs_p (ffi_type *s, char *src, unsigned *nfpr)
346 {
347  unsigned struct_offset=0, i;
348 
349  for (i = 0; s->elements[i] != NULL; i++)
350  {
351  char *item_base;
352  ffi_type *p = s->elements[i];
353  /* Find the start of this item (0 for the first one). */
354  if (i > 0)
355  struct_offset = ALIGN(struct_offset, p->alignment);
356 
357  item_base = src + struct_offset;
358 
359  switch (p->type)
360  {
361  case FFI_TYPE_STRUCT:
362  if (darwin64_struct_size_exceeds_gprs_p (p, item_base, nfpr))
363  return 1;
364  break;
365  case FFI_TYPE_LONGDOUBLE:
366  if (*nfpr >= NUM_FPR_ARG_REGISTERS)
367  return 1;
368  (*nfpr) += 1;
369  item_base += 8;
370  /* FALL THROUGH */
371  case FFI_TYPE_DOUBLE:
372  if (*nfpr >= NUM_FPR_ARG_REGISTERS)
373  return 1;
374  (*nfpr) += 1;
375  break;
376  case FFI_TYPE_FLOAT:
377  if (*nfpr >= NUM_FPR_ARG_REGISTERS)
378  return 1;
379  (*nfpr) += 1;
380  break;
381  default:
382  /* If we try and place any item, that is non-float, once we've
383  exceeded the 8 GPR mark, then we can't fit the struct. */
384  if ((unsigned long)item_base >= 8*8)
385  return 1;
386  break;
387  }
388  /* now count the size of what we just used. */
389  struct_offset += p->size;
390  }
391  return 0;
392 }
393 
394 /* Can this struct be returned by value? */
395 int
396 darwin64_struct_ret_by_value_p (ffi_type *s)
397 {
398  unsigned nfp = 0;
399 
400  FFI_ASSERT (s && s->type == FFI_TYPE_STRUCT);
401 
402  /* The largest structure we can return is 8long + 13 doubles. */
403  if (s->size > 168)
404  return 0;
405 
406  /* We can't pass more than 13 floats. */
407  darwin64_scan_struct_for_floats (s, &nfp);
408  if (nfp > 13)
409  return 0;
410 
411  /* If there are not too many floats, and the struct is
412  small enough to accommodate in the GPRs, then it must be OK. */
413  if (s->size <= 64)
414  return 1;
415 
416  /* Well, we have to look harder. */
417  nfp = 0;
418  if (darwin64_struct_size_exceeds_gprs_p (s, NULL, &nfp))
419  return 0;
420 
421  return 1;
422 }
423 
424 void
425 darwin64_pass_struct_floats (ffi_type *s, char *src,
426  unsigned *nfpr, double **fprs)
427 {
428  int i;
429  double *fpr_base = *fprs;
430  unsigned struct_offset = 0;
431 
432  /* We don't assume anything about the alignment of the source. */
433  for (i = 0; s->elements[i] != NULL; i++)
434  {
435  char *item_base;
436  ffi_type *p = s->elements[i];
437  /* Find the start of this item (0 for the first one). */
438  if (i > 0)
439  struct_offset = ALIGN(struct_offset, p->alignment);
440  item_base = src + struct_offset;
441 
442  switch (p->type)
443  {
444  case FFI_TYPE_STRUCT:
445  darwin64_pass_struct_floats (p, item_base, nfpr,
446  &fpr_base);
447  break;
448  case FFI_TYPE_LONGDOUBLE:
449  if (*nfpr < NUM_FPR_ARG_REGISTERS)
450  *fpr_base++ = *(double *)item_base;
451  (*nfpr) += 1;
452  item_base += 8;
453  /* FALL THROUGH */
454  case FFI_TYPE_DOUBLE:
455  if (*nfpr < NUM_FPR_ARG_REGISTERS)
456  *fpr_base++ = *(double *)item_base;
457  (*nfpr) += 1;
458  break;
459  case FFI_TYPE_FLOAT:
460  if (*nfpr < NUM_FPR_ARG_REGISTERS)
461  *fpr_base++ = (double) *(float *)item_base;
462  (*nfpr) += 1;
463  break;
464  default:
465  break;
466  }
467  /* now count the size of what we just used. */
468  struct_offset += p->size;
469  }
470  /* Update the scores. */
471  *fprs = fpr_base;
472 }
473 
474 /* Darwin64 special rules.
475  Break out a struct into params and float registers. */
476 static void
477 darwin64_pass_struct_by_value (ffi_type *s, char *src, unsigned size,
478  unsigned *nfpr, double **fprs, unsigned long **arg)
479 {
480  unsigned long *next_arg = *arg;
481  char *dest_cpy = (char *)next_arg;
482 
483  FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
484 
485  if (!size)
486  return;
487 
488  /* First... special cases. */
489  if (size < 3
490  || (size == 4
491  && s->elements[0]
492  && s->elements[0]->type != FFI_TYPE_FLOAT))
493  {
494  /* Must be at least one GPR, padding is unspecified in value,
495  let's make it zero. */
496  *next_arg = 0UL;
497  dest_cpy += 8 - size;
498  memcpy ((char *) dest_cpy, src, size);
499  next_arg++;
500  }
501  else if (size == 16)
502  {
503  memcpy ((char *) dest_cpy, src, size);
504  next_arg += 2;
505  }
506  else
507  {
508  /* now the general case, we consider embedded floats. */
509  memcpy ((char *) dest_cpy, src, size);
510  darwin64_pass_struct_floats (s, src, nfpr, fprs);
511  next_arg += (size+7)/8;
512  }
513 
514  *arg = next_arg;
515 }
516 
517 double *
518 darwin64_struct_floats_to_mem (ffi_type *s, char *dest, double *fprs, unsigned *nf)
519 {
520  int i;
521  unsigned struct_offset = 0;
522 
523  /* We don't assume anything about the alignment of the source. */
524  for (i = 0; s->elements[i] != NULL; i++)
525  {
526  char *item_base;
527  ffi_type *p = s->elements[i];
528  /* Find the start of this item (0 for the first one). */
529  if (i > 0)
530  struct_offset = ALIGN(struct_offset, p->alignment);
531  item_base = dest + struct_offset;
532 
533  switch (p->type)
534  {
535  case FFI_TYPE_STRUCT:
536  fprs = darwin64_struct_floats_to_mem (p, item_base, fprs, nf);
537  break;
538  case FFI_TYPE_LONGDOUBLE:
539  if (*nf < NUM_FPR_ARG_REGISTERS)
540  {
541  *(double *)item_base = *fprs++ ;
542  (*nf) += 1;
543  }
544  item_base += 8;
545  /* FALL THROUGH */
546  case FFI_TYPE_DOUBLE:
547  if (*nf < NUM_FPR_ARG_REGISTERS)
548  {
549  *(double *)item_base = *fprs++ ;
550  (*nf) += 1;
551  }
552  break;
553  case FFI_TYPE_FLOAT:
554  if (*nf < NUM_FPR_ARG_REGISTERS)
555  {
556  *(float *)item_base = (float) *fprs++ ;
557  (*nf) += 1;
558  }
559  break;
560  default:
561  break;
562  }
563  /* now count the size of what we just used. */
564  struct_offset += p->size;
565  }
566  return fprs;
567 }
568 
569 #endif
570 
571 /* Adjust the size of S to be correct for Darwin.
572  On Darwin m32, the first field of a structure has natural alignment.
573  On Darwin m64, all fields have natural alignment. */
574 
575 static void
576 darwin_adjust_aggregate_sizes (ffi_type *s)
577 {
578  int i;
579 
580  if (s->type != FFI_TYPE_STRUCT)
581  return;
582 
583  s->size = 0;
584  for (i = 0; s->elements[i] != NULL; i++)
585  {
586  ffi_type *p;
587  int align;
588 
589  p = s->elements[i];
590  if (p->type == FFI_TYPE_STRUCT)
591  darwin_adjust_aggregate_sizes (p);
592 #if defined(POWERPC_DARWIN64)
593  /* Natural alignment for all items. */
594  align = p->alignment;
595 #else
596  /* Natural alignment for the first item... */
597  if (i == 0)
598  align = p->alignment;
599  else if (p->alignment == 16 || p->alignment < 4)
600  /* .. subsequent items with vector or align < 4 have natural align. */
601  align = p->alignment;
602  else
603  /* .. or align is 4. */
604  align = 4;
605 #endif
606  /* Pad, if necessary, before adding the current item. */
607  s->size = ALIGN(s->size, align) + p->size;
608  }
609 
610  s->size = ALIGN(s->size, s->alignment);
611 
612  /* This should not be necessary on m64, but harmless. */
613  if (s->elements[0]->type == FFI_TYPE_UINT64
614  || s->elements[0]->type == FFI_TYPE_SINT64
615  || s->elements[0]->type == FFI_TYPE_DOUBLE
616  || s->elements[0]->alignment == 8)
617  s->alignment = s->alignment > 8 ? s->alignment : 8;
618  /* Do not add additional tail padding. */
619 }
620 
621 /* Adjust the size of S to be correct for AIX.
622  Word-align double unless it is the first member of a structure. */
623 
624 static void
625 aix_adjust_aggregate_sizes (ffi_type *s)
626 {
627  int i;
628 
629  if (s->type != FFI_TYPE_STRUCT)
630  return;
631 
632  s->size = 0;
633  for (i = 0; s->elements[i] != NULL; i++)
634  {
635  ffi_type *p;
636  int align;
637 
638  p = s->elements[i];
639  aix_adjust_aggregate_sizes (p);
640  align = p->alignment;
641  if (i != 0 && p->type == FFI_TYPE_DOUBLE)
642  align = 4;
643  s->size = ALIGN(s->size, align) + p->size;
644  }
645 
646  s->size = ALIGN(s->size, s->alignment);
647 
648  if (s->elements[0]->type == FFI_TYPE_UINT64
649  || s->elements[0]->type == FFI_TYPE_SINT64
650  || s->elements[0]->type == FFI_TYPE_DOUBLE
651  || s->elements[0]->alignment == 8)
652  s->alignment = s->alignment > 8 ? s->alignment : 8;
653  /* Do not add additional tail padding. */
654 }
655 
656 /* Perform machine dependent cif processing. */
657 ffi_status
658 ffi_prep_cif_machdep (ffi_cif *cif)
659 {
660  /* All this is for the DARWIN ABI. */
661  unsigned i;
662  ffi_type **ptr;
663  unsigned bytes;
664  unsigned fparg_count = 0, intarg_count = 0;
665  unsigned flags = 0;
666  unsigned size_al = 0;
667 
668  /* All the machine-independent calculation of cif->bytes will be wrong.
669  All the calculation of structure sizes will also be wrong.
670  Redo the calculation for DARWIN. */
671 
672  if (cif->abi == FFI_DARWIN)
673  {
674  darwin_adjust_aggregate_sizes (cif->rtype);
675  for (i = 0; i < cif->nargs; i++)
676  darwin_adjust_aggregate_sizes (cif->arg_types[i]);
677  }
678 
679  if (cif->abi == FFI_AIX)
680  {
681  aix_adjust_aggregate_sizes (cif->rtype);
682  for (i = 0; i < cif->nargs; i++)
683  aix_adjust_aggregate_sizes (cif->arg_types[i]);
684  }
685 
686  /* Space for the frame pointer, callee's LR, CR, etc, and for
687  the asm's temp regs. */
688 
689  bytes = (LINKAGE_AREA_GPRS + ASM_NEEDS_REGISTERS) * sizeof(unsigned long);
690 
691  /* Return value handling.
692  The rules m32 are as follows:
693  - 32-bit (or less) integer values are returned in gpr3;
694  - structures of size <= 4 bytes also returned in gpr3;
695  - 64-bit integer values [??? and structures between 5 and 8 bytes] are
696  returned in gpr3 and gpr4;
697  - Single/double FP values are returned in fpr1;
698  - Long double FP (if not equivalent to double) values are returned in
699  fpr1 and fpr2;
700  m64:
701  - 64-bit or smaller integral values are returned in GPR3
702  - Single/double FP values are returned in fpr1;
703  - Long double FP values are returned in fpr1 and fpr2;
704  m64 Structures:
705  - If the structure could be accommodated in registers were it to be the
706  first argument to a routine, then it is returned in those registers.
707  m32/m64 structures otherwise:
708  - Larger structures values are allocated space and a pointer is passed
709  as the first argument. */
710  switch (cif->rtype->type)
711  {
712 
713 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
714  case FFI_TYPE_LONGDOUBLE:
715  flags |= FLAG_RETURNS_128BITS;
716  flags |= FLAG_RETURNS_FP;
717  break;
718 #endif
719 
720  case FFI_TYPE_DOUBLE:
721  flags |= FLAG_RETURNS_64BITS;
722  /* Fall through. */
723  case FFI_TYPE_FLOAT:
724  flags |= FLAG_RETURNS_FP;
725  break;
726 
727  case FFI_TYPE_UINT64:
728  case FFI_TYPE_SINT64:
729 #ifdef POWERPC64
730  case FFI_TYPE_POINTER:
731 #endif
732  flags |= FLAG_RETURNS_64BITS;
733  break;
734 
735  case FFI_TYPE_STRUCT:
736 #if defined(POWERPC_DARWIN64)
737  {
738  /* Can we fit the struct into regs? */
739  if (darwin64_struct_ret_by_value_p (cif->rtype))
740  {
741  unsigned nfpr = 0;
742  flags |= FLAG_RETURNS_STRUCT;
743  if (cif->rtype->size != 16)
744  darwin64_scan_struct_for_floats (cif->rtype, &nfpr) ;
745  else
746  flags |= FLAG_RETURNS_128BITS;
747  /* Will be 0 for 16byte struct. */
748  if (nfpr)
749  flags |= FLAG_RETURNS_FP;
750  }
751  else /* By ref. */
752  {
753  flags |= FLAG_RETVAL_REFERENCE;
754  flags |= FLAG_RETURNS_NOTHING;
755  intarg_count++;
756  }
757  }
758 #elif defined(DARWIN_PPC)
759  if (cif->rtype->size <= 4)
760  flags |= FLAG_RETURNS_STRUCT;
761  else /* else by reference. */
762  {
763  flags |= FLAG_RETVAL_REFERENCE;
764  flags |= FLAG_RETURNS_NOTHING;
765  intarg_count++;
766  }
767 #else /* assume we pass by ref. */
768  flags |= FLAG_RETVAL_REFERENCE;
769  flags |= FLAG_RETURNS_NOTHING;
770  intarg_count++;
771 #endif
772  break;
773  case FFI_TYPE_VOID:
774  flags |= FLAG_RETURNS_NOTHING;
775  break;
776 
777  default:
778  /* Returns 32-bit integer, or similar. Nothing to do here. */
779  break;
780  }
781 
782  /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
783  first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
784  goes on the stack.
785  ??? Structures are passed as a pointer to a copy of the structure.
786  Stuff on the stack needs to keep proper alignment.
787  For m64 the count is effectively of half-GPRs. */
788  for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
789  {
790  unsigned align_words;
791  switch ((*ptr)->type)
792  {
793  case FFI_TYPE_FLOAT:
794  case FFI_TYPE_DOUBLE:
795  fparg_count++;
796 #if !defined(POWERPC_DARWIN64)
797  /* If this FP arg is going on the stack, it must be
798  8-byte-aligned. */
799  if (fparg_count > NUM_FPR_ARG_REGISTERS
800  && (intarg_count & 0x01) != 0)
801  intarg_count++;
802 #endif
803  break;
804 
805 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
806  case FFI_TYPE_LONGDOUBLE:
807  fparg_count += 2;
808  /* If this FP arg is going on the stack, it must be
809  16-byte-aligned. */
810  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
811 #if defined (POWERPC64)
812  intarg_count = ALIGN(intarg_count, 2);
813 #else
814  intarg_count = ALIGN(intarg_count, 4);
815 #endif
816  break;
817 #endif
818 
819  case FFI_TYPE_UINT64:
820  case FFI_TYPE_SINT64:
821 #if defined(POWERPC64)
822  intarg_count++;
823 #else
824  /* 'long long' arguments are passed as two words, but
825  either both words must fit in registers or both go
826  on the stack. If they go on the stack, they must
827  be 8-byte-aligned. */
828  if (intarg_count == NUM_GPR_ARG_REGISTERS-1
829  || (intarg_count >= NUM_GPR_ARG_REGISTERS
830  && (intarg_count & 0x01) != 0))
831  intarg_count++;
832  intarg_count += 2;
833 #endif
834  break;
835 
836  case FFI_TYPE_STRUCT:
837  size_al = (*ptr)->size;
838 #if defined(POWERPC_DARWIN64)
839  align_words = (*ptr)->alignment >> 3;
840  if (align_words)
841  intarg_count = ALIGN(intarg_count, align_words);
842  /* Base size of the struct. */
843  intarg_count += (size_al + 7) / 8;
844  /* If 16 bytes then don't worry about floats. */
845  if (size_al != 16)
846  /* Scan through for floats to be placed in regs. */
847  darwin64_scan_struct_for_floats (*ptr, &fparg_count) ;
848 #else
849  align_words = (*ptr)->alignment >> 2;
850  if (align_words)
851  intarg_count = ALIGN(intarg_count, align_words);
852  /* If the first member of the struct is a double, then align
853  the struct to double-word.
854  if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
855  size_al = ALIGN((*ptr)->size, 8); */
856 # ifdef POWERPC64
857  intarg_count += (size_al + 7) / 8;
858 # else
859  intarg_count += (size_al + 3) / 4;
860 # endif
861 #endif
862  break;
863 
864  default:
865  /* Everything else is passed as a 4-byte word in a GPR, either
866  the object itself or a pointer to it. */
867  intarg_count++;
868  break;
869  }
870  }
871 
872  if (fparg_count != 0)
873  flags |= FLAG_FP_ARGUMENTS;
874 
875 #if defined(POWERPC_DARWIN64)
876  /* Space to image the FPR registers, if needed - which includes when they might be
877  used in a struct return. */
878  if (fparg_count != 0
879  || ((flags & FLAG_RETURNS_STRUCT)
880  && (flags & FLAG_RETURNS_FP)))
881  bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
882 #else
883  /* Space for the FPR registers, if needed. */
884  if (fparg_count != 0)
885  bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
886 #endif
887 
888  /* Stack space. */
889 #ifdef POWERPC64
890  if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
891  bytes += (intarg_count + fparg_count) * sizeof(long);
892 #else
893  if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
894  bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
895 #endif
896  else
897  bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
898 
899  /* The stack space allocated needs to be a multiple of 16 bytes. */
900  bytes = ALIGN(bytes, 16) ;
901 
902  cif->flags = flags;
903  cif->bytes = bytes;
904 
905  return FFI_OK;
906 }
907 
908 extern void ffi_call_AIX(extended_cif *, long, unsigned, unsigned *,
909  void (*fn)(void), void (*fn2)(void));
910 
911 extern void ffi_call_DARWIN(extended_cif *, long, unsigned, unsigned *,
912  void (*fn)(void), void (*fn2)(void), ffi_type*);
913 
914 void
915 ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
916 {
917  extended_cif ecif;
918 
919  ecif.cif = cif;
920  ecif.avalue = avalue;
921 
922  /* If the return value is a struct and we don't have a return
923  value address then we need to make one. */
924 
925  if ((rvalue == NULL) &&
926  (cif->rtype->type == FFI_TYPE_STRUCT))
927  {
928  ecif.rvalue = alloca (cif->rtype->size);
929  }
930  else
931  ecif.rvalue = rvalue;
932 
933  switch (cif->abi)
934  {
935  case FFI_AIX:
936  ffi_call_AIX(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
937  FFI_FN(ffi_prep_args));
938  break;
939  case FFI_DARWIN:
940  ffi_call_DARWIN(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
941  FFI_FN(ffi_prep_args), cif->rtype);
942  break;
943  default:
944  FFI_ASSERT(0);
945  break;
946  }
947 }
948 
949 static void flush_icache(char *);
950 static void flush_range(char *, int);
951 
952 /* The layout of a function descriptor. A C function pointer really
953  points to one of these. */
954 
955 typedef struct aix_fd_struct {
957  void *toc;
958 } aix_fd;
959 
960 /* here I'd like to add the stack frame layout we use in darwin_closure.S
961  and aix_closure.S
962 
963  m32/m64
964 
965  The stack layout looks like this:
966 
967  | Additional params... | | Higher address
968  ~ ~ ~
969  | Parameters (at least 8*4/8=32/64) | | NUM_GPR_ARG_REGISTERS
970  |--------------------------------------------| |
971  | TOC=R2 (AIX) Reserved (Darwin) 4/8 | |
972  |--------------------------------------------| |
973  | Reserved 2*4/8 | |
974  |--------------------------------------------| |
975  | Space for callee's LR 4/8 | |
976  |--------------------------------------------| |
977  | Saved CR [low word for m64] 4/8 | |
978  |--------------------------------------------| |
979  | Current backchain pointer 4/8 |-/ Parent's frame.
980  |--------------------------------------------| <+ <<< on entry to ffi_closure_ASM
981  | Result Bytes 16 | |
982  |--------------------------------------------| |
983  ~ padding to 16-byte alignment ~ ~
984  |--------------------------------------------| |
985  | NUM_FPR_ARG_REGISTERS slots | |
986  | here fp13 .. fp1 13*8 | |
987  |--------------------------------------------| |
988  | R3..R10 8*4/8=32/64 | | NUM_GPR_ARG_REGISTERS
989  |--------------------------------------------| |
990  | TOC=R2 (AIX) Reserved (Darwin) 4/8 | |
991  |--------------------------------------------| | stack |
992  | Reserved [compiler,binder] 2*4/8 | | grows |
993  |--------------------------------------------| | down V
994  | Space for callee's LR 4/8 | |
995  |--------------------------------------------| | lower addresses
996  | Saved CR [low word for m64] 4/8 | |
997  |--------------------------------------------| | stack pointer here
998  | Current backchain pointer 4/8 |-/ during
999  |--------------------------------------------| <<< ffi_closure_ASM.
1000 
1001 */
1002 
1003 ffi_status
1004 ffi_prep_closure_loc (ffi_closure* closure,
1005  ffi_cif* cif,
1006  void (*fun)(ffi_cif*, void*, void**, void*),
1007  void *user_data,
1008  void *codeloc)
1009 {
1010  unsigned int *tramp;
1011  struct ffi_aix_trampoline_struct *tramp_aix;
1012  aix_fd *fd;
1013 
1014  switch (cif->abi)
1015  {
1016  case FFI_DARWIN:
1017 
1018  FFI_ASSERT (cif->abi == FFI_DARWIN);
1019 
1020  tramp = (unsigned int *) &closure->tramp[0];
1021 #if defined(POWERPC_DARWIN64)
1022  tramp[0] = 0x7c0802a6; /* mflr r0 */
1023  tramp[1] = 0x429f0015; /* bcl- 20,4*cr7+so, +0x18 (L1) */
1024  /* We put the addresses here. */
1025  tramp[6] = 0x7d6802a6; /*L1: mflr r11 */
1026  tramp[7] = 0xe98b0000; /* ld r12,0(r11) function address */
1027  tramp[8] = 0x7c0803a6; /* mtlr r0 */
1028  tramp[9] = 0x7d8903a6; /* mtctr r12 */
1029  tramp[10] = 0xe96b0008; /* lwz r11,8(r11) static chain */
1030  tramp[11] = 0x4e800420; /* bctr */
1031 
1032  *((unsigned long *)&tramp[2]) = (unsigned long) ffi_closure_ASM; /* function */
1033  *((unsigned long *)&tramp[4]) = (unsigned long) codeloc; /* context */
1034 #else
1035  tramp[0] = 0x7c0802a6; /* mflr r0 */
1036  tramp[1] = 0x429f000d; /* bcl- 20,4*cr7+so,0x10 */
1037  tramp[4] = 0x7d6802a6; /* mflr r11 */
1038  tramp[5] = 0x818b0000; /* lwz r12,0(r11) function address */
1039  tramp[6] = 0x7c0803a6; /* mtlr r0 */
1040  tramp[7] = 0x7d8903a6; /* mtctr r12 */
1041  tramp[8] = 0x816b0004; /* lwz r11,4(r11) static chain */
1042  tramp[9] = 0x4e800420; /* bctr */
1043  tramp[2] = (unsigned long) ffi_closure_ASM; /* function */
1044  tramp[3] = (unsigned long) codeloc; /* context */
1045 #endif
1046  closure->cif = cif;
1047  closure->fun = fun;
1048  closure->user_data = user_data;
1049 
1050  /* Flush the icache. Only necessary on Darwin. */
1051  flush_range(codeloc, FFI_TRAMPOLINE_SIZE);
1052 
1053  break;
1054 
1055  case FFI_AIX:
1056 
1057  tramp_aix = (struct ffi_aix_trampoline_struct *) (closure->tramp);
1058  fd = (aix_fd *)(void *)ffi_closure_ASM;
1059 
1060  FFI_ASSERT (cif->abi == FFI_AIX);
1061 
1062  tramp_aix->code_pointer = fd->code_pointer;
1063  tramp_aix->toc = fd->toc;
1064  tramp_aix->static_chain = codeloc;
1065  closure->cif = cif;
1066  closure->fun = fun;
1067  closure->user_data = user_data;
1068  break;
1069 
1070  default:
1071  return FFI_BAD_ABI;
1072  break;
1073  }
1074  return FFI_OK;
1075 }
1076 
1077 static void
1078 flush_icache(char *addr)
1079 {
1080 #ifndef _AIX
1081  __asm__ volatile (
1082  "dcbf 0,%0\n"
1083  "\tsync\n"
1084  "\ticbi 0,%0\n"
1085  "\tsync\n"
1086  "\tisync"
1087  : : "r"(addr) : "memory");
1088 #endif
1089 }
1090 
1091 static void
1092 flush_range(char * addr1, int size)
1093 {
1094 #define MIN_LINE_SIZE 32
1095  int i;
1096  for (i = 0; i < size; i += MIN_LINE_SIZE)
1097  flush_icache(addr1+i);
1098  flush_icache(addr1+size-1);
1099 }
1100 
1101 typedef union
1102 {
1103  float f;
1104  double d;
1105 } ffi_dblfl;
1106 
1107 ffi_type *
1108 ffi_closure_helper_DARWIN (ffi_closure *, void *,
1109  unsigned long *, ffi_dblfl *);
1110 
1111 /* Basically the trampoline invokes ffi_closure_ASM, and on
1112  entry, r11 holds the address of the closure.
1113  After storing the registers that could possibly contain
1114  parameters to be passed into the stack frame and setting
1115  up space for a return value, ffi_closure_ASM invokes the
1116  following helper function to do most of the work. */
1117 
1118 ffi_type *
1119 ffi_closure_helper_DARWIN (ffi_closure *closure, void *rvalue,
1120  unsigned long *pgr, ffi_dblfl *pfr)
1121 {
1122  /* rvalue is the pointer to space for return value in closure assembly
1123  pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
1124  pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM. */
1125 
1126  typedef double ldbits[2];
1127 
1128  union ldu
1129  {
1130  ldbits lb;
1131  long double ld;
1132  };
1133 
1134  void ** avalue;
1135  ffi_type ** arg_types;
1136  long i, avn;
1137  ffi_cif * cif;
1138  ffi_dblfl * end_pfr = pfr + NUM_FPR_ARG_REGISTERS;
1139  unsigned size_al;
1140 #if defined(POWERPC_DARWIN64)
1141  unsigned fpsused = 0;
1142 #endif
1143 
1144  cif = closure->cif;
1145  avalue = alloca (cif->nargs * sizeof(void *));
1146 
1147  if (cif->rtype->type == FFI_TYPE_STRUCT)
1148  {
1149 #if defined(POWERPC_DARWIN64)
1150  if (!darwin64_struct_ret_by_value_p (cif->rtype))
1151  {
1152  /* Won't fit into the regs - return by ref. */
1153  rvalue = (void *) *pgr;
1154  pgr++;
1155  }
1156 #elif defined(DARWIN_PPC)
1157  if (cif->rtype->size > 4)
1158  {
1159  rvalue = (void *) *pgr;
1160  pgr++;
1161  }
1162 #else /* assume we return by ref. */
1163  rvalue = (void *) *pgr;
1164  pgr++;
1165 #endif
1166  }
1167 
1168  i = 0;
1169  avn = cif->nargs;
1170  arg_types = cif->arg_types;
1171 
1172  /* Grab the addresses of the arguments from the stack frame. */
1173  while (i < avn)
1174  {
1175  switch (arg_types[i]->type)
1176  {
1177  case FFI_TYPE_SINT8:
1178  case FFI_TYPE_UINT8:
1179 #if defined(POWERPC64)
1180  avalue[i] = (char *) pgr + 7;
1181 #else
1182  avalue[i] = (char *) pgr + 3;
1183 #endif
1184  pgr++;
1185  break;
1186 
1187  case FFI_TYPE_SINT16:
1188  case FFI_TYPE_UINT16:
1189 #if defined(POWERPC64)
1190  avalue[i] = (char *) pgr + 6;
1191 #else
1192  avalue[i] = (char *) pgr + 2;
1193 #endif
1194  pgr++;
1195  break;
1196 
1197  case FFI_TYPE_SINT32:
1198  case FFI_TYPE_UINT32:
1199 #if defined(POWERPC64)
1200  avalue[i] = (char *) pgr + 4;
1201 #else
1202  case FFI_TYPE_POINTER:
1203  avalue[i] = pgr;
1204 #endif
1205  pgr++;
1206  break;
1207 
1208  case FFI_TYPE_STRUCT:
1209  size_al = arg_types[i]->size;
1210 #if defined(POWERPC_DARWIN64)
1211  pgr = (unsigned long *)ALIGN((char *)pgr, arg_types[i]->alignment);
1212  if (size_al < 3 || size_al == 4)
1213  {
1214  avalue[i] = ((char *)pgr)+8-size_al;
1215  if (arg_types[i]->elements[0]->type == FFI_TYPE_FLOAT
1216  && fpsused < NUM_FPR_ARG_REGISTERS)
1217  {
1218  *(float *)pgr = (float) *(double *)pfr;
1219  pfr++;
1220  fpsused++;
1221  }
1222  }
1223  else
1224  {
1225  if (size_al != 16)
1226  pfr = (ffi_dblfl *)
1227  darwin64_struct_floats_to_mem (arg_types[i], (char *)pgr,
1228  (double *)pfr, &fpsused);
1229  avalue[i] = pgr;
1230  }
1231  pgr += (size_al + 7) / 8;
1232 #else
1233  /* If the first member of the struct is a double, then align
1234  the struct to double-word. */
1235  if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
1236  size_al = ALIGN(arg_types[i]->size, 8);
1237 # if defined(POWERPC64)
1238  FFI_ASSERT (cif->abi != FFI_DARWIN);
1239  avalue[i] = pgr;
1240  pgr += (size_al + 7) / 8;
1241 # else
1242  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
1243  SI 4 bytes) are aligned as if they were those modes. */
1244  if (size_al < 3 && cif->abi == FFI_DARWIN)
1245  avalue[i] = (char*) pgr + 4 - size_al;
1246  else
1247  avalue[i] = pgr;
1248  pgr += (size_al + 3) / 4;
1249 # endif
1250 #endif
1251  break;
1252 
1253  case FFI_TYPE_SINT64:
1254  case FFI_TYPE_UINT64:
1255 #if defined(POWERPC64)
1256  case FFI_TYPE_POINTER:
1257  avalue[i] = pgr;
1258  pgr++;
1259  break;
1260 #else
1261  /* Long long ints are passed in two gpr's. */
1262  avalue[i] = pgr;
1263  pgr += 2;
1264  break;
1265 #endif
1266 
1267  case FFI_TYPE_FLOAT:
1268  /* A float value consumes a GPR.
1269  There are 13 64bit floating point registers. */
1270  if (pfr < end_pfr)
1271  {
1272  double temp = pfr->d;
1273  pfr->f = (float) temp;
1274  avalue[i] = pfr;
1275  pfr++;
1276  }
1277  else
1278  {
1279  avalue[i] = pgr;
1280  }
1281  pgr++;
1282  break;
1283 
1284  case FFI_TYPE_DOUBLE:
1285  /* A double value consumes two GPRs.
1286  There are 13 64bit floating point registers. */
1287  if (pfr < end_pfr)
1288  {
1289  avalue[i] = pfr;
1290  pfr++;
1291  }
1292  else
1293  {
1294  avalue[i] = pgr;
1295  }
1296 #ifdef POWERPC64
1297  pgr++;
1298 #else
1299  pgr += 2;
1300 #endif
1301  break;
1302 
1303 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
1304 
1305  case FFI_TYPE_LONGDOUBLE:
1306 #ifdef POWERPC64
1307  if (pfr + 1 < end_pfr)
1308  {
1309  avalue[i] = pfr;
1310  pfr += 2;
1311  }
1312  else
1313  {
1314  if (pfr < end_pfr)
1315  {
1316  *pgr = *(unsigned long *) pfr;
1317  pfr++;
1318  }
1319  avalue[i] = pgr;
1320  }
1321  pgr += 2;
1322 #else /* POWERPC64 */
1323  /* A long double value consumes four GPRs and two FPRs.
1324  There are 13 64bit floating point registers. */
1325  if (pfr + 1 < end_pfr)
1326  {
1327  avalue[i] = pfr;
1328  pfr += 2;
1329  }
1330  /* Here we have the situation where one part of the long double
1331  is stored in fpr13 and the other part is already on the stack.
1332  We use a union to pass the long double to avalue[i]. */
1333  else if (pfr + 1 == end_pfr)
1334  {
1335  union ldu temp_ld;
1336  memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
1337  memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
1338  avalue[i] = &temp_ld.ld;
1339  pfr++;
1340  }
1341  else
1342  {
1343  avalue[i] = pgr;
1344  }
1345  pgr += 4;
1346 #endif /* POWERPC64 */
1347  break;
1348 #endif
1349  default:
1350  FFI_ASSERT(0);
1351  }
1352  i++;
1353  }
1354 
1355  (closure->fun) (cif, rvalue, avalue, closure->user_data);
1356 
1357  /* Tell ffi_closure_ASM to perform return type promotions. */
1358  return cif->rtype;
1359 }
FFI_ASSERT
#define FFI_ASSERT(x)
Definition: ffi_common.h:72
ffi_dblfl::d
double d
Definition: ffi_darwin.c:1104
FFI_TYPE_LONGDOUBLE
#define FFI_TYPE_LONGDOUBLE
Definition: ffi.c:40
ffi_abi
ffi_abi
Definition: ffitarget.h:33
extended_cif::rvalue
void * rvalue
Definition: ffi_common.h:89
ffi_common.h
FFI_TRAMPOLINE_SIZE
#define FFI_TRAMPOLINE_SIZE
Definition: ffitarget.h:45
aix_fd_struct
Definition: ffi_darwin.c:955
FLAG_4_GPR_ARGUMENTS
@ FLAG_4_GPR_ARGUMENTS
Definition: ffi_darwin.c:52
ptr
struct RIMemo * ptr
Definition: debug.c:74
ffi_call_DARWIN
void ffi_call_DARWIN(extended_cif *, long, unsigned, unsigned *, void(*fn)(void), void(*fn2)(void), ffi_type *)
ALIGN
#define ALIGN(v, a)
Definition: ffi_common.h:77
NULL
#define NULL
Definition: _sdbm.c:101
FLAG_RETURNS_STRUCT
@ FLAG_RETURNS_STRUCT
Definition: ffi_darwin.c:48
ffi_dblfl::f
float f
Definition: ffi_darwin.c:1103
ffi_call_AIX
void ffi_call_AIX(extended_cif *, long, unsigned, unsigned *, void(*fn)(void), void(*fn2)(void))
memcpy
void * memcpy(void *__restrict, const void *__restrict, size_t)
double
double
Definition: rb_mjit_min_header-2.7.0.h:5923
ffi_prep_cif_machdep
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
Definition: ffi_darwin.c:658
FLAG_RETURNS_64BITS
@ FLAG_RETURNS_64BITS
Definition: ffi_darwin.c:46
i
uint32_t i
Definition: rb_mjit_min_header-2.7.0.h:5464
FLAG_RETVAL_REFERENCE
@ FLAG_RETVAL_REFERENCE
Definition: ffi_darwin.c:53
long
#define long
Definition: rb_mjit_min_header-2.7.0.h:2880
alloca
#define alloca(size)
Definition: rb_mjit_min_header-2.7.0.h:2487
ffi_prep_closure_loc
ffi_status ffi_prep_closure_loc(ffi_closure *closure, ffi_cif *cif, void(*fun)(ffi_cif *, void *, void **, void *), void *user_data, void *codeloc)
Definition: ffi_darwin.c:1004
aix_fd_struct::code_pointer
void * code_pointer
Definition: ffi_darwin.c:956
size
int size
Definition: encoding.c:58
extended_cif
Definition: ffi_common.h:86
ffi_closure_helper_DARWIN
ffi_type * ffi_closure_helper_DARWIN(ffi_closure *, void *, unsigned long *, ffi_dblfl *)
Definition: ffi_darwin.c:1119
src
__inline__ const void *__restrict src
Definition: rb_mjit_min_header-2.7.0.h:2836
NUM_FPR_ARG_REGISTERS
@ NUM_FPR_ARG_REGISTERS
Definition: ffi_darwin.c:59
arg
VALUE arg
Definition: rb_mjit_min_header-2.7.0.h:5601
extended_cif::avalue
void ** avalue
Definition: ffi_common.h:90
FLAG_RETURNS_NOTHING
@ FLAG_RETURNS_NOTHING
Definition: ffi_darwin.c:44
aix_fd_struct::toc
void * toc
Definition: ffi_darwin.c:957
aix_fd
struct aix_fd_struct aix_fd
ffi_call
void ffi_call(ffi_cif *cif, void(*fn)(void), void *rvalue, void **avalue)
Definition: ffi_darwin.c:915
__asm__
#define __asm__
Definition: Context.c:12
ffi_prep_args
void ffi_prep_args(extended_cif *ecif, unsigned long *const stack)
Definition: ffi_darwin.c:106
MIN_LINE_SIZE
#define MIN_LINE_SIZE
ffi_dblfl
Definition: ffi_darwin.c:1101
FLAG_RETURNS_FP
@ FLAG_RETURNS_FP
Definition: ffi_darwin.c:45
FLAG_RETURNS_128BITS
@ FLAG_RETURNS_128BITS
Definition: ffi_darwin.c:43
ASM_NEEDS_REGISTERS
@ ASM_NEEDS_REGISTERS
Definition: ffi_darwin.c:63
ffi_closure_ASM
void ffi_closure_ASM(void)
extended_cif::cif
ffi_cif * cif
Definition: ffi_common.h:88
LINKAGE_AREA_GPRS
@ LINKAGE_AREA_GPRS
Definition: ffi_darwin.c:60
FLAG_ARG_NEEDS_COPY
@ FLAG_ARG_NEEDS_COPY
Definition: ffi_darwin.c:50
ruby::backward::cxxanyargs::type
VALUE type(ANYARGS)
ANYARGS-ed function type.
Definition: cxxanyargs.hpp:39
FLAG_FP_ARGUMENTS
@ FLAG_FP_ARGUMENTS
Definition: ffi_darwin.c:51
NUM_GPR_ARG_REGISTERS
@ NUM_GPR_ARG_REGISTERS
Definition: ffi_darwin.c:58