--- mozilla/js/src/ctypes/libffi/src/powerpc/aix.S	2013-10-24 09:56:51.844587814 +0200

+++ /suse/dvaleev/obs/openSUSE:Factory:PowerLE/libffi48/gcc-4.8-ibmr205465/libffi/src/powerpc/aix.S	2013-11-29 17:23:26.000000000 +0100

@@ -1,5 +1,5 @@

 /* -----------------------------------------------------------------------

-   aix.S - Copyright (c) 2002,2009 Free Software Foundation, Inc.

+   aix.S - Copyright (c) 2002, 2009 Free Software Foundation, Inc.

    based on darwin.S by John Hornkvist

    PowerPC Assembly glue.

@@ -79,6 +79,8 @@

 	.set f20,20

 	.set f21,21

+	.extern .ffi_prep_args

+

 #define LIBFFI_ASM

 #include <fficonfig.h>

 #include <ffi.h>

@@ -125,6 +127,7 @@ ffi_call_AIX:

 	/* Call ffi_prep_args.  */

 	mr	r4, r1

 	bl	.ffi_prep_args

+	nop

 	/* Now do the call.  */

 	ld	r0, 0(r29)

@@ -226,6 +229,7 @@ L(float_return_value):

 	/* Call ffi_prep_args.  */

 	mr	r4, r1

 	bl	.ffi_prep_args

+	nop

 	/* Now do the call.  */

 	lwz	r0, 0(r29)

--- mozilla/js/src/ctypes/libffi/src/powerpc/ffi.c	2013-10-24 09:56:51.846587814 +0200

+++ /suse/dvaleev/obs/openSUSE:Factory:PowerLE/libffi48/gcc-4.8-ibmr205465/libffi/src/powerpc/ffi.c	2013-11-29 17:23:26.000000000 +0100

@@ -1,7 +1,9 @@

 /* -----------------------------------------------------------------------

-   ffi.c - Copyright (c) 1998 Geoffrey Keating

-   Copyright (C) 2007, 2008 Free Software Foundation, Inc

-   Copyright (C) 2008 Red Hat, Inc

+   ffi.c - Copyright (C) 2011 Anthony Green

+           Copyright (C) 2011 Kyle Moffett

+           Copyright (C) 2008 Red Hat, Inc

+           Copyright (C) 2007, 2008 Free Software Foundation, Inc

+	   Copyright (c) 1998 Geoffrey Keating

    PowerPC Foreign Function Interface

@@ -39,32 +41,29 @@ enum {

   /* The assembly depends on these exact flags.  */

   FLAG_RETURNS_SMST	= 1 << (31-31), /* Used for FFI_SYSV small structs.  */

   FLAG_RETURNS_NOTHING  = 1 << (31-30), /* These go in cr7 */

+#ifndef __NO_FPRS__

   FLAG_RETURNS_FP       = 1 << (31-29),

+#endif

   FLAG_RETURNS_64BITS   = 1 << (31-28),

   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.  */

-  /* Bits (31-24) through (31-19) store shift value for SMST */

   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

   FLAG_4_GPR_ARGUMENTS  = 1 << (31- 5),

   FLAG_RETVAL_REFERENCE = 1 << (31- 4)

 };

 /* About the SYSV ABI.  */

-unsigned int NUM_GPR_ARG_REGISTERS = 8;

+#define ASM_NEEDS_REGISTERS 4

+#define NUM_GPR_ARG_REGISTERS 8

 #ifndef __NO_FPRS__

-unsigned int NUM_FPR_ARG_REGISTERS = 8;

-#else

-unsigned int NUM_FPR_ARG_REGISTERS = 0;

+# define NUM_FPR_ARG_REGISTERS 8

 #endif

-enum { ASM_NEEDS_REGISTERS = 4 };

-

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

    has been allocated for the function's arguments.

@@ -113,10 +112,12 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   valp gpr_base;

   int intarg_count;

+#ifndef __NO_FPRS__

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

      we use FPR registers.  */

   valp fpr_base;

   int fparg_count;

