ffi 1.15.4 → 1.16.3

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct11.c

@@ -35,6 +35,13 @@ static C C_fn (int x, int y, int z, C source, int i, int j, int k)
 
   printf ("%d, %d, %d, %d, %d, %d\n", x, y, z, i, j, k);
 
+  CHECK(x == 1);
+  CHECK(y == 1);
+  CHECK(z == 1);
+  CHECK(i == 1);
+  CHECK(j == 1);
+  CHECK(k == 1);
+
   printf ("%.1f, %.1f, %.1f, %.1f, "
 	  "%.1f, %.1f, %.1f, %.1f\n",
 	  source.a.a_x, source.a.a_y,
@@ -42,6 +49,15 @@ static C C_fn (int x, int y, int z, C source, int i, int j, int k)
 	  result.a.a_x, result.a.a_y,
 	  result.b.b_x, result.b.b_y);
 
+    CHECK_FLOAT_EQ(source.a.a_x, 1.0);
+    CHECK_FLOAT_EQ(source.a.a_y, 2.0);
+    CHECK_FLOAT_EQ(source.b.b_x, 4.0);
+    CHECK_FLOAT_EQ(source.b.b_y, 8.0);
+    CHECK_FLOAT_EQ(result.a.a_x, 1.0);
+    CHECK_FLOAT_EQ(result.a.a_y, 2.0);
+    CHECK_FLOAT_EQ(result.b.b_x, 4.0);
+    CHECK_FLOAT_EQ(result.b.b_y, 8.0);
+
   return result;
 }
 
@@ -113,9 +129,9 @@ int main (void)
   ffi_call (&cif, FFI_FN (C_fn), &result, args);
   /* { dg-output "1, 1, 1, 1, 1, 1\n" } */
   /* { dg-output "1.0, 2.0, 4.0, 8.0, 1.0, 2.0, 4.0, 8.0" } */
-  CHECK (result.a.a_x == source.a.a_x);
-  CHECK (result.a.a_y == source.a.a_y);
-  CHECK (result.b.b_x == source.b.b_x);
-  CHECK (result.b.b_y == source.b.b_y);
-  exit (0);
+  CHECK_FLOAT_EQ(result.a.a_x, source.a.a_x);
+  CHECK_FLOAT_EQ(result.a.a_y, source.a.a_y);
+  CHECK_FLOAT_EQ(result.b.b_x, source.b.b_x);
+  CHECK_FLOAT_EQ(result.b.b_y, source.b.b_y);
+  exit(0);
 }

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct12.c

