ffi 1.9.24 → 1.16.3

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

@@ -13,6 +13,8 @@ static void cls_ret_sint_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
   *(ffi_arg*)resp = *(signed int *)args[0];
   printf("%d: %d\n",*(signed int *)args[0],
 	 (int)*(ffi_arg *)(resp));
+  CHECK(*(signed int *)args[0] == 65534);
+  CHECK((int)*(ffi_arg *)(resp) == 65534);
 }
 typedef signed int (*cls_ret_sint)(signed int);
 

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

@@ -13,6 +13,8 @@ static void cls_ret_sshort_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
   *(ffi_arg*)resp = *(signed short *)args[0];
   printf("%d: %d\n",*(signed short *)args[0],
 	 (int)*(ffi_arg *)(resp));
+  CHECK(*(signed short *)args[0] == 255);
+  CHECK((int)*(ffi_arg *)(resp) == 255);
 }
 typedef signed short (*cls_ret_sshort)(signed short);
 
@@ -37,6 +39,7 @@ int main (void)
   /* { dg-output "255: 255" } */
   printf("res: %d\n",res);
   /* { dg-output "\nres: 255" } */
+  CHECK(res == 255);
 
   exit(0);
 }

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

@@ -35,6 +35,16 @@ test_fn (ffi_cif* cif __UNUSED__, void* resp,
   printf ("%d %d %d %d %d %d %d %d %d %d\n", n, s1.a, s1.b,
 	  l1.a, l1.b, l1.c, l1.d, l1.e,
 	  s2.a, s2.b);
+  CHECK(n == 4);
+  CHECK(s1.a == 5);
+  CHECK(s1.b == 6);
+  CHECK(l1.a == 10);
+  CHECK(l1.b == 11);
+  CHECK(l1.c == 12);
+  CHECK(l1.d == 13);
+  CHECK(l1.e == 14);
+  CHECK(s2.a == 20);
+  CHECK(s2.b == 21);
   * (ffi_arg*) resp = 42;
 }
 
@@ -109,6 +119,7 @@ main (void)
   /* { dg-output "4 5 6 10 11 12 13 14 20 21" } */
   printf("res: %d\n", (int) res);
   /* { dg-output "\nres: 42" } */
+  CHECK(res == 42);
 
   exit(0);
 }

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

@@ -13,6 +13,8 @@ static void cls_ret_uchar_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
   *(ffi_arg*)resp = *(unsigned char *)args[0];
   printf("%d: %d\n",*(unsigned char *)args[0],
 	 (int)*(ffi_arg *)(resp));
+  CHECK(*(unsigned char *)args[0] == 127);
+  CHECK((int)*(ffi_arg *)(resp) == 127);
 }
 typedef unsigned char (*cls_ret_uchar)(unsigned char);
 
@@ -37,6 +39,7 @@ int main (void)
   /* { dg-output "127: 127" } */
   printf("res: %d\n",res);
   /* { dg-output "\nres: 127" } */
+  CHECK(res == 127);
 
   exit(0);
 }

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

@@ -14,6 +14,9 @@ static void cls_ret_uint_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
 
   printf("%d: %d\n",*(unsigned int *)args[0],
 	 (int)*(ffi_arg *)(resp));
+
+  CHECK(*(unsigned int *)args[0] == 2147483647);
+  CHECK((int)*(ffi_arg *)(resp) == 2147483647);
 }
 typedef unsigned int (*cls_ret_uint)(unsigned int);
 
@@ -38,6 +41,7 @@ int main (void)
   /* { dg-output "2147483647: 2147483647" } */
   printf("res: %d\n",res);
   /* { dg-output "\nres: 2147483647" } */
+  CHECK(res == 2147483647);
 
   exit(0);
 }

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

@@ -16,6 +16,9 @@ static void cls_ret_T_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
    *(ffi_arg *)resp = *(T *)args[0];
 
    printf("%d: %d %d\n", (int)*(ffi_arg *)resp, *(T *)args[0], *(T *)args[1]);
+   CHECK(*(T *)args[0] == 67);
+   CHECK(*(T *)args[1] == 4);
+   CHECK((int)*(ffi_arg *)resp == 67);
  }
 
 typedef T (*cls_ret_T)(T, ...);
@@ -41,5 +44,6 @@ int main (void)
   /* { dg-output "67: 67 4" } */
   printf("res: %d\n", res);
   /* { dg-output "\nres: 67" } */
+  CHECK(res == 67);
   exit(0);
 }

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

