ffi 1.15.5 → 1.16.3

data/ext/ffi_c/libffi/src/mips/ffi.c

@@ -31,6 +31,7 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <stdio.h>
 
 #ifdef __GNUC__
 #  if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))
@@ -77,22 +78,39 @@ static void ffi_prep_args(char *stack,
 {
   int i;
   void **p_argv;
-  char *argp;
+  char *argp, *argp_f;
   ffi_type **p_arg;
 
+  memset(stack, 0, bytes);
+
 #ifdef FFI_MIPS_N32
+  int soft_float = (ecif->cif->abi == FFI_N32_SOFT_FLOAT
+		    || ecif->cif->abi == FFI_N64_SOFT_FLOAT);
   /* If more than 8 double words are used, the remainder go
      on the stack. We reorder stuff on the stack here to 
      support this easily. */
-  if (bytes > 8 * sizeof(ffi_arg))
-    argp = &stack[bytes - (8 * sizeof(ffi_arg))];
+  /* if ret is _Complex long double, args reg shift2, and a0 should holds pointer to rvalue */
+  if (ecif->cif->rtype->type == FFI_TYPE_COMPLEX && ecif->cif->rtype->elements[0]->type == FFI_TYPE_LONGDOUBLE)
+    {
+      if (bytes + 16 > 8 * sizeof(ffi_arg))
+        argp = &stack[bytes - (8 * sizeof(ffi_arg))];
+      else
+        argp = stack;
+      * (unsigned long *) argp = (unsigned long) ecif->rvalue;
+      argp += 16;
+    }
   else
-    argp = stack;
+    {
+      if (bytes > 8 * sizeof(ffi_arg))
+        argp = &stack[bytes - (8 * sizeof(ffi_arg))];
+      else
+        argp = stack;
+    }
 #else
   argp = stack;
 #endif
 
-  memset(stack, 0, bytes);
+  argp_f = argp;
 
 #ifdef FFI_MIPS_N32
   if ( ecif->cif->rstruct_flag != 0 )
@@ -133,7 +151,7 @@ static void ffi_prep_args(char *stack,
           if (type == FFI_TYPE_POINTER)
             type = (ecif->cif->abi == FFI_N64
 		    || ecif->cif->abi == FFI_N64_SOFT_FLOAT)
-	      ? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
+	      ? FFI_TYPE_SINT64 : FFI_TYPE_UINT32;
 
 	if (i < 8 && (ecif->cif->abi == FFI_N32_SOFT_FLOAT
 		      || ecif->cif->abi == FFI_N64_SOFT_FLOAT))
@@ -183,6 +201,25 @@ static void ffi_prep_args(char *stack,
 #endif
 		break;
 
+#ifdef FFI_MIPS_N32
+	      case FFI_TYPE_COMPLEX:
+		/* expand from 4+4 to 8+8 if pass with fpr reg */
+		/* argp will wind back to stack when we process all of reg args */
+		/* all var_args passed with gpr, should be expand */
+	        if(!soft_float
+		    && (*p_arg)->elements[0]->type == FFI_TYPE_FLOAT
+		    && argp>=argp_f
+		    && i < ecif->cif->mips_nfixedargs)
+		  {
+		    *(float *) argp = *(float *)(* p_argv);
+		    argp += z;
+		    char *tmp = (void *) (*p_argv);
+		    *(float *) argp = *(float *)(tmp+4);
+		  }
+		else
+		  memcpy(argp, *p_argv, (*p_arg)->size);
+		break;
+#endif
 	      /* This can only happen with 64bit slots.  */
 	      case FFI_TYPE_FLOAT:
 		*(float *) argp = *(float *)(* p_argv);
@@ -235,6 +272,24 @@ static void ffi_prep_args(char *stack,
    passed in an integer register". This code traverses structure
    definitions and generates the appropriate flags. */
 
+static int
+calc_n32_struct_flags_element(unsigned *flags, ffi_type *e,
+			      unsigned *loc, unsigned *arg_reg)
+{
+  /* Align this object.  */
+  *loc = FFI_ALIGN(*loc, e->alignment);
+  if (e->type == FFI_TYPE_DOUBLE)
+    {
+      /* Already aligned to FFI_SIZEOF_ARG.  */
+      *arg_reg = *loc / FFI_SIZEOF_ARG;
+      if (*arg_reg > 7)
+	return 1;
+      *flags += (FFI_TYPE_DOUBLE << (*arg_reg * FFI_FLAG_BITS));
+    }
+  *loc += e->size;
+  return 0;
+}
+
 static unsigned
 calc_n32_struct_flags(int soft_float, ffi_type *arg,
 		      unsigned *loc, unsigned *arg_reg)
@@ -249,19 +304,16 @@ calc_n32_struct_flags(int soft_float, ffi_type *arg,
 
   while ((e = arg->elements[index]))
     {
-      /* Align this object.  */
-      *loc = FFI_ALIGN(*loc, e->alignment);
-      if (e->type == FFI_TYPE_DOUBLE)
+      if (e->type == FFI_TYPE_COMPLEX)
 	{
-          /* Already aligned to FFI_SIZEOF_ARG.  */
-          *arg_reg = *loc / FFI_SIZEOF_ARG;
-          if (*arg_reg > 7)
-            break;
-	  flags += (FFI_TYPE_DOUBLE << (*arg_reg * FFI_FLAG_BITS));
-          *loc += e->size;
+	  if (calc_n32_struct_flags_element(&flags, e->elements[0], loc, arg_reg))
+	    break;
+	  if (calc_n32_struct_flags_element(&flags, e->elements[0], loc, arg_reg))
+	    break;
 	}
       else
-        *loc += e->size;
+	if (calc_n32_struct_flags_element(&flags, e, loc, arg_reg))
+	  break;
       index++;
     }
   /* Next Argument register at alignment of FFI_SIZEOF_ARG.  */
@@ -273,7 +325,7 @@ calc_n32_struct_flags(int soft_float, ffi_type *arg,
 static unsigned
 calc_n32_return_struct_flags(int soft_float, ffi_type *arg)
 {
-  unsigned flags = 0;
+  unsigned flags;
   unsigned small = FFI_TYPE_SMALLSTRUCT;
   ffi_type *e;
 
@@ -292,33 +344,48 @@ calc_n32_return_struct_flags(int soft_float, ffi_type *arg)
 
   e = arg->elements[0];
 
-  if (e->type == FFI_TYPE_DOUBLE)
-    flags = FFI_TYPE_DOUBLE;
-  else if (e->type == FFI_TYPE_FLOAT)
-    flags = FFI_TYPE_FLOAT;
-
-  if (flags && (e = arg->elements[1]))
+  if (e->type == FFI_TYPE_COMPLEX)
     {
-      if (e->type == FFI_TYPE_DOUBLE)
-	flags += FFI_TYPE_DOUBLE << FFI_FLAG_BITS;
-      else if (e->type == FFI_TYPE_FLOAT)
-	flags += FFI_TYPE_FLOAT << FFI_FLAG_BITS;
-      else 
+      int type = e->elements[0]->type;
+
+      if (type != FFI_TYPE_DOUBLE && type != FFI_TYPE_FLOAT)
 	return small;
 
-      if (flags && (arg->elements[2]))
+      if (arg->elements[1])
 	{
-	  /* There are three arguments and the first two are 
-	     floats! This must be passed the old way. */
+	  /* Two floating point fields with more fields!
+	     This must be passed the old way. */
 	  return small;
 	}
-      if (soft_float)
-	flags += FFI_TYPE_STRUCT_SOFT;
+
+      flags = (type << FFI_FLAG_BITS) + type;
     }
   else
-    if (!flags)
-      return small;
+    {
+      if (e->type != FFI_TYPE_DOUBLE && e->type != FFI_TYPE_FLOAT)
+	return small;
+
+      flags = e->type;
+
+      if (arg->elements[1])
+	{
+	  e = arg->elements[1];
+	  if (e->type != FFI_TYPE_DOUBLE && e->type != FFI_TYPE_FLOAT)
+	    return small;
+
+	  if (arg->elements[2])
+	    {
+	      /* There are three arguments and the first two are
+		 floats! This must be passed the old way. */
+	      return small;
+	    }
 
+	  flags += e->type << FFI_FLAG_BITS;
+	}
+    }
+
+  if (soft_float)
+    flags += FFI_TYPE_STRUCT_SOFT;
   return flags;
 }
 
@@ -335,7 +402,7 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
    * does not have special handling for floating point args.
    */
 
-  if (cif->rtype->type != FFI_TYPE_STRUCT && cif->abi == FFI_O32)
+  if (cif->rtype->type != FFI_TYPE_STRUCT && cif->rtype->type != FFI_TYPE_COMPLEX && cif->abi == FFI_O32)
     {
       if (cif->nargs > 0 && cif->nargs == nfixedargs)
 	{
@@ -403,7 +470,10 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
         case FFI_TYPE_STRUCT:
         case FFI_TYPE_FLOAT:
         case FFI_TYPE_DOUBLE:
+        case FFI_TYPE_COMPLEX:
           cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
+	  if (cif->rtype->type == FFI_TYPE_COMPLEX)
+            cif->flags +=  ((*cif->rtype->elements[0]).type) << (FFI_FLAG_BITS * 4);
           break;
 
         case FFI_TYPE_SINT64:
@@ -421,7 +491,6 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 #ifdef FFI_MIPS_N32
   /* Set the flags necessary for N32 processing */
   {
-    int type;
     unsigned arg_reg = 0;
     unsigned loc = 0;
     unsigned count = (cif->nargs < 8) ? cif->nargs : 8;
@@ -453,29 +522,14 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 
     while (count-- > 0 && arg_reg < 8)
       {
-	type = (cif->arg_types)[index]->type;
+	ffi_type *t = cif->arg_types[index];
 
-	// Pass variadic arguments in integer registers even if they're floats
-	if (soft_float || index >= nfixedargs)
-	  {
-	    switch (type)
-	      {
-	      case FFI_TYPE_FLOAT:
-		type = FFI_TYPE_UINT32;
-		break;
-	      case FFI_TYPE_DOUBLE:
-		type = FFI_TYPE_UINT64;
-		break;
-	      default:
-		break;
-	      }
-	  }
-	switch (type)
+	switch (t->type)
 	  {
 	  case FFI_TYPE_FLOAT:
 	  case FFI_TYPE_DOUBLE:
-	    cif->flags +=
-              ((cif->arg_types)[index]->type << (arg_reg * FFI_FLAG_BITS));
+	    if (!soft_float && index < nfixedargs)
+              cif->flags += t->type << (arg_reg * FFI_FLAG_BITS);
 	    arg_reg++;
 	    break;
           case FFI_TYPE_LONGDOUBLE:
@@ -491,17 +545,71 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 		cif->flags +=
 		  (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
 		arg_reg++;
+		if (arg_reg >= 8)
+		  continue;
 		cif->flags +=
 		  (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
 		arg_reg++;
 	      }
             break;
 
+	  case FFI_TYPE_COMPLEX:
+	    switch (t->elements[0]->type)
+	      {
+	      case FFI_TYPE_LONGDOUBLE:
+		arg_reg = FFI_ALIGN(arg_reg, 2);
+		if (soft_float || index >= nfixedargs)
+		  {
+		    arg_reg += 2;
+		  }
+		else
+		  {
+		    cif->flags +=
+		      (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
+		    arg_reg++;
+		    if (arg_reg >= 8)
+		        continue;
+		    cif->flags +=
+		      (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
+		    arg_reg++;
+		    if (arg_reg >= 8)
+		        continue;
+		  }
+		/* passthrough */
+	      case FFI_TYPE_FLOAT:
+		// one fpr can only holds one arg even it is single
+		cif->bytes += 16;
+		/* passthrough */
+	      case FFI_TYPE_SINT32:
+	      case FFI_TYPE_UINT32:
+	      case FFI_TYPE_DOUBLE:
+		if (soft_float || index >= nfixedargs)
+		  {
+		    arg_reg += 2;
+		  }
+		else
+		  {
+		    uint32_t type = t->elements[0]->type != FFI_TYPE_LONGDOUBLE? t->elements[0]->type: FFI_TYPE_DOUBLE;
+		    cif->flags +=
+		      (type << (arg_reg * FFI_FLAG_BITS));
+		    arg_reg++;
+		    if (arg_reg >= 8)
+		        continue;
+		    cif->flags +=
+		      (type << (arg_reg * FFI_FLAG_BITS));
+		    arg_reg++;
+		  }
+		break;
+	      default:
+		arg_reg += 2;
+		break;
+	      }
+	    break;
+
 	  case FFI_TYPE_STRUCT:
             loc = arg_reg * FFI_SIZEOF_ARG;
 	    cif->flags += calc_n32_struct_flags(soft_float || index >= nfixedargs,
-						(cif->arg_types)[index],
-						&loc, &arg_reg);
+						t, &loc, &arg_reg);
 	    break;
 
 	  default:
@@ -539,7 +647,7 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 
       case FFI_TYPE_POINTER:
 	if (cif->abi == FFI_N32_SOFT_FLOAT || cif->abi == FFI_N32)
-	  cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
+	  cif->flags += FFI_TYPE_UINT32 << (FFI_FLAG_BITS * 8);
 	else
 	  cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
 	break;
@@ -563,8 +671,9 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 	   two doubles.  */
 	if (soft_float)
 	  {
-	    cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
-	    cif->flags += FFI_TYPE_SMALLSTRUCT2 << (4 + (FFI_FLAG_BITS * 8));
+	    /* if ret is long double, the ret is given by v0 and a0, no idea why
+	     * Let's us VOID | VOID | LONGDOUBLE for it*/
+	    cif->flags += FFI_TYPE_LONGDOUBLE << (FFI_FLAG_BITS * 8);
  	  }
 	else
 	  {
@@ -574,13 +683,44 @@ static ffi_status ffi_prep_cif_machdep_int(ffi_cif *cif, unsigned nfixedargs)
 					      << (4 + (FFI_FLAG_BITS * 8));
 	  }
 	break;
+      case FFI_TYPE_COMPLEX:
+	{
+	  int type = cif->rtype->elements[0]->type;
+
+	  cif->flags += (FFI_TYPE_COMPLEX << (FFI_FLAG_BITS * 8));
+	  if (soft_float || (type != FFI_TYPE_FLOAT && type != FFI_TYPE_DOUBLE && type != FFI_TYPE_LONGDOUBLE))
+	    {
+	      switch (type)
+		{
+		case FFI_TYPE_DOUBLE:
+		case FFI_TYPE_SINT64:
+		case FFI_TYPE_UINT64:
+		case FFI_TYPE_INT:
+		  type = FFI_TYPE_SMALLSTRUCT2;
+		  break;
+		case FFI_TYPE_LONGDOUBLE:
+		  type = FFI_TYPE_LONGDOUBLE;
+		  break;
+		case FFI_TYPE_FLOAT:
+		default:
+		  type = FFI_TYPE_SMALLSTRUCT;
+		}
+	      cif->flags += type << (4 + (FFI_FLAG_BITS * 8));
+	    }
+	  else
+	    {
+	      //cif->flags += (type + (type << FFI_FLAG_BITS))
+		//	    << (4 + (FFI_FLAG_BITS * 8));
+	      cif->flags += type << (4 + (FFI_FLAG_BITS * 8));
+	    }
+	  break;
+	}
       default:
 	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
 	break;
       }
   }
 #endif
-  
   return FFI_OK;
 }
 
@@ -618,7 +758,7 @@ void ffi_call_int(ffi_cif *cif, void (*fn)(void), void *rvalue,
   /* value address then we need to make one		        */
   
   if ((rvalue == NULL) && 
-      (cif->rtype->type == FFI_TYPE_STRUCT))
+      (cif->rtype->type == FFI_TYPE_STRUCT || cif->rtype->type == FFI_TYPE_COMPLEX))
     ecif.rvalue = alloca(cif->rtype->size);
   else
     ecif.rvalue = rvalue;
@@ -830,6 +970,11 @@ ffi_closure_mips_inner_O32 (ffi_cif *cif,
       argn = 1;
       seen_int = 1;
     }
+  if ((cif->flags >> (FFI_FLAG_BITS * 2)) == FFI_TYPE_COMPLEX)
+    {
+      rvalue = fpr;
+      argn = 1;
+    }
 
   i = 0;
   avn = cif->nargs;
@@ -902,6 +1047,9 @@ ffi_closure_mips_inner_O32 (ffi_cif *cif,
     }
   else
     {
+      if (cif->rtype->type == FFI_TYPE_COMPLEX) {
+          __asm__ volatile ("move $v1, %0" : : "r"(cif->rtype->size));
+      }
       return cif->rtype->type;
     }
 }
@@ -991,6 +1139,8 @@ ffi_closure_mips_inner_N32 (ffi_cif *cif,
 #endif
       argn = 1;
     }
+  if (cif->rtype->type == FFI_TYPE_COMPLEX && cif->rtype->elements[0]->type == FFI_TYPE_LONGDOUBLE)
+    argn = 2;
 
   i = 0;
   avn = cif->nargs;
@@ -1015,6 +1165,31 @@ ffi_closure_mips_inner_N32 (ffi_cif *cif,
 #endif
             avaluep[i] = (char *) argp;
         }
+      else if (arg_types[i]->type == FFI_TYPE_COMPLEX && arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
+        {
+          argp = (argn >= 8 || i >= cif->mips_nfixedargs || soft_float) ? ar + argn : fpr + argn;
+          avaluep[i] = (char *) argp;
+        }
+      else if (arg_types[i]->type == FFI_TYPE_COMPLEX && arg_types[i]->elements[0]->type == FFI_TYPE_LONGDOUBLE)
+        {
+	  /* align long double */
+	  argn += ((argn & 0x1)? 1 : 0);
+          argp = (argn >= 8 || i >= cif->mips_nfixedargs || soft_float) ? ar + argn : fpr + argn;
+          avaluep[i] = (char *) argp;
+        }
+      else if (arg_types[i]->type == FFI_TYPE_COMPLEX && arg_types[i]->elements[0]->type == FFI_TYPE_FLOAT)
+        {
+          if (argn >= 8 || i >= cif->mips_nfixedargs || soft_float)
+	     argp = ar + argn;
+	  else
+	    {
+	      argp = fpr + argn;
+	      /* the normal args for function holds 8bytes, while here we convert it to ptr */
+	      uint32_t *tmp = (uint32_t *)argp;
+	      tmp[1] = tmp[2];
+	    }
+          avaluep[i] = (char *) argp;
+        }
       else
         {
           unsigned type = arg_types[i]->type;
@@ -1027,10 +1202,10 @@ ffi_closure_mips_inner_N32 (ffi_cif *cif,
           /* The size of a pointer depends on the ABI */
           if (type == FFI_TYPE_POINTER)
             type = (cif->abi == FFI_N64 || cif->abi == FFI_N64_SOFT_FLOAT)
-	      ? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
+	      ? FFI_TYPE_SINT64 : FFI_TYPE_UINT32;
 
 	  if (soft_float && type ==  FFI_TYPE_FLOAT)
-	    type = FFI_TYPE_UINT32;
+	    type = FFI_TYPE_SINT32;
 
           switch (type)
             {

data/ext/ffi_c/libffi/src/mips/ffitarget.h

@@ -80,6 +80,7 @@
 #  endif
 #endif
 
+#define FFI_TARGET_HAS_COMPLEX_TYPE 1
 #define FFI_FLAG_BITS 2
 
 /* SGI's strange assembler requires that we multiply by 4 rather 
@@ -111,6 +112,12 @@
 #define FFI_TYPE_STRUCT_SMALL  93
 #define FFI_TYPE_STRUCT_SMALL2 109
 
+#define FFI_TYPE_COMPLEX_SMALL    95
+#define FFI_TYPE_COMPLEX_SMALL2   111
+#define FFI_TYPE_COMPLEX_FF       47
+#define FFI_TYPE_COMPLEX_DD       63
+#define FFI_TYPE_COMPLEX_LDLD     79
+
 /* and for n32 soft float, add 16 * 2^4 */
 #define FFI_TYPE_STRUCT_D_SOFT      317
 #define FFI_TYPE_STRUCT_F_SOFT      301