+#endif

   /* 'copy_space' grows down as we put structures in it.  It should

      stay 16-byte aligned.  */

@@ -125,9 +126,11 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   /* 'next_arg' grows up as we put parameters in it.  */

   valp next_arg;

-  int i, ii MAYBE_UNUSED;

+  int i;

   ffi_type **ptr;

+#ifndef __NO_FPRS__

   double double_tmp;

+#endif

   union {

     void **v;

     char **c;

@@ -143,21 +146,22 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   size_t struct_copy_size;

   unsigned gprvalue;

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

-    NUM_FPR_ARG_REGISTERS = 0;

-

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

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

   intarg_count = 0;

+#ifndef __NO_FPRS__

   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);

+#else

+  copy_space.c = gpr_base.c;

+#endif

   next_arg.u = stack + 2;

   /* Check that everything starts aligned properly.  */

-  FFI_ASSERT (((unsigned) (char *) stack & 0xF) == 0);

-  FFI_ASSERT (((unsigned) copy_space.c & 0xF) == 0);

-  FFI_ASSERT (((unsigned) stacktop.c & 0xF) == 0);

+  FFI_ASSERT (((unsigned long) (char *) stack & 0xF) == 0);

+  FFI_ASSERT (((unsigned long) copy_space.c & 0xF) == 0);

+  FFI_ASSERT (((unsigned long) stacktop.c & 0xF) == 0);

   FFI_ASSERT ((bytes & 0xF) == 0);

   FFI_ASSERT (copy_space.c >= next_arg.c);

