diff -urp libffi-3.0.13/src/powerpc/ffi.c libffi-current/src/powerpc/ffi.c

--- libffi-3.0.13/src/powerpc/ffi.c	2013-03-16 22:46:20.000000000 +1030

+++ libffi-current/src/powerpc/ffi.c	2013-11-18 00:48:55.218044221 +1030

@@ -48,12 +48,8 @@ enum {

   FLAG_RETURNS_128BITS  = 1 << (31-27), /* cr6  */

-  FLAG_SYSV_SMST_R4     = 1 << (31-26), /* use r4 for FFI_SYSV 8 byte

-					   structs.  */

-  FLAG_SYSV_SMST_R3     = 1 << (31-25), /* use r3 for FFI_SYSV 4 byte

-					   structs.  */

-

   FLAG_ARG_NEEDS_COPY   = 1 << (31- 7),

+  FLAG_ARG_NEEDS_PSAVE  = FLAG_ARG_NEEDS_COPY, /* Used by ELFv2 */

 #ifndef __NO_FPRS__

   FLAG_FP_ARGUMENTS     = 1 << (31- 6), /* cr1.eq; specified by ABI */

 #endif

@@ -132,6 +128,9 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   int i;

   ffi_type **ptr;

+#ifndef __NO_FPRS__

+  double double_tmp;

+#endif

   union {

     void **v;

     char **c;

@@ -151,7 +150,6 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   gpr_base.u = stacktop.u - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS;

   intarg_count = 0;

 #ifndef __NO_FPRS__

-  double double_tmp;

   fpr_base.d = gpr_base.d - NUM_FPR_ARG_REGISTERS;

   fparg_count = 0;

   copy_space.c = ((flags & FLAG_FP_ARGUMENTS) ? fpr_base.c : gpr_base.c);

@@ -374,7 +372,7 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   FFI_ASSERT (gpr_base.u <= stacktop.u - ASM_NEEDS_REGISTERS);

   /* The assert below is testing that the number of integer arguments agrees

      with the number found in ffi_prep_cif_machdep().  However, intarg_count

-     is incremeneted whenever we place an FP arg on the stack, so account for

+     is incremented whenever we place an FP arg on the stack, so account for

      that before our assert test.  */

 #ifndef __NO_FPRS__

   if (fparg_count > NUM_FPR_ARG_REGISTERS)

@@ -392,6 +390,45 @@ enum {

 };

 enum { ASM_NEEDS_REGISTERS64 = 4 };

+#if _CALL_ELF == 2

+static unsigned int

+discover_homogeneous_aggregate (const ffi_type *t, unsigned int *elnum)

+{

+  switch (t->type)

+    {

+    case FFI_TYPE_FLOAT:

+    case FFI_TYPE_DOUBLE:

+      *elnum = 1;

+      return (int) t->type;

+

+    case FFI_TYPE_STRUCT:;

+      {

+	unsigned int base_elt = 0, total_elnum = 0;

+	ffi_type **el = t->elements;

+	while (*el)

+	  {

+	    unsigned int el_elt, el_elnum = 0;

+	    el_elt = discover_homogeneous_aggregate (*el, &el_elnum);

+	    if (el_elt == 0

+		|| (base_elt && base_elt != el_elt))

+	      return 0;

+	    base_elt = el_elt;

+	    total_elnum += el_elnum;

+	    if (total_elnum > 8)

+	      return 0;

+	    el++;

+	  }

+	*elnum = total_elnum;

+	return base_elt;

+      }

+

+    default:

+      return 0;

+    }

+}

+#endif

+

+

 /* ffi_prep_args64 is called by the assembly routine once stack space

    has been allocated for the function's arguments.

@@ -437,6 +474,7 @@ ffi_prep_args64 (extended_cif *ecif, uns

     unsigned long *ul;

     float *f;

     double *d;

+    size_t p;

   } valp;

   /* 'stacktop' points at the previous backchain pointer.  */

@@ -452,9 +490,9 @@ ffi_prep_args64 (extended_cif *ecif, uns

   /* 'fpr_base' points at the space for fpr3, and grows upwards as

      we use FPR registers.  */

   valp fpr_base;

-  int fparg_count;

+  unsigned int fparg_count;

-  int i, words;

+  unsigned int i, words, nargs, nfixedargs;

   ffi_type **ptr;

   double double_tmp;

   union {

@@ -471,11 +509,18 @@ ffi_prep_args64 (extended_cif *ecif, uns

     double **d;

   } p_argv;

   unsigned long gprvalue;

+#ifdef __STRUCT_PARM_ALIGN__

+  unsigned long align;

+#endif

   stacktop.c = (char *) stack + bytes;

   gpr_base.ul = stacktop.ul - ASM_NEEDS_REGISTERS64 - NUM_GPR_ARG_REGISTERS64;

   gpr_end.ul = gpr_base.ul + NUM_GPR_ARG_REGISTERS64;

+#if _CALL_ELF == 2

+  rest.ul = stack + 4 + NUM_GPR_ARG_REGISTERS64;

+#else

   rest.ul = stack + 6 + NUM_GPR_ARG_REGISTERS64;

+#endif

   fpr_base.d = gpr_base.d - NUM_FPR_ARG_REGISTERS64;

   fparg_count = 0;

   next_arg.ul = gpr_base.ul;

@@ -491,30 +536,36 @@ ffi_prep_args64 (extended_cif *ecif, uns

   /* Now for the arguments.  */

   p_argv.v = ecif->avalue;

-  for (ptr = ecif->cif->arg_types, i = ecif->cif->nargs;

-       i > 0;

-       i--, ptr++, p_argv.v++)

+  nargs = ecif->cif->nargs;

+  nfixedargs = ecif->cif->nfixedargs;

+  for (ptr = ecif->cif->arg_types, i = 0;

+       i < nargs;

+       i++, ptr++, p_argv.v++)

     {

+      unsigned int elt, elnum;

+

       switch ((*ptr)->type)

 	{

 	case FFI_TYPE_FLOAT:

 	  double_tmp = **p_argv.f;

-	  *next_arg.f = (float) double_tmp;

+	  if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)

+	    *fpr_base.d++ = double_tmp;

+	  else

+	    *next_arg.f = (float) double_tmp;

 	  if (++next_arg.ul == gpr_end.ul)

 	    next_arg.ul = rest.ul;

-	  if (fparg_count < NUM_FPR_ARG_REGISTERS64)

-	    *fpr_base.d++ = double_tmp;

 	  fparg_count++;

 	  FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);

 	  break;

 	case FFI_TYPE_DOUBLE:

 	  double_tmp = **p_argv.d;

-	  *next_arg.d = double_tmp;

+	  if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)

+	    *fpr_base.d++ = double_tmp;

+	  else

+	    *next_arg.d = double_tmp;

 	  if (++next_arg.ul == gpr_end.ul)

 	    next_arg.ul = rest.ul;

-	  if (fparg_count < NUM_FPR_ARG_REGISTERS64)

-	    *fpr_base.d++ = double_tmp;

 	  fparg_count++;

 	  FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);

 	  break;

@@ -522,18 +573,20 @@ ffi_prep_args64 (extended_cif *ecif, uns

 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE

 	case FFI_TYPE_LONGDOUBLE:

 	  double_tmp = (*p_argv.d)[0];

-	  *next_arg.d = double_tmp;

+	  if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)

+	    *fpr_base.d++ = double_tmp;

+	  else

+	    *next_arg.d = double_tmp;

 	  if (++next_arg.ul == gpr_end.ul)

 	    next_arg.ul = rest.ul;

-	  if (fparg_count < NUM_FPR_ARG_REGISTERS64)

-	    *fpr_base.d++ = double_tmp;

 	  fparg_count++;

 	  double_tmp = (*p_argv.d)[1];

-	  *next_arg.d = double_tmp;

+	  if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)

+	    *fpr_base.d++ = double_tmp;

+	  else

+	    *next_arg.d = double_tmp;

 	  if (++next_arg.ul == gpr_end.ul)

 	    next_arg.ul = rest.ul;

-	  if (fparg_count < NUM_FPR_ARG_REGISTERS64)

-	    *fpr_base.d++ = double_tmp;

 	  fparg_count++;

 	  FFI_ASSERT (__LDBL_MANT_DIG__ == 106);

 	  FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);

@@ -541,27 +594,86 @@ ffi_prep_args64 (extended_cif *ecif, uns

 #endif

 	case FFI_TYPE_STRUCT:

-	  words = ((*ptr)->size + 7) / 8;

-	  if (next_arg.ul >= gpr_base.ul && next_arg.ul + words > gpr_end.ul)

-	    {

-	      size_t first = gpr_end.c - next_arg.c;

-	      memcpy (next_arg.c, *p_argv.c, first);

-	      memcpy (rest.c, *p_argv.c + first, (*ptr)->size - first);

-	      next_arg.c = rest.c + words * 8 - first;

+#ifdef __STRUCT_PARM_ALIGN__

+	  align = (*ptr)->alignment;

+	  if (align > __STRUCT_PARM_ALIGN__)

+	    align = __STRUCT_PARM_ALIGN__;

+	  if (align > 1)

+	    next_arg.p = ALIGN (next_arg.p, align);

+#endif

+	  elt = 0;

+#if _CALL_ELF == 2

+	  elt = discover_homogeneous_aggregate (*ptr, &elnum);

+#endif

+	  if (elt)

+	    {

+	      union {

+		void *v;

+		float *f;

+		double *d;

+	      } arg;

+

+	      arg.v = *p_argv.v;

+	      if (elt == FFI_TYPE_FLOAT)

+		{

+		  do

+		    {

+		      double_tmp = *arg.f++;

+		      if (fparg_count < NUM_FPR_ARG_REGISTERS64

+			  && i < nfixedargs)

+			*fpr_base.d++ = double_tmp;

+		      else

+			*next_arg.f = (float) double_tmp;

+		      if (++next_arg.f == gpr_end.f)

+			next_arg.f = rest.f;

+		      fparg_count++;

+		    }

+		  while (--elnum != 0);

+		  if ((next_arg.p & 3) != 0)

+		    {

+		      if (++next_arg.f == gpr_end.f)

+			next_arg.f = rest.f;

+		    }

+		}

+	      else

+		do

+		  {

+		    double_tmp = *arg.d++;

+		    if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)

+		      *fpr_base.d++ = double_tmp;

+		    else

+		      *next_arg.d = double_tmp;

+		    if (++next_arg.d == gpr_end.d)

+		      next_arg.d = rest.d;

+		    fparg_count++;

+		  }

+		while (--elnum != 0);

 	    }

 	  else

 	    {

-	      char *where = next_arg.c;

-

-	      /* Structures with size less than eight bytes are passed

-		 left-padded.  */

-	      if ((*ptr)->size < 8)

-		where += 8 - (*ptr)->size;

+	      words = ((*ptr)->size + 7) / 8;

+	      if (next_arg.ul >= gpr_base.ul && next_arg.ul + words > gpr_end.ul)

+		{

+		  size_t first = gpr_end.c - next_arg.c;

+		  memcpy (next_arg.c, *p_argv.c, first);

+		  memcpy (rest.c, *p_argv.c + first, (*ptr)->size - first);

+		  next_arg.c = rest.c + words * 8 - first;

+		}

+	      else

+		{

+		  char *where = next_arg.c;

-	      memcpy (where, *p_argv.c, (*ptr)->size);

-	      next_arg.ul += words;

-	      if (next_arg.ul == gpr_end.ul)

-		next_arg.ul = rest.ul;

+#ifndef __LITTLE_ENDIAN__

+		  /* Structures with size less than eight bytes are passed

+		     left-padded.  */

+		  if ((*ptr)->size < 8)

+		    where += 8 - (*ptr)->size;

+#endif

+		  memcpy (where, *p_argv.c, (*ptr)->size);

+		  next_arg.ul += words;

+		  if (next_arg.ul == gpr_end.ul)

+		    next_arg.ul = rest.ul;

+		}

 	    }

 	  break;

@@ -605,24 +717,22 @@ ffi_prep_args64 (extended_cif *ecif, uns

 /* Perform machine dependent cif processing */

-ffi_status

-ffi_prep_cif_machdep (ffi_cif *cif)

+static ffi_status

+ffi_prep_cif_machdep_core (ffi_cif *cif)

 {

   /* All this is for the SYSV and LINUX64 ABI.  */

-  int i;

   ffi_type **ptr;

   unsigned bytes;

-  int fparg_count = 0, intarg_count = 0;

-  unsigned flags = 0;

+  unsigned i, fparg_count = 0, intarg_count = 0;

+  unsigned flags = cif->flags;

   unsigned struct_copy_size = 0;

   unsigned type = cif->rtype->type;

   unsigned size = cif->rtype->size;

+  /* The machine-independent calculation of cif->bytes doesn't work

+     for us.  Redo the calculation.  */

   if (cif->abi != FFI_LINUX64)

     {

-      /* All the machine-independent calculation of cif->bytes will be wrong.

-	 Redo the calculation for SYSV.  */

-

       /* Space for the frame pointer, callee's LR, and the asm's temp regs.  */

       bytes = (2 + ASM_NEEDS_REGISTERS) * sizeof (int);

@@ -632,13 +742,20 @@ ffi_prep_cif_machdep (ffi_cif *cif)

   else

     {

       /* 64-bit ABI.  */

+#if _CALL_ELF == 2

+      /* Space for backchain, CR, LR, TOC and the asm's temp regs.  */

+      bytes = (4 + ASM_NEEDS_REGISTERS64) * sizeof (long);

+      /* Space for the general registers.  */

+      bytes += NUM_GPR_ARG_REGISTERS64 * sizeof (long);

+#else

       /* Space for backchain, CR, LR, cc/ld doubleword, TOC and the asm's temp

 	 regs.  */

       bytes = (6 + ASM_NEEDS_REGISTERS64) * sizeof (long);

       /* Space for the mandatory parm save area and general registers.  */

       bytes += 2 * NUM_GPR_ARG_REGISTERS64 * sizeof (long);

+#endif

     }

   /* Return value handling.  The rules for SYSV are as follows:

@@ -658,19 +775,23 @@ ffi_prep_cif_machdep (ffi_cif *cif)

      - soft-float float/doubles are treated as UINT32/UINT64 respectivley.

      - soft-float long doubles are returned in gpr3-gpr6.  */

   /* First translate for softfloat/nonlinux */

-  if (cif->abi == FFI_LINUX_SOFT_FLOAT) {

-	if (type == FFI_TYPE_FLOAT)

-		type = FFI_TYPE_UINT32;

-	if (type == FFI_TYPE_DOUBLE)

-		type = FFI_TYPE_UINT64;

-	if (type == FFI_TYPE_LONGDOUBLE)

-		type = FFI_TYPE_UINT128;

-  } else if (cif->abi != FFI_LINUX && cif->abi != FFI_LINUX64) {

+  if (cif->abi == FFI_LINUX_SOFT_FLOAT)

+    {

+      if (type == FFI_TYPE_FLOAT)

+	type = FFI_TYPE_UINT32;

+      if (type == FFI_TYPE_DOUBLE)

+	type = FFI_TYPE_UINT64;

+      if (type == FFI_TYPE_LONGDOUBLE)

+	type = FFI_TYPE_UINT128;

+    }

+  else if (cif->abi != FFI_LINUX

+	   && cif->abi != FFI_LINUX64)

+    {

 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE

-	if (type == FFI_TYPE_LONGDOUBLE)

-		type = FFI_TYPE_STRUCT;

+      if (type == FFI_TYPE_LONGDOUBLE)

+	type = FFI_TYPE_STRUCT;

 #endif

-  }

+    }

   switch (type)

     {

@@ -697,35 +818,40 @@ ffi_prep_cif_machdep (ffi_cif *cif)

       break;

     case FFI_TYPE_STRUCT:

-      if (cif->abi == FFI_SYSV)

+      /*

+       * The final SYSV ABI says that structures smaller or equal 8 bytes

+       * are returned in r3/r4.  The FFI_GCC_SYSV ABI instead returns them

+       * in memory.

+       *

+       * NOTE: The assembly code can safely assume that it just needs to

+       *       store both r3 and r4 into a 8-byte word-aligned buffer, as

+       *       we allocate a temporary buffer in ffi_call() if this flag is

+       *       set.

+       */

+      if (cif->abi == FFI_SYSV && size <= 8)

 	{

-	  /* The final SYSV ABI says that structures smaller or equal 8 bytes

-	     are returned in r3/r4. The FFI_GCC_SYSV ABI instead returns them

-	     in memory.  */

-

-	  /* Treat structs with size <= 8 bytes.  */

-	  if (size <= 8)

+	  flags |= FLAG_RETURNS_SMST;

+	  break;

+	}

+#if _CALL_ELF == 2

+      if (cif->abi == FFI_LINUX64)

+	{

+	  unsigned int elt, elnum;

+	  elt = discover_homogeneous_aggregate (cif->rtype, &elnum);

+	  if (elt)

+	    {

+	      if (elt == FFI_TYPE_DOUBLE)

+		flags |= FLAG_RETURNS_64BITS;

+	      flags |= FLAG_RETURNS_FP | FLAG_RETURNS_SMST;

+	      break;

+	    }

+	  if (size <= 16)

 	    {

 	      flags |= FLAG_RETURNS_SMST;

-	      /* These structs are returned in r3. We pack the type and the

-		 precalculated shift value (needed in the sysv.S) into flags.

-		 The same applies for the structs returned in r3/r4.  */

-	      if (size <= 4)

-		{

-		  flags |= FLAG_SYSV_SMST_R3;

-		  flags |= 8 * (4 - size) << 8;

-		  break;

-		}

-	      /* These structs are returned in r3 and r4. See above.   */

-	      if  (size <= 8)

-		{

-		  flags |= FLAG_SYSV_SMST_R3 | FLAG_SYSV_SMST_R4;

-		  flags |= 8 * (8 - size) << 8;

-		  break;

-		}

+	      break;

 	    }

 	}

-

+#endif

       intarg_count++;

       flags |= FLAG_RETVAL_REFERENCE;

       /* Fall through.  */

@@ -841,27 +967,54 @@ ffi_prep_cif_machdep (ffi_cif *cif)

   else

     for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)

       {

+	unsigned int elt, elnum;

+#ifdef __STRUCT_PARM_ALIGN__

+	unsigned int align;

+#endif

+

 	switch ((*ptr)->type)

 	  {

 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE

 	  case FFI_TYPE_LONGDOUBLE:

-	    if (cif->abi == FFI_LINUX_SOFT_FLOAT)

-	      intarg_count += 4;

-	    else

-	      {

-		fparg_count += 2;

-		intarg_count += 2;

-	      }

+	    fparg_count += 2;

+	    intarg_count += 2;

+	    if (fparg_count > NUM_FPR_ARG_REGISTERS)

+	      flags |= FLAG_ARG_NEEDS_PSAVE;

 	    break;

 #endif

 	  case FFI_TYPE_FLOAT:

 	  case FFI_TYPE_DOUBLE:

 	    fparg_count++;

 	    intarg_count++;

+	    if (fparg_count > NUM_FPR_ARG_REGISTERS)

+	      flags |= FLAG_ARG_NEEDS_PSAVE;

 	    break;

 	  case FFI_TYPE_STRUCT:

+#ifdef __STRUCT_PARM_ALIGN__

+	    align = (*ptr)->alignment;

+	    if (align > __STRUCT_PARM_ALIGN__)

+	      align = __STRUCT_PARM_ALIGN__;

+	    align = align / 8;

+	    if (align > 1)

+	      intarg_count = ALIGN (intarg_count, align);

+#endif

 	    intarg_count += ((*ptr)->size + 7) / 8;

+	    elt = 0;

+#if _CALL_ELF == 2

+	    elt = discover_homogeneous_aggregate (*ptr, &elnum);

+#endif

+	    if (elt)

+	      {

+		fparg_count += elnum;

+		if (fparg_count > NUM_FPR_ARG_REGISTERS)

+		  flags |= FLAG_ARG_NEEDS_PSAVE;

+	      }

+	    else

+	      {

+		if (intarg_count > NUM_GPR_ARG_REGISTERS)

+		  flags |= FLAG_ARG_NEEDS_PSAVE;

+	      }

 	    break;

 	  case FFI_TYPE_POINTER:

@@ -877,9 +1030,11 @@ ffi_prep_cif_machdep (ffi_cif *cif)

 	    /* Everything else is passed as a 8-byte word in a GPR, either

 	       the object itself or a pointer to it.  */

 	    intarg_count++;

+	    if (intarg_count > NUM_GPR_ARG_REGISTERS)

+	      flags |= FLAG_ARG_NEEDS_PSAVE;

 	    break;

 	  default:

-		FFI_ASSERT (0);

+	    FFI_ASSERT (0);

 	  }

       }

@@ -917,8 +1072,13 @@ ffi_prep_cif_machdep (ffi_cif *cif)

 #endif

       /* Stack space.  */

+#if _CALL_ELF == 2

+      if ((flags & FLAG_ARG_NEEDS_PSAVE) != 0)

+	bytes += intarg_count * sizeof (long);

+#else

       if (intarg_count > NUM_GPR_ARG_REGISTERS64)

 	bytes += (intarg_count - NUM_GPR_ARG_REGISTERS64) * sizeof (long);

+#endif

     }

   /* The stack space allocated needs to be a multiple of 16 bytes.  */

@@ -933,6 +1093,26 @@ ffi_prep_cif_machdep (ffi_cif *cif)

   return FFI_OK;

 }

+ffi_status

+ffi_prep_cif_machdep (ffi_cif *cif)

+{

+  cif->nfixedargs = cif->nargs;

+  return ffi_prep_cif_machdep_core (cif);

+}

+

+ffi_status

+ffi_prep_cif_machdep_var (ffi_cif *cif,

+			  unsigned int nfixedargs,

+			  unsigned int ntotalargs MAYBE_UNUSED)

+{

+  cif->nfixedargs = nfixedargs;

+#if _CALL_ELF == 2

+  if (cif->abi == FFI_LINUX64)

+    cif->flags |= FLAG_ARG_NEEDS_PSAVE;

+#endif

+  return ffi_prep_cif_machdep_core (cif);

+}

+

 extern void ffi_call_SYSV(extended_cif *, unsigned, unsigned, unsigned *,

 			  void (*fn)(void));

 extern void FFI_HIDDEN ffi_call_LINUX64(extended_cif *, unsigned long,

@@ -944,30 +1124,28 @@ ffi_call(ffi_cif *cif, void (*fn)(void),

 {

   /*

    * The final SYSV ABI says that structures smaller or equal 8 bytes

-   * are returned in r3/r4. The FFI_GCC_SYSV ABI instead returns them

+   * are returned in r3/r4.  The FFI_GCC_SYSV ABI instead returns them

    * in memory.

    *

-   * Just to keep things simple for the assembly code, we will always

-   * bounce-buffer struct return values less than or equal to 8 bytes.

-   * This allows the ASM to handle SYSV small structures by directly

-   * writing r3 and r4 to memory without worrying about struct size.

+   * We bounce-buffer SYSV small struct return values so that sysv.S

+   * can write r3 and r4 to memory without worrying about struct size.

+   *

+   * For ELFv2 ABI, use a bounce buffer for homogeneous structs too,

+   * for similar reasons.

    */

-  unsigned int smst_buffer[2];

+  unsigned long smst_buffer[8];

   extended_cif ecif;

-  unsigned int rsize = 0;

   ecif.cif = cif;

   ecif.avalue = avalue;

-  /* Ensure that we have a valid struct return value */

   ecif.rvalue = rvalue;

-  if (cif->rtype->type == FFI_TYPE_STRUCT) {

-    rsize = cif->rtype->size;

-    if (rsize <= 8)

-      ecif.rvalue = smst_buffer;

-    else if (!rvalue)

-      ecif.rvalue = alloca(rsize);

-  }

+  if ((cif->flags & FLAG_RETURNS_SMST) != 0)

+    ecif.rvalue = smst_buffer;

+  /* Ensure that we have a valid struct return value.

+     FIXME: Isn't this just papering over a user problem?  */

+  else if (!rvalue && cif->rtype->type == FFI_TYPE_STRUCT)

+    ecif.rvalue = alloca (cif->rtype->size);

   switch (cif->abi)

     {

@@ -992,11 +1170,26 @@ ffi_call(ffi_cif *cif, void (*fn)(void),

   /* Check for a bounce-buffered return value */

   if (rvalue && ecif.rvalue == smst_buffer)

-    memcpy(rvalue, smst_buffer, rsize);

+    {

+      unsigned int rsize = cif->rtype->size;

+#ifndef __LITTLE_ENDIAN__

+      /* The SYSV ABI returns a structure of up to 4 bytes in size

+	 left-padded in r3.  */

+      if (cif->abi == FFI_SYSV && rsize <= 4)

+	memcpy (rvalue, (char *) smst_buffer + 4 - rsize, rsize);

+      /* The SYSV ABI returns a structure of up to 8 bytes in size

+	 left-padded in r3/r4, and the ELFv2 ABI similarly returns a

+	 structure of up to 8 bytes in size left-padded in r3.  */

+      else if (rsize <= 8)

+	memcpy (rvalue, (char *) smst_buffer + 8 - rsize, rsize);

+      else

+#endif

+	memcpy (rvalue, smst_buffer, rsize);

+    }

 }

-#ifndef POWERPC64

+#if !defined POWERPC64 || _CALL_ELF == 2

 #define MIN_CACHE_LINE_SIZE 8

 static void

@@ -1020,6 +1213,22 @@ ffi_prep_closure_loc (ffi_closure *closu

 		      void *codeloc)

 {

 #ifdef POWERPC64

+# if _CALL_ELF == 2

+  unsigned int *tramp = (unsigned int *) &closure->tramp[0];

+

+  if (cif->abi != FFI_LINUX64)

+    return FFI_BAD_ABI;

+

+  tramp[0] = 0xe96c0018;	/* 0:	ld	11,2f-0b(12)	*/

+  tramp[1] = 0xe98c0010;	/*	ld	12,1f-0b(12)	*/

+  tramp[2] = 0x7d8903a6;	/*	mtctr	12		*/

+  tramp[3] = 0x4e800420;	/*	bctr			*/

+				/* 1:	.quad	function_addr	*/

+				/* 2:	.quad	context		*/

+  *(void **) &tramp[4] = (void *) ffi_closure_LINUX64;

+  *(void **) &tramp[6] = codeloc;

+  flush_icache ((char *)tramp, (char *)codeloc, FFI_TRAMPOLINE_SIZE);

+# else

   void **tramp = (void **) &closure->tramp[0];

   if (cif->abi != FFI_LINUX64)

@@ -1027,6 +1236,7 @@ ffi_prep_closure_loc (ffi_closure *closu

   /* Copy function address and TOC from ffi_closure_LINUX64.  */

   memcpy (tramp, (char *) ffi_closure_LINUX64, 16);

   tramp[2] = codeloc;

+# endif

 #else

   unsigned int *tramp;

@@ -1236,6 +1446,7 @@ ffi_closure_helper_SYSV (ffi_closure *cl

 	case FFI_TYPE_SINT8:

 	case FFI_TYPE_UINT8:

+#ifndef __LITTLE_ENDIAN__

 	  /* there are 8 gpr registers used to pass values */

 	  if (ng < 8)

 	    {

@@ -1249,9 +1460,11 @@ ffi_closure_helper_SYSV (ffi_closure *cl

 	      pst++;

 	    }

 	  break;

+#endif

 	case FFI_TYPE_SINT16:

 	case FFI_TYPE_UINT16:

+#ifndef __LITTLE_ENDIAN__

 	  /* there are 8 gpr registers used to pass values */

 	  if (ng < 8)

 	    {

@@ -1265,6 +1478,7 @@ ffi_closure_helper_SYSV (ffi_closure *cl

 	      pst++;

 	    }

 	  break;

+#endif

 	case FFI_TYPE_SINT32:

 	case FFI_TYPE_UINT32:

@@ -1369,16 +1583,20 @@ ffi_closure_helper_LINUX64 (ffi_closure

   void **avalue;

   ffi_type **arg_types;

-  long i, avn;

+  unsigned long i, avn, nfixedargs;

   ffi_cif *cif;

   ffi_dblfl *end_pfr = pfr + NUM_FPR_ARG_REGISTERS64;

+#ifdef __STRUCT_PARM_ALIGN__

+  unsigned long align;

+#endif

   cif = closure->cif;