ffi 1.1.2 → 1.17.0

data/ext/ffi_c/libffi/testsuite/{libffi.call/closure_stdcall.c → libffi.closures/closure_simple.c}

@@ -1,15 +1,14 @@
-/* Area:	closure_call (stdcall convention)
-   Purpose:	Check handling when caller expects stdcall callee
+/* Area:	closure_call
+   Purpose:	Check simple closure handling with all ABIs
    Limitations:	none.
    PR:		none.
    Originator:	<twalljava@dev.java.net> */
 
-/* { dg-do run { target i?86-*-cygwin* i?86-*-mingw* } } */
+/* { dg-do run } */
 #include "ffitest.h"
 
 static void
-closure_test_stdcall(ffi_cif* cif __UNUSED__, void* resp, void** args,
-		 void* userdata)
+closure_test(ffi_cif* cif __UNUSED__, void* resp, void** args, void* userdata)
 {
   *(ffi_arg*)resp =
     (int)*(int *)args[0] + (int)(*(int *)args[1])
@@ -21,9 +20,14 @@ closure_test_stdcall(ffi_cif* cif __UNUSED__, void* resp, void** args,
 	 (int)(*(int *)args[2]), (int)(*(int *)args[3]),
          (int)*(ffi_arg *)resp);
 
+  CHECK((int)*(int *)args[0] == 0);
+  CHECK((int)*(int *)args[1] == 1);
+  CHECK((int)*(int *)args[2] == 2);
+  CHECK((int)*(int *)args[3] == 3);
+  CHECK((int)*(ffi_arg *)resp == 9);
 }
 
-typedef int (__stdcall *closure_test_type0)(int, int, int, int);
+typedef int (ABI_ATTR *closure_test_type0)(int, int, int, int);
 
 int main (void)
 {
@@ -32,9 +36,6 @@ int main (void)
   ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
   ffi_type * cl_arg_types[17];
   int res;
-  void* sp_pre;
-  void* sp_post;
-  char buf[1024];
 
   cl_arg_types[0] = &ffi_type_uint;
   cl_arg_types[1] = &ffi_type_uint;
@@ -43,22 +44,18 @@ int main (void)
   cl_arg_types[4] = NULL;
 
   /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, FFI_STDCALL, 4,
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 4,
 		     &ffi_type_sint, cl_arg_types) == FFI_OK);
 
-  CHECK(ffi_prep_closure_loc(pcl, &cif, closure_test_stdcall,
+  CHECK(ffi_prep_closure_loc(pcl, &cif, closure_test,
                              (void *) 3 /* userdata */, code) == FFI_OK);
 
-  asm volatile (" movl %%esp,%0" : "=g" (sp_pre));
   res = (*(closure_test_type0)code)(0, 1, 2, 3);
-  asm volatile (" movl %%esp,%0" : "=g" (sp_post));
   /* { dg-output "0 1 2 3: 9" } */
 
   printf("res: %d\n",res);
   /* { dg-output "\nres: 9" } */
+  CHECK(res == 9);
 
-  sprintf(buf, "mismatch: pre=%p vs post=%p", sp_pre, sp_post);
-  printf("stack pointer %s\n", (sp_pre == sp_post ? "match" : buf));
-  /* { dg-output "\nstack pointer match" } */
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_12byte.c

@@ -25,6 +25,17 @@ cls_struct_12byte cls_struct_12byte_fn(struct cls_struct_12byte b1,
   printf("%d %d %d %d %d %d: %d %d %d\n", b1.a, b1.b, b1.c, b2.a, b2.b, b2.c,
 	 result.a, result.b, result.c);
 
+  CHECK(b1.a == 7);
+  CHECK(b1.b == 4);
+  CHECK(b1.c == 9);
+
+  CHECK(b2.a == 1);
+  CHECK(b2.b == 5);
+  CHECK(b2.c == 3);
+
+  CHECK(result.a == 8);
+  CHECK(result.b == 9);
+  CHECK(result.c == 12);
   return result;
 }
 
@@ -49,15 +60,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
+  struct cls_struct_12byte h_dbl = { 7, 4, 9 };
+  struct cls_struct_12byte j_dbl = { 1, 5, 3 };
+  struct cls_struct_12byte 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;
 
-  struct cls_struct_12byte h_dbl = { 7, 4, 9 };
-  struct cls_struct_12byte j_dbl = { 1, 5, 3 };
-  struct cls_struct_12byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_sint;
   cls_struct_fields[1] = &ffi_type_sint;
   cls_struct_fields[2] = &ffi_type_sint;
@@ -78,6 +89,9 @@ int main (void)
   /* { dg-output "7 4 9 1 5 3: 8 9 12" } */
   printf("res: %d %d %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 8 9 12" } */
+  CHECK(res_dbl.a == 8);
+  CHECK(res_dbl.b == 9);
+  CHECK(res_dbl.c == 12);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_12byte_gn, NULL, code) == FFI_OK);
 