@@ -0,0 +1,86 @@
+/* Area:	ffi_call
+   Purpose:	Check nested float struct.
+   Limitations:	none.
+   PR:		none.
+   Originator:	Cheng Jin <jincheng@ca.ibm.com>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct stru_FF stru_FF;
+typedef struct stru_Nested_F stru_Nested_F;
+
+struct stru_FF {
+	float elem1;
+	float elem2;
+};
+
+struct stru_Nested_F {
+	float elem1;
+	stru_FF elem2;
+};
+
+static float testNestedFloatStruct(float arg1, stru_Nested_F arg2)
+{
+	float floatSum = arg1 + arg2.elem1 + arg2.elem2.elem1 + arg2.elem2.elem2;
+	return floatSum;
+}
+
+int main (void)
+{
+	float ts12_result = 0;
+	int structElemNum = 2;
+	int nestedStructElemNum = 2;
+	int argNum = 2;
+
+	ffi_cif cif;
+	ffi_type **struct_float1 = (ffi_type **)malloc(sizeof(ffi_type *) * (structElemNum + 1));
+	ffi_type **struct_float2 = (ffi_type **)malloc(sizeof(ffi_type *) * (nestedStructElemNum + 1));
+	ffi_type **args = (ffi_type **)malloc(sizeof(ffi_type *) * (argNum + 1));
+	void **values = (void **)malloc(sizeof(void *) * (argNum + 1));
+	ffi_type struct_float_type1, struct_float_type2;
+	ffi_type *retType = &ffi_type_float;
+	float arg1;
+	float *arg2 = (float *)malloc(sizeof(stru_Nested_F));
+
+	struct_float2[0] = &ffi_type_float;
+	struct_float2[1] = &ffi_type_float;
+	struct_float2[2] = NULL;
+
+	struct_float_type2.size = 0;
+	struct_float_type2.alignment = 0;
+	struct_float_type2.type = FFI_TYPE_STRUCT;
+	struct_float_type2.elements = struct_float2;
+
+	struct_float1[0] = &ffi_type_float;
+	struct_float1[1] = &struct_float_type2;
+	struct_float1[2] = NULL;
+
+	struct_float_type1.size = 0;
+	struct_float_type1.alignment = 0;
+	struct_float_type1.type = FFI_TYPE_STRUCT;
+	struct_float_type1.elements = struct_float1;
+
+	args[0] = &ffi_type_float;
+	args[1] = &struct_float_type1;
+	args[2] = NULL;
+
+	arg1 = 37.88;
+	arg2[0] = 31.22;
+	arg2[1] = 33.44;
+	arg2[2] = 35.66;
+	values[0] = &arg1;
+	values[1] = arg2;
+	values[2] = NULL;
+
+	CHECK( ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, retType, args) == FFI_OK);
+	ffi_call(&cif, FFI_FN(testNestedFloatStruct), &ts12_result, values);
+	CHECK_FLOAT_EQ(ts12_result, 138.2f);
+
+	free(struct_float1);
+	free(struct_float2);
+	free(args);
+	free(values);
+
+	exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct13.c

@@ -0,0 +1,115 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Check structure passing.
+   Limitations:        none.
+   PR:         none.
+   Originator: <jincheng@ca.ibm.com> and <jakub@redhat.com> 20210609    */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  float a, b;
+} A;
+
+typedef struct B {
+  float x;
+  struct A y;
+} B;
+
+B B_fn(float b0, struct B b1)
+{
+  struct B result;
+
+  result.x = b0 + b1.x;
+  result.y.a = b0 + b1.y.a;
+  result.y.b = b0 + b1.y.b;
+
+  printf("%g %g %g %g: %g %g %g\n", b0, b1.x, b1.y.a, b1.y.b,
+        result.x, result.y.a, result.y.b);
+
+  CHECK_FLOAT_EQ(b0, 12.125);
+  CHECK_FLOAT_EQ(b1.x, 24.75);
+  CHECK_FLOAT_EQ(b1.y.a, 31.625);
+  CHECK_FLOAT_EQ(b1.y.b, 32.25);
+  CHECK_FLOAT_EQ(result.x, 36.875);
+  CHECK_FLOAT_EQ(result.y.a, 43.75);
+  CHECK_FLOAT_EQ(result.y.b, 44.375);
+
+  return result;
+}
+
+static void
+B_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  float b0;
+  struct B b1;
+
+  b0 = *(float*)(args[0]);
+  b1 = *(struct B*)(args[1]);
+
+  *(B*)resp = B_fn(b0, b1);
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[3];
+  ffi_type* cls_struct_fields1[3];
+  ffi_type cls_struct_type, cls_struct_type1;
+  ffi_type* dbl_arg_types[3];
+
+  float e_dbl = 12.125f;
+  struct B f_dbl = { 24.75f, { 31.625f, 32.25f } };
+
+  struct B res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_type1.size = 0;
+  cls_struct_type1.alignment = 0;
+  cls_struct_type1.type = FFI_TYPE_STRUCT;
+  cls_struct_type1.elements = cls_struct_fields1;
+
+  cls_struct_fields[0] = &ffi_type_float;
+  cls_struct_fields[1] = &ffi_type_float;
+  cls_struct_fields[2] = NULL;
+
+  cls_struct_fields1[0] = &ffi_type_float;
+  cls_struct_fields1[1] = &cls_struct_type;
+  cls_struct_fields1[2] = NULL;
+
+
+  dbl_arg_types[0] = &ffi_type_float;
+  dbl_arg_types[1] = &cls_struct_type1;
+  dbl_arg_types[2] = NULL;
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type1,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+  ffi_call(&cif, FFI_FN(B_fn), &res_dbl, args_dbl);
+  /* { dg-output "12.125 24.75 31.625 32.25: 36.875 43.75 44.375" } */
+  CHECK_FLOAT_EQ( res_dbl.x, (e_dbl + f_dbl.x));
+  CHECK_FLOAT_EQ( res_dbl.y.a, (e_dbl + f_dbl.y.a));
+  CHECK_FLOAT_EQ( res_dbl.y.b, (e_dbl + f_dbl.y.b));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, B_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((B(*)(float, B))(code))(e_dbl, f_dbl);
+  /* { dg-output "\n12.125 24.75 31.625 32.25: 36.875 43.75 44.375" } */
+  CHECK_FLOAT_EQ( res_dbl.x, (e_dbl + f_dbl.x));
+  CHECK_FLOAT_EQ( res_dbl.y.a, (e_dbl + f_dbl.y.a));
+  CHECK_FLOAT_EQ( res_dbl.y.b, (e_dbl + f_dbl.y.b));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct2.c

@@ -19,7 +19,7 @@ typedef struct B {
   unsigned char y;
 } B;
 