@@ -16,6 +16,9 @@ static void cls_ret_T_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
    *(T *)resp = *(T *)args[0];
 
    printf("%ld: %ld %ld\n", *(T *)resp, *(T *)args[0], *(T *)args[1]);
+   CHECK(*(T *)args[0] == 67);
+   CHECK(*(T *)args[1] == 4);
+   CHECK(*(T *)resp == 67);
  }
 
 typedef T (*cls_ret_T)(T, ...);
@@ -41,5 +44,6 @@ int main (void)
   /* { dg-output "67: 67 4" } */
   printf("res: %ld\n", res);
   /* { dg-output "\nres: 67" } */
+  CHECK(res == 67);
   exit(0);
 }

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

@@ -37,11 +37,13 @@ int main (void)
   /* { dg-output "214: 1152921504606846761" } */
   printf("res: %" PRIdLL "\n", res);
   /* { dg-output "\nres: 1152921504606846761" } */
+  CHECK(res == 1152921504606846761LL);
 
   res = (*((cls_ret_ulonglong)code))(9223372035854775808LL);
   /* { dg-output "\n9223372035854775808: 8070450533247928831" } */
   printf("res: %" PRIdLL "\n", res);
   /* { dg-output "\nres: 8070450533247928831" } */
+  CHECK(res == 8070450533247928831LL);
 
   exit(0);
 }

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

@@ -14,6 +14,8 @@ static void cls_ret_ushort_fn(ffi_cif* cif __UNUSED__, void* resp, void** args,
 
   printf("%d: %d\n",*(unsigned short *)args[0],
 	 (int)*(ffi_arg *)(resp));
+  CHECK(*(unsigned short *)args[0] == 65535);
+  CHECK((int)*(ffi_arg *)(resp) == 65535);
 }
 typedef unsigned short (*cls_ret_ushort)(unsigned short);
 
@@ -38,6 +40,7 @@ int main (void)
   /* { dg-output "65535: 65535" } */
   printf("res: %d\n",res);
   /* { dg-output "\nres: 65535" } */
+  CHECK(res == 65535);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/libffi.closures/ffitest.h

@@ -0,0 +1 @@
+#include "../libffi.call/ffitest.h"

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

@@ -6,8 +6,10 @@
 */
 
 /* { dg-do run { xfail strongarm*-*-* xscale*-*-* } } */
-/* { dg-options -mlong-double-128 { target powerpc64*-*-linux* } } */
-/* { dg-options -Wformat=0 { target moxie*-*-elf } } */
+/* { dg-options -mlong-double-128 { target powerpc64*-*-linux-gnu* } } */
+/* { dg-options -Wformat=0 { target moxie*-*-elf or1k-*-* } } */
+
+#include <inttypes.h>
 
 #include "ffitest.h"
 
