ffi 1.15.5 → 1.17.0

data/ext/ffi_c/libffi/testsuite/libffi.call/callback2.c

@@ -0,0 +1,108 @@
+/* Area:	ffi_call
+   Purpose:	Check structures with nested array and callback.
+   Limitations:	none.
+   PR:		none.
+   Originator:	David Tenty <daltenty@ibm.com>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+int i=5;
+
+void callback(void) { i++; }
+
+typedef struct
+{
+  struct { double d; } s1;
+  double s[2];
+  unsigned char c2;
+} test_structure_12;
+
+static test_structure_12 ABI_ATTR struct12 (test_structure_12 ts, void (*func)(void))
+{
+  ts.s1.d += 1;
+  ts.c2 += 1;
+  ts.s[0] += 1;
+  ts.s[1] += 1;
+
+  func();
+  return ts;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  ffi_type ts12_type,ts12a_type, ts12b_type;
+  ffi_type *ts12_type_elements[4];
+  ffi_type *ts12a_type_elements[2];
+  ffi_type *ts12b_type_elements[3];
+
+
+  test_structure_12 ts12_arg;
+  void (*ptr)(void)=&callback;
+
+  test_structure_12 *ts12_result =
+    (test_structure_12 *) malloc (sizeof(test_structure_12));
+
+  ts12a_type.size = 0;
+  ts12a_type.alignment = 0;
+  ts12a_type.type = FFI_TYPE_STRUCT;
+  ts12a_type.elements = ts12a_type_elements;
+  ts12a_type_elements[0] = &ffi_type_double;
+  ts12a_type_elements[1] = NULL;
+
+  ts12b_type.size = 0;
+  ts12b_type.alignment = 0;
+  ts12b_type.type = FFI_TYPE_STRUCT;
+  ts12b_type.elements = ts12b_type_elements;
+  ts12b_type_elements[0] = &ffi_type_double;
+  ts12b_type_elements[1] = &ffi_type_double;
+  ts12b_type_elements[2] = NULL;
+
+  ts12_type.size = 0;
+  ts12_type.alignment = 0;
+  ts12_type.type = FFI_TYPE_STRUCT;
+  ts12_type.elements = ts12_type_elements;
+  ts12_type_elements[0] = &ts12a_type;
+  ts12_type_elements[1] = &ts12b_type;
+  ts12_type_elements[2] = &ffi_type_uchar;
+  ts12_type_elements[3] = NULL;
+
+
+  args[0] = &ts12_type;
+  args[1] = &ffi_type_pointer;
+  values[0] = &ts12_arg;
+  values[1] = &ptr;
+
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2, &ts12_type, args) == FFI_OK);
+
+  ts12_arg.s1.d = 5.55;
+  ts12_arg.c2 = 6;
+  ts12_arg.s[0] = 7.77;
+  ts12_arg.s[1] = 8.88;
+
+  printf ("%g\n", ts12_arg.s1.d);
+  printf ("%u\n", ts12_arg.c2);
+  printf ("%g\n", ts12_arg.s[0]);
+  printf ("%g\n", ts12_arg.s[1]);
+  printf ("%d\n", i);
+
+  ffi_call(&cif, FFI_FN(struct12), ts12_result, values);
+
+  printf ("%g\n", ts12_result->s1.d);
+  printf ("%u\n", ts12_result->c2);
+  printf ("%g\n", ts12_result->s[0]);
+  printf ("%g\n", ts12_result->s[1]);
+  printf ("%d\n", i);
+  CHECK(ts12_result->s1.d == 5.55 + 1);
+  CHECK(ts12_result->c2 == 6 + 1);
+  CHECK(ts12_result->s[0] == 7.77 + 1);
+  CHECK(ts12_result->s[1] == 8.88 + 1);
+  CHECK(i == 5 + 1);
+  CHECK(ts12_type.size == sizeof(test_structure_12));
+
+  free (ts12_result);
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.call/callback3.c

@@ -0,0 +1,114 @@
+/* Area:	ffi_call
+   Purpose:	Check structures with array and callback.
+   Limitations:	none.
+   PR:		none.
+   Originator:	David Tenty <daltenty@ibm.com>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+int i=5;
+
+void callback(void) { i++; }
+
+
+typedef struct
+{
+  struct { unsigned char c; double d; } s1;
+  double s[2];
+  unsigned char c2;
+} test_structure_12;
+
+static test_structure_12 ABI_ATTR struct12 (test_structure_12 ts, void (*func)(void))
+{
+  ts.s1.c += 1;
+  ts.s1.d += 1;
+  ts.c2 += 1;
+  ts.s[0] += 1;
+  ts.s[1] += 1;
+
+  func();
+  return ts;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  ffi_type ts12_type,ts12b_type, ts12a_type;
+  ffi_type *ts12_type_elements[4];
+  ffi_type *ts12b_type_elements[3];
+  ffi_type *ts12a_type_elements[3];
+
+  test_structure_12 ts12_arg;
+  void (*ptr)(void)=&callback;
+
+  test_structure_12 *ts12_result =
+    (test_structure_12 *) malloc (sizeof(test_structure_12));
+
+  ts12a_type.size = 0;
+  ts12a_type.alignment = 0;
+  ts12a_type.type = FFI_TYPE_STRUCT;
+  ts12a_type.elements = ts12a_type_elements;
+  ts12a_type_elements[0] = &ffi_type_uchar;
+  ts12a_type_elements[1] = &ffi_type_double;
+  ts12a_type_elements[2] = NULL;
+
+  ts12b_type.size = 0;
+  ts12b_type.alignment = 0;
+  ts12b_type.type = FFI_TYPE_STRUCT;
+  ts12b_type.elements = ts12b_type_elements;
+  ts12b_type_elements[0] = &ffi_type_double;
+  ts12b_type_elements[1] = &ffi_type_double;
+  ts12b_type_elements[2] = NULL;
+
+  ts12_type.size = 0;
+  ts12_type.alignment = 0;
+  ts12_type.type = FFI_TYPE_STRUCT;
+  ts12_type.elements = ts12_type_elements;
+  ts12_type_elements[0] = &ts12a_type;
+  ts12_type_elements[1] = &ts12b_type;
+  ts12_type_elements[2] = &ffi_type_uchar;
+  ts12_type_elements[3] = NULL;
+
+
+  args[0] = &ts12_type;
+  args[1] = &ffi_type_pointer;
+  values[0] = &ts12_arg;
+  values[1] = &ptr;
+
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2, &ts12_type, args) == FFI_OK);
+
+  ts12_arg.s1.c = 5;
+  ts12_arg.s1.d = 5.55;
+  ts12_arg.c2 = 6;
+  ts12_arg.s[0] = 7.77;
+  ts12_arg.s[1] = 8.88;
+
+  printf ("%d\n", ts12_arg.s1.c);
+  printf ("%g\n", ts12_arg.s1.d);
+  printf ("%u\n", ts12_arg.c2);
+  printf ("%g\n", ts12_arg.s[0]);
+  printf ("%g\n", ts12_arg.s[1]);
+  printf ("%d\n", i);
+
+  ffi_call(&cif, FFI_FN(struct12), ts12_result, values);
+
+  printf ("%d\n", ts12_result->s1.c);
+  printf ("%g\n", ts12_result->s1.d);
+  printf ("%u\n", ts12_result->c2);
+  printf ("%g\n", ts12_result->s[0]);
+  printf ("%g\n", ts12_result->s[1]);
+  printf ("%d\n", i);
+  CHECK(ts12_result->s1.c == 5 + 1);
+  CHECK(ts12_result->s1.d == 5.55 + 1);
+  CHECK(ts12_result->c2 == 6 + 1);
+  CHECK(ts12_result->s[0] == 7.77 + 1);
+  CHECK(ts12_result->s[1] == 8.88 + 1);
+  CHECK(i == 5 + 1);
+  CHECK(ts12_type.size == sizeof(test_structure_12));
+
+  free (ts12_result);
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.call/callback4.c

@@ -0,0 +1,119 @@
+/* Area:	ffi_call
+   Purpose:	Check structures with array and callback.
+   Limitations:	none.
+   PR:		none.
+   Originator:	David Tenty <daltenty@ibm.com>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+int i=5;
+
+void callback(void) { i++; }
+
+
+typedef struct
+{
+  unsigned char c1;
+  struct { double d; unsigned char c; } s[2];
+  unsigned char c2;
+} test_structure_12;
+
+static test_structure_12 ABI_ATTR struct12 (test_structure_12 ts, void (*func)(void))
+{
+  ts.c1 += 1;
+  ts.s[0].d += 1;
+  ts.s[0].c += 1;
+  ts.s[1].d += 1;
+  ts.s[1].c += 1;
+  ts.c2 += 1;
+
+  func();
+  return ts;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  ffi_type ts12_type,ts12b_type, ts12a_type;
+  ffi_type *ts12_type_elements[4];
+  ffi_type *ts12b_type_elements[3];
+  ffi_type *ts12a_type_elements[3];
+
+  test_structure_12 ts12_arg;
+  void (*ptr)(void)=&callback;
+
+  test_structure_12 *ts12_result =
+    (test_structure_12 *) malloc (sizeof(test_structure_12));
+
+  ts12a_type.size = 0;
+  ts12a_type.alignment = 0;
+  ts12a_type.type = FFI_TYPE_STRUCT;
+  ts12a_type.elements = ts12a_type_elements;
+  ts12a_type_elements[0] = &ffi_type_double;
+  ts12a_type_elements[1] = &ffi_type_uchar;
+  ts12a_type_elements[2] = NULL;
+
+  ts12b_type.size = 0;
+  ts12b_type.alignment = 0;
+  ts12b_type.type = FFI_TYPE_STRUCT;
+  ts12b_type.elements = ts12b_type_elements;
+  ts12b_type_elements[0] = &ts12a_type;
+  ts12b_type_elements[1] = &ts12a_type;
+  ts12b_type_elements[2] = NULL;
+
+  ts12_type.size = 0;
+  ts12_type.alignment = 0;
+  ts12_type.type = FFI_TYPE_STRUCT;
+  ts12_type.elements = ts12_type_elements;
+  ts12_type_elements[0] = &ffi_type_uchar;
+  ts12_type_elements[1] = &ts12b_type;
+  ts12_type_elements[2] = &ffi_type_uchar;
+  ts12_type_elements[3] = NULL;
+
+
+  args[0] = &ts12_type;
+  args[1] = &ffi_type_pointer;
+  values[0] = &ts12_arg;
+  values[1] = &ptr;
+
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2, &ts12_type, args) == FFI_OK);
+
+  ts12_arg.c1 = 5;
+  ts12_arg.s[0].d = 5.55;
+  ts12_arg.s[0].c = 6;
+  ts12_arg.s[1].d = 7.77;
+  ts12_arg.s[1].c = 8;
+  ts12_arg.c2 = 9;
+
+  printf ("%u\n", ts12_arg.c1);
+  printf ("%g\n", ts12_arg.s[0].d);
+  printf ("%u\n", ts12_arg.s[0].c);
+  printf ("%g\n", ts12_arg.s[1].d);
+  printf ("%u\n", ts12_arg.s[1].c);
+  printf ("%u\n", ts12_arg.c2);
+  printf ("%d\n", i);
+
+  ffi_call(&cif, FFI_FN(struct12), ts12_result, values);
+
+  printf ("%u\n", ts12_result->c1);
+  printf ("%g\n", ts12_result->s[0].d);
+  printf ("%u\n", ts12_result->s[0].c);
+  printf ("%g\n", ts12_result->s[1].d);
+  printf ("%u\n", ts12_result->s[1].c);
+  printf ("%u\n", ts12_result->c2);
+  printf ("%d\n", i);
+  CHECK(ts12_result->c1 == 5 + 1);
+  CHECK(ts12_result->s[0].d == 5.55 + 1);
+  CHECK(ts12_result->s[0].c == 6 + 1);
+  CHECK(ts12_result->s[1].d == 7.77 + 1);
+  CHECK(ts12_result->s[1].c == 8 + 1);
+  CHECK(ts12_result->c2 == 9 + 1);
+  CHECK(i == 5 + 1);
+  CHECK(ts12_type.size == sizeof(test_structure_12));
+
+  free (ts12_result);
+  exit(0);
+}

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

@@ -5,6 +5,9 @@
 #include <ffi.h>
 #include "fficonfig.h"
 
+#include <float.h>
+#include <math.h>
+
 #if defined HAVE_STDINT_H
 #include <stdint.h>
 #endif
@@ -15,7 +18,29 @@
 
 #define MAX_ARGS 256
 
-#define CHECK(x) (void)(!(x) ? (abort(), 1) : 0)
+#define CHECK(x) \
+   do { \
+      if(!(x)){ \
+         printf("Check failed:\n%s\n", #x); \
+         abort(); \
+      } \
+   } while(0)
+
+#define CHECK_FLOAT_EQ(x, y) \
+   do { \
+      if(fabs((x) - (y)) > FLT_EPSILON){ \
+         printf("Check failed CHECK_FLOAT_EQ(%s, %s)\n", #x, #y); \
+         abort(); \
+      } \
+   } while(0)
+
+#define CHECK_DOUBLE_EQ(x, y) \
+   do { \
+      if(fabs((x) - (y)) > DBL_EPSILON){ \
+         printf("Check failed CHECK_FLOAT_EQ(%s, %s)\n", #x, #y); \
+         abort(); \
+      } \
+   } while(0)
 
 /* Define macros so that compilers other than gcc can run the tests.  */
 #undef __UNUSED__