@@ -174,12 +178,28 @@ ffi_prep_args_SYSV (extended_cif *ecif,

        i > 0;

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

     {

-      switch ((*ptr)->type)

-	{

+      unsigned short typenum = (*ptr)->type;

+

+      /* We may need to handle some values depending on ABI */

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

+		if (typenum == FFI_TYPE_FLOAT)

+			typenum = FFI_TYPE_UINT32;

+		if (typenum == FFI_TYPE_DOUBLE)

+			typenum = FFI_TYPE_UINT64;

+		if (typenum == FFI_TYPE_LONGDOUBLE)

+			typenum = FFI_TYPE_UINT128;

+      } else if (ecif->cif->abi != FFI_LINUX) {

+#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE

+		if (typenum == FFI_TYPE_LONGDOUBLE)

+			typenum = FFI_TYPE_STRUCT;

+#endif

+      }

+

+      /* Now test the translated value */

+      switch (typenum) {

+#ifndef __NO_FPRS__

 	case FFI_TYPE_FLOAT:

 	  /* With FFI_LINUX_SOFT_FLOAT floats are handled like UINT32.  */

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

-	    goto soft_float_prep;

 	  double_tmp = **p_argv.f;

 	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)

 	    {

@@ -195,8 +215,6 @@ ffi_prep_args_SYSV (extended_cif *ecif,

 	case FFI_TYPE_DOUBLE:

 	  /* With FFI_LINUX_SOFT_FLOAT doubles are handled like UINT64.  */

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

-	    goto soft_double_prep;

 	  double_tmp = **p_argv.d;

 	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)

@@ -218,43 +236,6 @@ ffi_prep_args_SYSV (extended_cif *ecif,

 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE

 	case FFI_TYPE_LONGDOUBLE:

-	  if ((ecif->cif->abi != FFI_LINUX)

-		&& (ecif->cif->abi != FFI_LINUX_SOFT_FLOAT))

-	    goto do_struct;

-	  /* The soft float ABI for long doubles works like this,

-	     a long double is passed in four consecutive gprs if available.

-	     A maximum of 2 long doubles can be passed in gprs.

-	     If we do not have 4 gprs left, the long double is passed on the

-	     stack, 4-byte aligned.  */

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

-	    {

-	      unsigned int int_tmp = (*p_argv.ui)[0];

-	      if (intarg_count >= NUM_GPR_ARG_REGISTERS - 3)

-		{

-		  if (intarg_count < NUM_GPR_ARG_REGISTERS)

-		    intarg_count += NUM_GPR_ARG_REGISTERS - intarg_count;

-		  *next_arg.u = int_tmp;

-		  next_arg.u++;

-		  for (ii = 1; ii < 4; ii++)

-		    {

-		      int_tmp = (*p_argv.ui)[ii];

-		      *next_arg.u = int_tmp;

-		      next_arg.u++;

-		    }

-		}

-	      else

-		{

-		  *gpr_base.u++ = int_tmp;

-		  for (ii = 1; ii < 4; ii++)

-		    {

-		      int_tmp = (*p_argv.ui)[ii];

-		      *gpr_base.u++ = int_tmp;

-		    }

-		}

-	      intarg_count +=4;

-	    }

-	  else

-	    {

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

 	      if (fparg_count >= NUM_FPR_ARG_REGISTERS - 1)

@@ -280,13 +261,40 @@ ffi_prep_args_SYSV (extended_cif *ecif,

 	      fparg_count += 2;

 	      FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);

-	    }

 	  break;

 #endif

+#endif /* have FPRs */

+

+	/*

+	 * The soft float ABI for long doubles works like this, a long double

+	 * is passed in four consecutive GPRs if available.  A maximum of 2

+	 * long doubles can be passed in gprs.  If we do not have 4 GPRs

+	 * left, the long double is passed on the stack, 4-byte aligned.

+	 */

+	case FFI_TYPE_UINT128: {

+		unsigned int int_tmp = (*p_argv.ui)[0];

+		unsigned int ii;

+		if (intarg_count >= NUM_GPR_ARG_REGISTERS - 3) {

+			if (intarg_count < NUM_GPR_ARG_REGISTERS)

+				intarg_count += NUM_GPR_ARG_REGISTERS - intarg_count;

+			*(next_arg.u++) = int_tmp;

+			for (ii = 1; ii < 4; ii++) {

+				int_tmp = (*p_argv.ui)[ii];

+				*(next_arg.u++) = int_tmp;

+			}

+		} else {

+			*(gpr_base.u++) = int_tmp;

+			for (ii = 1; ii < 4; ii++) {

+				int_tmp = (*p_argv.ui)[ii];

+				*(gpr_base.u++) = int_tmp;

+			}

+		}

+		intarg_count += 4;

+		break;

+	}

 	case FFI_TYPE_UINT64:

 	case FFI_TYPE_SINT64:

-	soft_double_prep:

 	  if (intarg_count == NUM_GPR_ARG_REGISTERS-1)

 	    intarg_count++;

 	  if (intarg_count >= NUM_GPR_ARG_REGISTERS)

@@ -319,9 +327,6 @@ ffi_prep_args_SYSV (extended_cif *ecif,

 	  break;

 	case FFI_TYPE_STRUCT:

-#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE

-	do_struct:

-#endif

 	  struct_copy_size = ((*ptr)->size + 15) & ~0xF;

 	  copy_space.c -= struct_copy_size;

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

@@ -349,7 +354,6 @@ ffi_prep_args_SYSV (extended_cif *ecif,

 	case FFI_TYPE_UINT32:

 	case FFI_TYPE_SINT32:

 	case FFI_TYPE_POINTER:

-	soft_float_prep:

 	  gprvalue = **p_argv.ui;

@@ -366,8 +370,16 @@ ffi_prep_args_SYSV (extended_cif *ecif,

   /* Check that we didn't overrun the stack...  */

   FFI_ASSERT (copy_space.c >= next_arg.c);

   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 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)

+    intarg_count -= fparg_count - NUM_FPR_ARG_REGISTERS;

   FFI_ASSERT (fpr_base.u

 	      <= stacktop.u - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);

+#endif

   FFI_ASSERT (flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);

 }

@@ -378,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.

@@ -423,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.  */

@@ -438,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 {

@@ -457,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;

@@ -477,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;

@@ -508,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);

@@ -527,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)

+#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)

 	    {

-	      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;

+	      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;