@@ -119,13 +121,13 @@ test_large_fn(
 {
 	BigStruct	retVal	= {
 		ui8_1 + 1, si8_1 + 1, ui16_1 + 1, si16_1 + 1, ui32_1 + 1, si32_1 + 1,
-			ui64_1 + 1, si64_1 + 1, f_1 + 1, d_1 + 1, ld_1 + 1, (char*)((intptr_t)p_1 + 1), 
+			ui64_1 + 1, si64_1 + 1, f_1 + 1, d_1 + 1, ld_1 + 1, (char*)((intptr_t)p_1 + 1),
 		ui8_2 + 2, si8_2 + 2, ui16_2 + 2, si16_2 + 2, ui32_2 + 2, si32_2 + 2,
-			ui64_2 + 2, si64_2 + 2, f_2 + 2, d_2 + 2, ld_2 + 2, (char*)((intptr_t)p_2 + 2), 
+			ui64_2 + 2, si64_2 + 2, f_2 + 2, d_2 + 2, ld_2 + 2, (char*)((intptr_t)p_2 + 2),
 		ui8_3 + 3, si8_3 + 3, ui16_3 + 3, si16_3 + 3, ui32_3 + 3, si32_3 + 3,
-			ui64_3 + 3, si64_3 + 3, f_3 + 3, d_3 + 3, ld_3 + 3, (char*)((intptr_t)p_3 + 3), 
+			ui64_3 + 3, si64_3 + 3, f_3 + 3, d_3 + 3, ld_3 + 3, (char*)((intptr_t)p_3 + 3),
 		ui8_4 + 4, si8_4 + 4, ui16_4 + 4, si16_4 + 4, ui32_4 + 4, si32_4 + 4,
-			ui64_4 + 4, si64_4 + 4, f_4 + 4, d_4 + 4, ld_4 + 4, (char*)((intptr_t)p_4 + 4), 
+			ui64_4 + 4, si64_4 + 4, f_4 + 4, d_4 + 4, ld_4 + 4, (char*)((intptr_t)p_4 + 4),
 		ui8_5 + 5, si8_5 + 5};
 
 	printf("%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx "
@@ -136,18 +138,18 @@ test_large_fn(
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx "
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx "
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx %" PRIu8 " %" PRId8 "\n",
-	       ui8_1, si8_1, ui16_1, si16_1, ui32_1, si32_1, ui64_1, si64_1, f_1, d_1, ld_1, (unsigned long)p_1,
-		ui8_2, si8_2, ui16_2, si16_2, ui32_2, si32_2, ui64_2, si64_2, f_2, d_2, ld_2, (unsigned long)p_2,
-		ui8_3, si8_3, ui16_3, si16_3, ui32_3, si32_3, ui64_3, si64_3, f_3, d_3, ld_3, (unsigned long)p_3,
-		ui8_4, si8_4, ui16_4, si16_4, ui32_4, si32_4, ui64_4, si64_4, f_4, d_4, ld_4, (unsigned long)p_4, ui8_5, si8_5,
+	       ui8_1, si8_1, ui16_1, si16_1, ui32_1, si32_1, ui64_1, si64_1, f_1, d_1, ld_1, (long)(intptr_t)p_1,
+		ui8_2, si8_2, ui16_2, si16_2, ui32_2, si32_2, ui64_2, si64_2, f_2, d_2, ld_2, (long)(intptr_t)p_2,
+		ui8_3, si8_3, ui16_3, si16_3, ui32_3, si32_3, ui64_3, si64_3, f_3, d_3, ld_3, (long)(intptr_t)p_3,
+		ui8_4, si8_4, ui16_4, si16_4, ui32_4, si32_4, ui64_4, si64_4, f_4, d_4, ld_4, (long)(intptr_t)p_4, ui8_5, si8_5,
 		retVal.a, retVal.b, retVal.c, retVal.d, retVal.e, retVal.f,
-	       retVal.g, retVal.h, retVal.i, retVal.j, retVal.k, (unsigned long)retVal.l,
+	       retVal.g, retVal.h, retVal.i, retVal.j, retVal.k, (long)(intptr_t)retVal.l,
 		retVal.m, retVal.n, retVal.o, retVal.p, retVal.q, retVal.r,
-	       retVal.s, retVal.t, retVal.u, retVal.v, retVal.w, (unsigned long)retVal.x,
+	       retVal.s, retVal.t, retVal.u, retVal.v, retVal.w, (long)(intptr_t)retVal.x,
 		retVal.y, retVal.z, retVal.aa, retVal.bb, retVal.cc, retVal.dd,
-	       retVal.ee, retVal.ff, retVal.gg, retVal.hh, retVal.ii, (unsigned long)retVal.jj,
+	       retVal.ee, retVal.ff, retVal.gg, retVal.hh, retVal.ii, (long)(intptr_t)retVal.jj,
 		retVal.kk, retVal.ll, retVal.mm, retVal.nn, retVal.oo, retVal.pp,
-	       retVal.qq, retVal.rr, retVal.ss, retVal.tt, retVal.uu, (unsigned long)retVal.vv, retVal.ww, retVal.xx);
+	       retVal.qq, retVal.rr, retVal.ss, retVal.tt, retVal.uu, (long)(intptr_t)retVal.vv, retVal.ww, retVal.xx);
 
 	return	retVal;
 }
@@ -300,13 +302,13 @@ main(int argc __UNUSED__, const char** argv __UNUSED__)
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx "
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx %" PRIu8 " %" PRId8 "\n",
 		retVal.a, retVal.b, retVal.c, retVal.d, retVal.e, retVal.f,
-	       retVal.g, retVal.h, retVal.i, retVal.j, retVal.k, (unsigned long)retVal.l,
+	       retVal.g, retVal.h, retVal.i, retVal.j, retVal.k, (long)(intptr_t)retVal.l,
 		retVal.m, retVal.n, retVal.o, retVal.p, retVal.q, retVal.r,
-	       retVal.s, retVal.t, retVal.u, retVal.v, retVal.w, (unsigned long)retVal.x,
+	       retVal.s, retVal.t, retVal.u, retVal.v, retVal.w, (long)(intptr_t)retVal.x,
 		retVal.y, retVal.z, retVal.aa, retVal.bb, retVal.cc, retVal.dd,
-	       retVal.ee, retVal.ff, retVal.gg, retVal.hh, retVal.ii, (unsigned long)retVal.jj,
+	       retVal.ee, retVal.ff, retVal.gg, retVal.hh, retVal.ii, (long)(intptr_t)retVal.jj,
 		retVal.kk, retVal.ll, retVal.mm, retVal.nn, retVal.oo, retVal.pp,
-	       retVal.qq, retVal.rr, retVal.ss, retVal.tt, retVal.uu, (unsigned long)retVal.vv, retVal.ww, retVal.xx);
+	       retVal.qq, retVal.rr, retVal.ss, retVal.tt, retVal.uu, (long)(intptr_t)retVal.vv, retVal.ww, retVal.xx);
 	/* { dg-output "\nres: 2 3 4 5 6 7 8 9 10 11 12 0x12345679 3 4 5 6 7 8 9 10 11 12 13 0x1234567a 4 5 6 7 8 9 10 11 12 13 14 0x1234567b 5 6 7 8 9 10 11 12 13 14 15 0x1234567c 6 7" } */
 
 	CHECK(ffi_prep_closure_loc(pcl, &cif, cls_large_fn, NULL, code) == FFI_OK);