@@ -63,8 +88,8 @@
 
 #endif
 
-/* MinGW kludge.  */
-#if defined(_WIN64) | defined(_WIN32)
+/* msvc kludge.  */
+#if defined(_MSC_VER)
 #define PRIdLL "I64d"
 #define PRIuLL "I64u"
 #else

data/ext/ffi_c/libffi/testsuite/libffi.call/float_va.c

@@ -74,6 +74,7 @@ int main (void)
   /* { dg-output "\n0: 2.0 : total: 2.0" } */
   printf("ffi: %.1f\n", resfp);
   /* { dg-output "\nffi: 2.0" } */
+  CHECK_DOUBLE_EQ(resfp, 2);
 
   /* Second test, float_va_fn(2,2.0,3.0,4.0), now with variadic params */
   /* Call it statically and then via ffi */
@@ -81,6 +82,7 @@ int main (void)
   /* { dg-output "\n2: 2.0 : 0:3.0  1:4.0  total: 11.0" } */
   printf("compiled: %.1f\n", resfp);
   /* { dg-output "\ncompiled: 11.0" } */
+  CHECK_DOUBLE_EQ(resfp, 11);
 
   arg_types[0] = &ffi_type_uint;
   arg_types[1] = &ffi_type_double;
@@ -102,6 +104,7 @@ int main (void)
   /* { dg-output "\n2: 2.0 : 0:3.0  1:4.0  total: 11.0" } */
   printf("ffi: %.1f\n", resfp);
   /* { dg-output "\nffi: 11.0" } */