-B B_fn(struct A b0, struct B b1)
+static B B_fn(struct A b0, struct B b1)
 {
   struct B result;
 
@@ -30,6 +30,15 @@ B B_fn(struct A b0, struct B b1)
   printf("%lu %d %lu %d %d: %lu %d %d\n", b0.a, b0.b, b1.x.a, b1.x.b, b1.y,
 	 result.x.a, result.x.b, result.y);
 
+  CHECK(b0.a == 1);
+  CHECK(b0.b == 7);
+  CHECK(b1.x.a == 12);
+  CHECK(b1.x.b == 127);
+  CHECK(b1.y == 99);
+  CHECK(result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct3.c

@@ -19,7 +19,7 @@ typedef struct B {
   unsigned char y;
 } B;
 
-B B_fn(struct A b0, struct B b1)
+static B B_fn(struct A b0, struct B b1)
 {
   struct B result;
 
@@ -31,6 +31,15 @@ B B_fn(struct A b0, struct B b1)
 	 (int)b1.x.a, b1.x.b, b1.y,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b0.a == 1);
+  CHECK(b0.b == 7);
+  CHECK((int)b1.x.a == 12);
+  CHECK(b1.x.b == 127);
+  CHECK(b1.y == 99);
+  CHECK((int)result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct4.c

@@ -31,6 +31,15 @@ static B B_fn(struct A b2, struct B b3)
 	 (int)b3.x.a, b3.x.b, b3.y,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct5.c

@@ -31,6 +31,15 @@ static B B_fn(struct A b2, struct B b3)
 	 (int)b3.x.a, b3.x.b, b3.y,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct6.c

@@ -36,6 +36,17 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 (int)b3.x.a, b3.x.b, b3.y, (int)b4.d, b4.e,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)b4.d == 2);
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 15);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct7.c

@@ -31,6 +31,15 @@ static B B_fn(struct A b2, struct B b3)
 	 (int)b3.x.a, b3.x.b, b3.y,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct8.c

@@ -36,6 +36,17 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 (int)b3.x.a, b3.x.b, b3.y, (int)b4.d, b4.e,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)b4.d == 2);
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 15);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct9.c

@@ -36,6 +36,17 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 b3.x.a, (int)b3.x.b, b3.y, (int)b4.d, b4.e,
 	 result.x.a, (int)result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)b4.d == 2); 
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 15);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+  
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs1.c

@@ -0,0 +1,86 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Single argument structs have a different ABI in emscripten.
+   Limitations:        none.
+   PR:         none.
+   Originator: <hood@mit.edu>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  int a;
+} A;
+
+static struct A A_fn(int b0, struct A b1)
+{
+  b1.a += b0;
+  return b1;
+}
+
+static void
+A_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  int b0;
+  struct A b1;
+
+  b0 = *(int*)(args[0]);
+  b1 = *(struct A*)(args[1]);
+
+  *(A*)resp = A_fn(b0, b1);
+}
+
+int main (void)
+{
+  printf("123\n");
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[2];
+  ffi_type cls_struct_type;
+  ffi_type* dbl_arg_types[3];
+
+  int e_dbl = 12125;
+  struct A f_dbl = { 31625 };
+
+  struct A res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_fields[0] = &ffi_type_sint;
+  cls_struct_fields[1] = NULL;
+
+  dbl_arg_types[0] = &ffi_type_sint;
+  dbl_arg_types[1] = &cls_struct_type;
+  dbl_arg_types[2] = NULL;
+
+  res_dbl = A_fn(e_dbl, f_dbl);
+  printf("0 res: %d\n", res_dbl.a);
+  /* { dg-output "0 res: 43750" } */
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+
+  ffi_call(&cif, FFI_FN(A_fn), &res_dbl, args_dbl);
+  printf("1 res: %d\n", res_dbl.a);
+  /* { dg-output "\n1 res: 43750" } */
+  CHECK( res_dbl.a == (e_dbl + f_dbl.a));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, A_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((A(*)(int, A))(code))(e_dbl, f_dbl);
+  printf("2 res: %d\n", res_dbl.a);
+  /* { dg-output "\n2 res: 43750" } */
+  CHECK( res_dbl.a == (e_dbl + f_dbl.a));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs2.c

@@ -0,0 +1,102 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Single argument structs have a different ABI in emscripten.
+   Limitations:        none.
+   PR:         none.
+   Originator: <hood@mit.edu>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  int a, b;
+} A;
+
+typedef struct B {
+  struct A y;
+} B;
+
+static struct B B_fn(int b0, struct B b1)
+{
+  b1.y.a += b0;
+  b1.y.b -= b0;
+  return b1;
+}
+
+static void
+B_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  int b0;
+  struct B b1;
+
+  b0 = *(int*)(args[0]);
+  b1 = *(struct B*)(args[1]);
+
+  *(B*)resp = B_fn(b0, b1);
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[3];
+  ffi_type* cls_struct_fields1[2];
+  ffi_type cls_struct_type, cls_struct_type1;
+  ffi_type* dbl_arg_types[3];
+
+  int e_dbl = 12125;
+  struct B f_dbl = { { 31625, 16723 } };
+
+  struct B res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_type1.size = 0;
+  cls_struct_type1.alignment = 0;
+  cls_struct_type1.type = FFI_TYPE_STRUCT;
+  cls_struct_type1.elements = cls_struct_fields1;
+
+  cls_struct_fields[0] = &ffi_type_sint;
+  cls_struct_fields[1] = &ffi_type_sint;
+  cls_struct_fields[2] = NULL;
+
+  cls_struct_fields1[0] = &cls_struct_type;
+  cls_struct_fields1[1] = NULL;
+
+
+  dbl_arg_types[0] = &ffi_type_sint;
+  dbl_arg_types[1] = &cls_struct_type1;
+  dbl_arg_types[2] = NULL;
+
+  res_dbl = B_fn(e_dbl, f_dbl);
+  printf("0 res: %d %d\n", res_dbl.y.a, res_dbl.y.b);
+  /* { dg-output "0 res: 43750 4598" } */
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type1,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+  ffi_call(&cif, FFI_FN(B_fn), &res_dbl, args_dbl);
+  printf("1 res: %d %d\n", res_dbl.y.a, res_dbl.y.b);
+  /* { dg-output "\n1 res: 43750 4598" } */
+  CHECK( res_dbl.y.a == (f_dbl.y.a + e_dbl));
+  CHECK( res_dbl.y.b == (f_dbl.y.b - e_dbl));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, B_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((B(*)(int, B))(code))(e_dbl, f_dbl);
+  printf("2 res: %d %d\n", res_dbl.y.a, res_dbl.y.b);
+  /* { dg-output "\n2 res: 43750 4598" } */
+  CHECK( res_dbl.y.a == (f_dbl.y.a + e_dbl));
+  CHECK( res_dbl.y.b == (f_dbl.y.b - e_dbl));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs3.c