@@ -87,8 +101,12 @@ int main (void)
 
   res_dbl = ((cls_struct_12byte(*)(cls_struct_12byte, cls_struct_12byte))(code))(h_dbl, j_dbl);
   /* { dg-output "\n7 4 9 1 5 3: 8 9 12" } */
+
   printf("res: %d %d %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 8 9 12" } */
+  CHECK(res_dbl.a == 8);
+  CHECK(res_dbl.b == 9);
+  CHECK(res_dbl.c == 12);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_16byte.c

@@ -26,6 +26,19 @@ cls_struct_16byte cls_struct_16byte_fn(struct cls_struct_16byte b1,
   printf("%d %g %d %d %g %d: %d %g %d\n", b1.a, b1.b, b1.c, b2.a, b2.b, b2.c,
 	 result.a, result.b, result.c);
 
+  CHECK(b1.a == 7);
+  CHECK(b1.b == 8);
+  CHECK(b1.c == 9);
+
+  CHECK(b2.a == 1);
+  CHECK(b2.b == 9);
+  CHECK(b2.c == 3);
+
+  CHECK(result.a == 8);
+  CHECK(result.b == 17);
+  CHECK(result.c == 12);
+
+
   return result;
 }
 
@@ -50,15 +63,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
+  struct cls_struct_16byte h_dbl = { 7, 8.0, 9 };
+  struct cls_struct_16byte j_dbl = { 1, 9.0, 3 };
+  struct cls_struct_16byte 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;
 
-  struct cls_struct_16byte h_dbl = { 7, 8.0, 9 };
-  struct cls_struct_16byte j_dbl = { 1, 9.0, 3 };
-  struct cls_struct_16byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_sint;
   cls_struct_fields[1] = &ffi_type_double;
   cls_struct_fields[2] = &ffi_type_sint;
@@ -80,6 +93,10 @@ int main (void)
   printf("res: %d %g %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 8 17 12" } */
 
+  CHECK(res_dbl.a == 8);
+  CHECK(res_dbl.b == 17);
+  CHECK(res_dbl.c == 12);
+
   res_dbl.a = 0;
   res_dbl.b = 0.0;
   res_dbl.c = 0;
@@ -91,5 +108,10 @@ int main (void)
   printf("res: %d %g %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 8 17 12" } */
 
+  CHECK(res_dbl.a == 8);
+  CHECK(res_dbl.b == 17);
+  CHECK(res_dbl.c == 12);
+
+
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_18byte.c

@@ -29,6 +29,22 @@ cls_struct_18byte cls_struct_18byte_fn(struct cls_struct_18byte a1,
   printf("%g %d %d %g %g %d %d %g: %g %d %d %g\n", a1.a, a1.b, a1.c, a1.d,
 	 a2.a, a2.b, a2.c, a2.d,
 	 result.a, result.b, result.c, result.d);
+
+  CHECK(a1.a == 1);
+  CHECK(a1.b == 127);
+  CHECK(a1.c == 126);
+  CHECK(a1.d == 3);
+
+  CHECK(a2.a == 4);
+  CHECK(a2.b == 125);
+  CHECK(a2.c == 124);
+  CHECK(a2.d == 5);
+
+  CHECK(result.a == 5);
+  CHECK(result.b == 252);
+  CHECK(result.c == 250);
+  CHECK(result.d == 8);
+
   return result;
 }
 
@@ -54,15 +70,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[3];
 
+  struct cls_struct_18byte g_dbl = { 1.0, 127, 126, 3.0 };
+  struct cls_struct_18byte f_dbl = { 4.0, 125, 124, 5.0 };
+  struct cls_struct_18byte 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;
 
-  struct cls_struct_18byte g_dbl = { 1.0, 127, 126, 3.0 };
-  struct cls_struct_18byte f_dbl = { 4.0, 125, 124, 5.0 };
-  struct cls_struct_18byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_double;
   cls_struct_fields[1] = &ffi_type_uchar;
   cls_struct_fields[2] = &ffi_type_uchar;