+  CHECK_DOUBLE_EQ(resfp, 11);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/libffi.call/return_ll1.c

@@ -9,6 +9,9 @@
 #include "ffitest.h"
 static long long return_ll(int ll0, long long ll1, int ll2)
 {
+  CHECK(ll0 == 11111111);
+  CHECK(ll1 == 11111111111000LL);
+  CHECK(ll2 == 11111111);
   return ll0 + ll1 + ll2;
 }
 
@@ -39,5 +42,7 @@ int main (void)
   ffi_call(&cif, FFI_FN(return_ll), &rlonglong, values);
   printf("res: %" PRIdLL ", %" PRIdLL "\n", rlonglong, ll0 + ll1 + ll2);
   /* { dg-output "res: 11111133333222, 11111133333222" } */
+  CHECK(rlonglong == 11111133333222);
+  CHECK(ll0 + ll1 + ll2 == 11111133333222);
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/libffi.call/return_sl.c

@@ -8,6 +8,8 @@
 #include "ffitest.h"
 static long return_sl(long l1, long l2)
 {
+  CHECK(l1 == 1073741823L);
+  CHECK(l2 == 1073741824L);
   return l1 - l2;
 }
 
@@ -33,6 +35,8 @@ int main (void)
   ffi_call(&cif, FFI_FN(return_sl), &res, values);
   printf("res: %ld, %ld\n", (long)res, l1 - l2);
   /* { dg-output "res: -1, -1" } */