@@ -328,13 +330,13 @@ main(int argc __UNUSED__, const char** argv __UNUSED__)
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx "
 		"%" PRIu8 " %" PRId8 " %hu %hd %u %d %" PRIu64 " %" PRId64 " %.0f %.0f %.0Lf %#lx %" PRIu8 " %" PRId8 "\n",
 		retVal.a, retVal.b, retVal.c, retVal.d, retVal.e, retVal.f,
-	       retVal.g, retVal.h, retVal.i, retVal.j, retVal.k, (unsigned long)retVal.l,
+	       retVal.g, retVal.h, retVal.i, retVal.j, retVal.k, (long)(intptr_t)retVal.l,
 		retVal.m, retVal.n, retVal.o, retVal.p, retVal.q, retVal.r,
-	       retVal.s, retVal.t, retVal.u, retVal.v, retVal.w, (unsigned long)retVal.x,
+	       retVal.s, retVal.t, retVal.u, retVal.v, retVal.w, (long)(intptr_t)retVal.x,
 		retVal.y, retVal.z, retVal.aa, retVal.bb, retVal.cc, retVal.dd,
-	       retVal.ee, retVal.ff, retVal.gg, retVal.hh, retVal.ii, (unsigned long)retVal.jj,
+	       retVal.ee, retVal.ff, retVal.gg, retVal.hh, retVal.ii, (long)(intptr_t)retVal.jj,
 		retVal.kk, retVal.ll, retVal.mm, retVal.nn, retVal.oo, retVal.pp,
-	       retVal.qq, retVal.rr, retVal.ss, retVal.tt, retVal.uu, (unsigned long)retVal.vv, retVal.ww, retVal.xx);
+	       retVal.qq, retVal.rr, retVal.ss, retVal.tt, retVal.uu, (long)(intptr_t)retVal.vv, retVal.ww, retVal.xx);
 	/* { dg-output "\nres: 2 3 4 5 6 7 8 9 10 11 12 0x12345679 3 4 5 6 7 8 9 10 11 12 13 0x1234567a 4 5 6 7 8 9 10 11 12 13 14 0x1234567b 5 6 7 8 9 10 11 12 13 14 15 0x1234567c 6 7" } */
 
     return 0;

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

@@ -25,7 +25,7 @@ typedef struct cls_struct_combined {
   cls_struct_16byte2 e;
 } cls_struct_combined;
 