@@ -84,6 +100,10 @@ int main (void)
   /* { dg-output "1 127 126 3 4 125 124 5: 5 252 250 8" } */
   printf("res: %g %d %d %g\n", res_dbl.a, res_dbl.b, res_dbl.c, res_dbl.d);
   /* { dg-output "\nres: 5 252 250 8" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 252);
+  CHECK(res_dbl.c == 250);
+  CHECK(res_dbl.d == 8);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_18byte_gn, NULL, code) == FFI_OK);
 
@@ -91,6 +111,10 @@ int main (void)
   /* { dg-output "\n1 127 126 3 4 125 124 5: 5 252 250 8" } */
   printf("res: %g %d %d %g\n", res_dbl.a, res_dbl.b, res_dbl.c, res_dbl.d);
   /* { dg-output "\nres: 5 252 250 8" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 252);
+  CHECK(res_dbl.c == 250);
+  CHECK(res_dbl.d == 8);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_19byte.c

@@ -32,6 +32,25 @@ cls_struct_19byte cls_struct_19byte_fn(struct cls_struct_19byte a1,
 	 a1.a, a1.b, a1.c, a1.d, a1.e,
 	 a2.a, a2.b, a2.c, a2.d, a2.e,
 	 result.a, result.b, result.c, result.d, result.e);
+
+  CHECK(a1.a == 1);
+  CHECK(a1.b == 127);
+  CHECK(a1.c == 126);
+  CHECK(a1.d == 3);
+  CHECK(a1.e == 120);
+
+  CHECK(a2.a == 4);
+  CHECK(a2.b == 125);
+  CHECK(a2.c == 124);
+  CHECK(a2.d == 5);
+  CHECK(a2.e == 119);
+
+  CHECK(result.a == 5);
+  CHECK(result.b == 252);
+  CHECK(result.c == 250);
+  CHECK(result.d == 8);
+  CHECK(result.e == 239);
+
   return result;
 }
 
@@ -57,15 +76,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[3];
 
+  struct cls_struct_19byte g_dbl = { 1.0, 127, 126, 3.0, 120 };
+  struct cls_struct_19byte f_dbl = { 4.0, 125, 124, 5.0, 119 };
+  struct cls_struct_19byte 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;
 
-  struct cls_struct_19byte g_dbl = { 1.0, 127, 126, 3.0, 120 };
-  struct cls_struct_19byte f_dbl = { 4.0, 125, 124, 5.0, 119 };
-  struct cls_struct_19byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_double;
   cls_struct_fields[1] = &ffi_type_uchar;
   cls_struct_fields[2] = &ffi_type_uchar;
@@ -89,6 +108,11 @@ int main (void)
   printf("res: %g %d %d %g %d\n", res_dbl.a, res_dbl.b, res_dbl.c,
 	 res_dbl.d, res_dbl.e);
   /* { dg-output "\nres: 5 252 250 8 239" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 252);
+  CHECK(res_dbl.c == 250);
+  CHECK(res_dbl.d == 8);
+  CHECK(res_dbl.e == 239);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_19byte_gn, NULL, code) == FFI_OK);
 
@@ -97,6 +121,11 @@ int main (void)
   printf("res: %g %d %d %g %d\n", res_dbl.a, res_dbl.b, res_dbl.c,
 	 res_dbl.d, res_dbl.e);
   /* { dg-output "\nres: 5 252 250 8 239" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 252);
+  CHECK(res_dbl.c == 250);
+  CHECK(res_dbl.d == 8);
+  CHECK(res_dbl.e == 239);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_1_1byte.c

@@ -23,6 +23,9 @@ cls_struct_1_1byte cls_struct_1_1byte_fn(struct cls_struct_1_1byte a1,
   result.a = a1.a + a2.a;
 
   printf("%d %d: %d\n", a1.a, a2.a, result.a);
+  CHECK(a1.a == 12);
+  CHECK(a2.a == 178);
+  CHECK(result.a == 190);
 
   return  result;
 }
@@ -50,15 +53,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
+  struct cls_struct_1_1byte g_dbl = { 12 };
+  struct cls_struct_1_1byte f_dbl = { 178 };
+  struct cls_struct_1_1byte 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;
 
-  struct cls_struct_1_1byte g_dbl = { 12 };
-  struct cls_struct_1_1byte f_dbl = { 178 };
-  struct cls_struct_1_1byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_uchar;
   cls_struct_fields[1] = NULL;
 
@@ -84,6 +87,7 @@ int main (void)
   /* { dg-output "\n12 178: 190" } */
   printf("res: %d\n", res_dbl.a);
   /* { dg-output "\nres: 190" } */