+  CHECK((long)res == -1);
+  CHECK(l1 + 1 == l2);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/libffi.call/return_ul.c

@@ -8,6 +8,8 @@
 #include "ffitest.h"
 static unsigned long return_ul(unsigned long ul1, unsigned long ul2)
 {
+  CHECK(ul1 == 1073741823L);
+  CHECK(ul2 == 1073741824L);
   return ul1 + ul2;
 }
 
@@ -33,6 +35,8 @@ int main (void)
   ffi_call(&cif, FFI_FN(return_ul), &res, values);
   printf("res: %lu, %lu\n", (unsigned long)res, ul1 + ul2);
   /* { dg-output "res: 2147483647, 2147483647" } */
+  CHECK(res == 2147483647L);
+  CHECK(ul1 + ul2 == 2147483647L);
 
   exit(0);
 }

data/ext/ffi_c/libffi/testsuite/libffi.call/s55.c

@@ -0,0 +1,60 @@
+/* Area:	ffi_call
+   Purpose:	Check structures.
+   Limitations:	none.
+   PR:		none.
+   Originator:	From the original ffitest.c  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct
+{
+  float f;
+} s55;
+
+static s55 ABI_ATTR f55(s55 ts, float f)
+{
+  s55 r;
+  r.f = ts.f + f;
+  printf ("f55>> %g + %g = %g\n", ts.f, f, r.f);
+  return r;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  s55 F, Fr;
+  float f;
+  void *values[] = { &F, &f };
+  ffi_type s55_type;
+  ffi_type *args[] = { &s55_type, &ffi_type_float };
+  ffi_type *s55_type_elements[] = { &ffi_type_float, NULL };
+
+  /* This is a hack to get a properly aligned result buffer */
+  s55 *s55_result =
+    (s55 *) malloc (sizeof(s55));
+
+  s55_type.size = 0;
+  s55_type.alignment = 0;
+  s55_type.type = FFI_TYPE_STRUCT;
+  s55_type.elements = s55_type_elements;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2, &s55_type, args) == FFI_OK);
+
+  F.f = 1;
+  Fr = f55(F, 2.14);
+  printf ("%g\n", Fr.f);
+
+  F.f = 1;
+  f = 2.14;
+  ffi_call(&cif, FFI_FN(f55), s55_result, values);
+  printf ("%g\n", s55_result->f);
+
+  fflush(0);
+
+  CHECK(fabs(Fr.f - s55_result->f) < FLT_EPSILON);
+
+  free (s55_result);
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.call/strlen.c