@@ -0,0 +1,101 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Single argument structs have a different ABI in emscripten.
+   Limitations:        none.
+   PR:         none.
+   Originator: <hood@mit.edu>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  int a;
+} A;
+
+typedef struct B {
+  struct A y;
+} B;
+
+static struct B B_fn(int b0, struct B b1)
+{
+  b1.y.a += b0;
+  return b1;
+}
+
+static void
+B_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  int b0;
+  struct B b1;
+
+  b0 = *(int*)(args[0]);
+  b1 = *(struct B*)(args[1]);
+
+  *(B*)resp = B_fn(b0, b1);
+}
+
+int main (void)
+{
+  printf("123\n");
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[2];
+  ffi_type* cls_struct_fields1[2];
+  ffi_type cls_struct_type, cls_struct_type1;
+  ffi_type* dbl_arg_types[3];
+
+  int e_dbl = 12125;
+  struct B f_dbl = { { 31625 } };
+
+  struct B res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_type1.size = 0;
+  cls_struct_type1.alignment = 0;
+  cls_struct_type1.type = FFI_TYPE_STRUCT;
+  cls_struct_type1.elements = cls_struct_fields1;
+
+  cls_struct_fields[0] = &ffi_type_sint;
+  cls_struct_fields[1] = NULL;
+
+  cls_struct_fields1[0] = &cls_struct_type;
+  cls_struct_fields1[1] = NULL;
+
+
+  dbl_arg_types[0] = &ffi_type_sint;
+  dbl_arg_types[1] = &cls_struct_type1;
+  dbl_arg_types[2] = NULL;
+
+  res_dbl = B_fn(e_dbl, f_dbl);
+  printf("0 res: %d\n", res_dbl.y.a);
+  /* { dg-output "0 res: 43750" } */
+
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type1,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+
+  ffi_call(&cif, FFI_FN(B_fn), &res_dbl, args_dbl);
+  printf("1 res: %d\n", res_dbl.y.a);
+  /* { dg-output "\n1 res: 43750" } */
+  CHECK( res_dbl.y.a == (e_dbl + f_dbl.y.a));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, B_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((B(*)(int, B))(code))(e_dbl, f_dbl);
+  printf("2 res: %d\n", res_dbl.y.a);
+  /* { dg-output "\n2 res: 43750" } */
+  CHECK( res_dbl.y.a == (e_dbl + f_dbl.y.a));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/stret_medium.c

@@ -21,7 +21,7 @@ typedef struct struct_72byte {
 	double i;
 } struct_72byte;
 
-struct_72byte cls_struct_72byte_fn(
+static struct_72byte cls_struct_72byte_fn(
 	struct_72byte b0,
 	struct_72byte b1,
 	struct_72byte b2,