+  CHECK(res_dbl.a == 190);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_20byte.c

@@ -14,7 +14,7 @@ typedef struct cls_struct_20byte {
   int c;
 } cls_struct_20byte;
 
-cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
+static cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
 			    struct cls_struct_20byte a2)
 {
   struct cls_struct_20byte result;
@@ -25,6 +25,18 @@ cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
 
   printf("%g %g %d %g %g %d: %g %g %d\n", a1.a, a1.b, a1.c, a2.a, a2.b, a2.c,
 	 result.a, result.b, result.c);
+
+  CHECK(a1.a == 1);
+  CHECK(a1.b == 2);
+  CHECK(a1.c == 3);
+
+  CHECK(a2.a == 4);
+  CHECK(a2.b == 5);
+  CHECK(a2.c == 7);
+
+  CHECK(result.a == 5);
+  CHECK(result.b == 7);
+  CHECK(result.c == 10);
   return result;
 }
 
@@ -50,15 +62,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
+  struct cls_struct_20byte g_dbl = { 1.0, 2.0, 3 };
+  struct cls_struct_20byte f_dbl = { 4.0, 5.0, 7 };
+  struct cls_struct_20byte 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;
 
-  struct cls_struct_20byte g_dbl = { 1.0, 2.0, 3 };
-  struct cls_struct_20byte f_dbl = { 4.0, 5.0, 7 };
-  struct cls_struct_20byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_double;
   cls_struct_fields[1] = &ffi_type_double;
   cls_struct_fields[2] = &ffi_type_sint;
@@ -79,6 +91,9 @@ int main (void)
   /* { dg-output "1 2 3 4 5 7: 5 7 10" } */
   printf("res: %g %g %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 5 7 10" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 7);
+  CHECK(res_dbl.c == 10);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_20byte_gn, NULL, code) == FFI_OK);
 
@@ -86,6 +101,9 @@ int main (void)
   /* { dg-output "\n1 2 3 4 5 7: 5 7 10" } */
   printf("res: %g %g %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 5 7 10" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 7);
+  CHECK(res_dbl.c == 10);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_20byte1.c

@@ -16,7 +16,7 @@ typedef struct cls_struct_20byte {
   double c;
 } cls_struct_20byte;
 
-cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
+static cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
 			    struct cls_struct_20byte a2)
 {
   struct cls_struct_20byte result;
@@ -27,6 +27,19 @@ cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
 
   printf("%d %g %g %d %g %g: %d %g %g\n", a1.a, a1.b, a1.c, a2.a, a2.b, a2.c,
 	 result.a, result.b, result.c);
+
+  CHECK(a1.a == 1);
+  CHECK(a1.b == 2);
+  CHECK(a1.c == 3);
+
+  CHECK(a2.a == 4);
+  CHECK(a2.b == 5);
+  CHECK(a2.c == 7);
+
+  CHECK(result.a == 5);
+  CHECK(result.b == 7);
+  CHECK(result.c == 10);
+
   return result;
 }
 
@@ -52,15 +65,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[3];
 
+  struct cls_struct_20byte g_dbl = { 1, 2.0, 3.0 };
+  struct cls_struct_20byte f_dbl = { 4, 5.0, 7.0 };
+  struct cls_struct_20byte 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;
 
-  struct cls_struct_20byte g_dbl = { 1, 2.0, 3.0 };
-  struct cls_struct_20byte f_dbl = { 4, 5.0, 7.0 };
-  struct cls_struct_20byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_sint;
   cls_struct_fields[1] = &ffi_type_double;
   cls_struct_fields[2] = &ffi_type_double;
@@ -81,6 +94,9 @@ int main (void)
   /* { dg-output "1 2 3 4 5 7: 5 7 10" } */
   printf("res: %d %g %g\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 5 7 10" } */
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 7);
+  CHECK(res_dbl.c == 10);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_20byte_gn, NULL, code) == FFI_OK);
 
@@ -89,5 +105,9 @@ int main (void)
   printf("res: %d %g %g\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 5 7 10" } */
 