-cls_struct_combined cls_struct_combined_fn(struct cls_struct_16byte1 b0,
+static cls_struct_combined cls_struct_combined_fn(struct cls_struct_16byte1 b0,
 			    struct cls_struct_16byte2 b1,
 			    struct cls_struct_combined b2)
 {
@@ -46,6 +46,29 @@ cls_struct_combined cls_struct_combined_fn(struct cls_struct_16byte1 b0,
 	 result.d.a, result.d.b, result.d.c,
 	 result.e.ii, result.e.dd, result.e.ff);
 
+  CHECK_DOUBLE_EQ(b0.a, 9);
+  CHECK_FLOAT_EQ(b0.b, 2);
+  CHECK(b0.c == 6);
+
+  CHECK(b1.ii == 1);
+  CHECK_DOUBLE_EQ(b1.dd, 2);
+  CHECK_FLOAT_EQ(b1.ff, 3);
+
+  CHECK_DOUBLE_EQ(b2.d.a, 4);
+  CHECK_FLOAT_EQ(b2.d.b, 5);
+  CHECK(b2.d.c == 6);
+
+  CHECK(b2.e.ii == 3);
+  CHECK_DOUBLE_EQ(b2.e.dd, 1);
+  CHECK_FLOAT_EQ(b2.e.ff, 8);
+
+  CHECK_DOUBLE_EQ(result.d.a, 15);
+  CHECK_FLOAT_EQ(result.d.b, 10);
+  CHECK(result.d.c == 13);
+  CHECK(result.e.ii == 10);
+  CHECK_DOUBLE_EQ(result.e.dd, 12);
+  CHECK_FLOAT_EQ(result.e.ff, 13);
+
   return result;
 }
 
@@ -128,12 +151,12 @@ int main (void)
 
   ffi_call(&cif, FFI_FN(cls_struct_combined_fn), &res_dbl, args_dbl);
   /* { dg-output "9 2 6 1 2 3 4 5 6 3 1 8: 15 10 13 10 12 13" } */
-  CHECK( res_dbl.d.a == (e_dbl.a + f_dbl.dd + g_dbl.d.a));
-  CHECK( res_dbl.d.b == (e_dbl.b + f_dbl.ff + g_dbl.d.b));
+  CHECK_DOUBLE_EQ( res_dbl.d.a, (e_dbl.a + f_dbl.dd + g_dbl.d.a));
+  CHECK_FLOAT_EQ( res_dbl.d.b,  (e_dbl.b + f_dbl.ff + g_dbl.d.b));
   CHECK( res_dbl.d.c == (e_dbl.c + f_dbl.ii + g_dbl.d.c));
   CHECK( res_dbl.e.ii == (e_dbl.c + f_dbl.ii + g_dbl.e.ii));
-  CHECK( res_dbl.e.dd == (e_dbl.a + f_dbl.dd + g_dbl.e.dd));
-  CHECK( res_dbl.e.ff == (e_dbl.b + f_dbl.ff + g_dbl.e.ff));
+  CHECK_DOUBLE_EQ( res_dbl.e.dd, (e_dbl.a + f_dbl.dd + g_dbl.e.dd));
+  CHECK_FLOAT_EQ( res_dbl.e.ff, (e_dbl.b + f_dbl.ff + g_dbl.e.ff));
 
   CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_combined_gn, NULL, code) == FFI_OK);
 
@@ -142,11 +165,11 @@ int main (void)
 				     cls_struct_combined))
 	     (code))(e_dbl, f_dbl, g_dbl);
   /* { dg-output "\n9 2 6 1 2 3 4 5 6 3 1 8: 15 10 13 10 12 13" } */
-  CHECK( res_dbl.d.a == (e_dbl.a + f_dbl.dd + g_dbl.d.a));
-  CHECK( res_dbl.d.b == (e_dbl.b + f_dbl.ff + g_dbl.d.b));
+  CHECK_DOUBLE_EQ( res_dbl.d.a, (e_dbl.a + f_dbl.dd + g_dbl.d.a));
+  CHECK_FLOAT_EQ( res_dbl.d.b,  (e_dbl.b + f_dbl.ff + g_dbl.d.b));
   CHECK( res_dbl.d.c == (e_dbl.c + f_dbl.ii + g_dbl.d.c));
   CHECK( res_dbl.e.ii == (e_dbl.c + f_dbl.ii + g_dbl.e.ii));
-  CHECK( res_dbl.e.dd == (e_dbl.a + f_dbl.dd + g_dbl.e.dd));
-  CHECK( res_dbl.e.ff == (e_dbl.b + f_dbl.ff + g_dbl.e.ff));
+  CHECK_DOUBLE_EQ( res_dbl.e.dd, (e_dbl.a + f_dbl.dd + g_dbl.e.dd));
+  CHECK_FLOAT_EQ( res_dbl.e.ff, (e_dbl.b + f_dbl.ff + g_dbl.e.ff));
   exit(0);
 }

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

@@ -25,7 +25,7 @@ typedef struct cls_struct_combined {
   cls_struct_16byte2 e;
 } cls_struct_combined;
 
-cls_struct_combined cls_struct_combined_fn(struct cls_struct_16byte1 b0,
+static cls_struct_combined cls_struct_combined_fn(struct cls_struct_16byte1 b0,
 					   struct cls_struct_16byte2 b1,
 					   struct cls_struct_combined b2,
 					   struct cls_struct_16byte1 b3)

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

@@ -38,6 +38,18 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 (int)b3.x.a, b3.x.b, b3.y, b3.z, (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(b3.z == 255);
+  CHECK((int)b4.d == 2);
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 270);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/{libffi.call → 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.call → 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.call → 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.call → 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;
 }