@@ -7,9 +7,9 @@
 /* { dg-do run } */
 #include "ffitest.h"
 
-static size_t ABI_ATTR my_strlen(char *s)
+static unsigned int ABI_ATTR my_strlen(char *s)
 {
-  return (strlen(s));
+  return (unsigned int) (strlen(s));
 }
 
 int main (void)
@@ -22,23 +22,22 @@ int main (void)
 
   args[0] = &ffi_type_pointer;
   values[0] = (void*) &s;
-  
+
   /* Initialize the cif */
   CHECK(ffi_prep_cif(&cif, ABI_NUM, 1,
-		     &ffi_type_sint, args) == FFI_OK);
-  
+		     &ffi_type_uint, args) == FFI_OK);
+
   s = "a";
   ffi_call(&cif, FFI_FN(my_strlen), &rint, values);
   CHECK(rint == 1);
-  
+
   s = "1234567";
   ffi_call(&cif, FFI_FN(my_strlen), &rint, values);
   CHECK(rint == 7);
-  
+
   s = "1234567890123456789012345";
   ffi_call(&cif, FFI_FN(my_strlen), &rint, values);
   CHECK(rint == 25);
-  
+
   exit (0);
 }
-  

data/ext/ffi_c/libffi/testsuite/libffi.call/strlen2.c