+  CHECK(res_dbl.a == 5);
+  CHECK(res_dbl.b == 7);
+  CHECK(res_dbl.c == 10);
+
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_24byte.c

@@ -31,8 +31,32 @@ cls_struct_24byte cls_struct_24byte_fn(struct cls_struct_24byte b0,
 	 b0.a, b0.b, b0.c, b0.d,
 	 b1.a, b1.b, b1.c, b1.d,
 	 b2.a, b2.b, b2.c, b2.d,
-	 b3.a, b3.b, b3.c, b2.d,
+	 b3.a, b3.b, b3.c, b3.d,
 	 result.a, result.b, result.c, result.d);
+  CHECK_DOUBLE_EQ(b0.a, 9);
+  CHECK_DOUBLE_EQ(b0.b, 2);
+  CHECK(b0.c == 6);
+  CHECK_FLOAT_EQ(b0.d, 5);
+
+  CHECK_DOUBLE_EQ(b1.a, 1);
+  CHECK_DOUBLE_EQ(b1.b, 2);
+  CHECK(b1.c == 3);
+  CHECK_FLOAT_EQ(b1.d, 7);
+
+  CHECK_DOUBLE_EQ(b2.a, 4);
+  CHECK_DOUBLE_EQ(b2.b, 5);
+  CHECK(b2.c == 7);
+  CHECK_FLOAT_EQ(b2.d, 9);
+
+  CHECK_DOUBLE_EQ(b3.a, 8);
+  CHECK_DOUBLE_EQ(b3.b, 6);
+  CHECK(b3.c == 1);
+  CHECK_FLOAT_EQ(b3.d, 4);
+
+  CHECK_DOUBLE_EQ(result.a, 22);
+  CHECK_DOUBLE_EQ(result.b, 15);
+  CHECK(result.c == 17);
+  CHECK_FLOAT_EQ(result.d, 25);
 
   return result;
 }
@@ -61,17 +85,17 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
-  cls_struct_type.size = 0;
-  cls_struct_type.alignment = 0;
-  cls_struct_type.type = FFI_TYPE_STRUCT;
-  cls_struct_type.elements = cls_struct_fields;
-
   struct cls_struct_24byte e_dbl = { 9.0, 2.0, 6, 5.0 };
   struct cls_struct_24byte f_dbl = { 1.0, 2.0, 3, 7.0 };
   struct cls_struct_24byte g_dbl = { 4.0, 5.0, 7, 9.0 };
   struct cls_struct_24byte h_dbl = { 8.0, 6.0, 1, 4.0 };
   struct cls_struct_24byte 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_double;
   cls_struct_fields[1] = &ffi_type_double;
   cls_struct_fields[2] = &ffi_type_sint;
@@ -94,9 +118,13 @@ int main (void)
   args_dbl[4] = NULL;
 
   ffi_call(&cif, FFI_FN(cls_struct_24byte_fn), &res_dbl, args_dbl);
-  /* { dg-output "9 2 6 5 1 2 3 7 4 5 7 9 8 6 1 9: 22 15 17 25" } */
+  /* { dg-output "9 2 6 5 1 2 3 7 4 5 7 9 8 6 1 4: 22 15 17 25" } */
   printf("res: %g %g %d %g\n", res_dbl.a, res_dbl.b, res_dbl.c, res_dbl.d);
   /* { dg-output "\nres: 22 15 17 25" } */
+  CHECK_DOUBLE_EQ(res_dbl.a, 22);
+  CHECK_DOUBLE_EQ(res_dbl.b, 15);
+  CHECK(res_dbl.c == 17);
+  CHECK_FLOAT_EQ(res_dbl.d, 25);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_24byte_gn, NULL, code) == FFI_OK);
 
@@ -105,9 +133,13 @@ int main (void)
 				   cls_struct_24byte,
 				   cls_struct_24byte))
 	     (code))(e_dbl, f_dbl, g_dbl, h_dbl);
-  /* { dg-output "\n9 2 6 5 1 2 3 7 4 5 7 9 8 6 1 9: 22 15 17 25" } */
+  /* { dg-output "\n9 2 6 5 1 2 3 7 4 5 7 9 8 6 1 4: 22 15 17 25" } */
   printf("res: %g %g %d %g\n", res_dbl.a, res_dbl.b, res_dbl.c, res_dbl.d);
   /* { dg-output "\nres: 22 15 17 25" } */
+  CHECK_DOUBLE_EQ(res_dbl.a, 22);
+  CHECK_DOUBLE_EQ(res_dbl.b, 15);
+  CHECK(res_dbl.c == 17);
+  CHECK_FLOAT_EQ(res_dbl.d, 25);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_2byte.c

@@ -24,6 +24,15 @@ cls_struct_2byte cls_struct_2byte_fn(struct cls_struct_2byte a1,
 
   printf("%d %d %d %d: %d %d\n", a1.a, a1.b, a2.a, a2.b, result.a, result.b);
 
+  CHECK(a1.a == 12);
+  CHECK(a1.b == 127);
+
+  CHECK(a2.a == 1);
+  CHECK(a2.b == 13);
+
+  CHECK(result.a == 13);
+  CHECK(result.b == 140);
+
   return  result;
 }
 
@@ -50,15 +59,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
+  struct cls_struct_2byte g_dbl = { 12, 127 };
+  struct cls_struct_2byte f_dbl = { 1, 13 };
+  struct cls_struct_2byte 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;
 
-  struct cls_struct_2byte g_dbl = { 12, 127 };
-  struct cls_struct_2byte f_dbl = { 1, 13 };
-  struct cls_struct_2byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_uchar;
   cls_struct_fields[1] = &ffi_type_uchar;
   cls_struct_fields[2] = NULL;
@@ -78,6 +87,8 @@ int main (void)
   /* { dg-output "12 127 1 13: 13 140" } */
   printf("res: %d %d\n", res_dbl.a, res_dbl.b);
   /* { dg-output "\nres: 13 140" } */
+  CHECK(res_dbl.a == 13);
+  CHECK(res_dbl.b == 140);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_2byte_gn, NULL, code) == FFI_OK);
 
@@ -85,6 +96,8 @@ int main (void)
   /* { dg-output "\n12 127 1 13: 13 140" } */
   printf("res: %d %d\n", res_dbl.a, res_dbl.b);
   /* { dg-output "\nres: 13 140" } */
+  CHECK(res_dbl.a == 13);
+  CHECK(res_dbl.b == 140);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/cls_3_1byte.c

@@ -28,6 +28,18 @@ cls_struct_3_1byte cls_struct_3_1byte_fn(struct cls_struct_3_1byte a1,
 	 a2.a, a2.b, a2.c,
 	 result.a, result.b, result.c);
 
+  CHECK(a1.a == 12);
+  CHECK(a1.b == 13);
+  CHECK(a1.c == 14);
+
+  CHECK(a2.a == 178);
+  CHECK(a2.b == 179);
+  CHECK(a2.c == 180);
+
+  CHECK(result.a == 190);
+  CHECK(result.b == 192);
+  CHECK(result.c == 194);
+
   return  result;
 }
 
@@ -54,15 +66,15 @@ int main (void)
   ffi_type cls_struct_type;
   ffi_type* dbl_arg_types[5];
 
+  struct cls_struct_3_1byte g_dbl = { 12, 13, 14 };
+  struct cls_struct_3_1byte f_dbl = { 178, 179, 180 };
+  struct cls_struct_3_1byte 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;
 
-  struct cls_struct_3_1byte g_dbl = { 12, 13, 14 };
-  struct cls_struct_3_1byte f_dbl = { 178, 179, 180 };
-  struct cls_struct_3_1byte res_dbl;
-
   cls_struct_fields[0] = &ffi_type_uchar;
   cls_struct_fields[1] = &ffi_type_uchar;
   cls_struct_fields[2] = &ffi_type_uchar;
@@ -83,6 +95,9 @@ int main (void)
   /* { dg-output "12 13 14 178 179 180: 190 192 194" } */
   printf("res: %d %d %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 190 192 194" } */
+  CHECK(res_dbl.a == 190);
+  CHECK(res_dbl.b == 192);
+  CHECK(res_dbl.c == 194);
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_3_1byte_gn, NULL, code) == FFI_OK);
 
@@ -91,5 +106,9 @@ int main (void)
   printf("res: %d %d %d\n", res_dbl.a, res_dbl.b, res_dbl.c);
   /* { dg-output "\nres: 190 192 194" } */
 
+  CHECK(res_dbl.a == 190);
+  CHECK(res_dbl.b == 192);
+  CHECK(res_dbl.c == 194);
+
   exit(0);
 }