@@ -8,9 +8,9 @@
 
 #include "ffitest.h"
 
-static size_t ABI_ATTR my_f(char *s, float a)
+static int ABI_ATTR my_f(char *s, float a)
 {
-  return (size_t) ((int) strlen(s) + (int) a);
+  return (int) strlen(s) + (int) a;
 }
 
 int main (void)

data/ext/ffi_c/libffi/testsuite/libffi.call/strlen3.c

@@ -8,9 +8,9 @@
 
 #include "ffitest.h"
 
-static size_t ABI_ATTR my_f(float a, char *s)
+static int ABI_ATTR my_f(float a, char *s)
 {
-  return (size_t) ((int) strlen(s) + (int) a);
+  return (int) strlen(s) + (int) a;
 }
 
 int main (void)

data/ext/ffi_c/libffi/testsuite/libffi.call/strlen4.c

@@ -8,9 +8,9 @@
 
 #include "ffitest.h"
 
-static size_t ABI_ATTR my_f(float a, char *s, int i)
+static int ABI_ATTR my_f(float a, char *s, int i)
 {
-  return (size_t) ((int) strlen(s) + (int) a + i);
+  return (int) strlen(s) + (int) a + i;
 }
 
 int main (void)

data/ext/ffi_c/libffi/testsuite/libffi.call/struct10.c

@@ -16,7 +16,7 @@ struct s {
   signed char s8;
 };
 
-struct s make_s(void) {
+struct s ABI_ATTR make_s(void) {
   struct s r;
   r.s32 = 0x1234;
   r.f32 = 7.0;

data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_2.c

@@ -0,0 +1,63 @@
+/* Area:	ffi_call
+   Purpose:	Check structures.
+   Limitations:	none.
+   PR:		none.
+   Originator:	From the original ffitest.c  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct
+{
+  unsigned int ui01;
+  unsigned int ui02;
+} test_structure_1;
+
+static test_structure_1 ABI_ATTR struct1(test_structure_1 ts)
+{
+  ts.ui02++;
+
+  return ts;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  ffi_type ts1_type;
+  ffi_type *ts1_type_elements[3];
+
+  test_structure_1 ts1_arg;
+
+  /* This is a hack to get a properly aligned result buffer */
+  test_structure_1 *ts1_result =
+    (test_structure_1 *) malloc (sizeof(test_structure_1));
+
+  ts1_type.size = 0;
+  ts1_type.alignment = 0;
+  ts1_type.type = FFI_TYPE_STRUCT;
+  ts1_type.elements = ts1_type_elements;
+  ts1_type_elements[0] = &ffi_type_uint;
+  ts1_type_elements[1] = &ffi_type_uint;
+  ts1_type_elements[2] = NULL;
+
+  args[0] = &ts1_type;
+  values[0] = &ts1_arg;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1,
+		     &ts1_type, args) == FFI_OK);
+
+  ts1_arg.ui02 = 555;
+
+  ffi_call(&cif, FFI_FN(struct1), ts1_result, values);
+
+  CHECK(ts1_result->ui02 == 556);
+
+  /* This will fail if ffi_call isn't passing the struct by value. */
+  CHECK(ts1_arg.ui02 == 555);
+
+  free (ts1_result);
+  exit(0);
+}