ffi 1.17.0 → 1.17.4

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

@@ -1,67 +0,0 @@
-/* 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 char uc;
-  double d;
-  unsigned int ui;
-} test_structure_1;
-
-static test_structure_1 ABI_ATTR struct1(test_structure_1 ts)
-{
-  ts.uc++;
-  ts.d--;
-  ts.ui++;
-
-  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[4];
-
-  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_uchar;
-  ts1_type_elements[1] = &ffi_type_double;
-  ts1_type_elements[2] = &ffi_type_uint;
-  ts1_type_elements[3] = 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.uc = '\x01';
-  ts1_arg.d = 3.14159;
-  ts1_arg.ui = 555;
-
-  ffi_call(&cif, FFI_FN(struct1), ts1_result, values);
-  
-  CHECK(ts1_result->ui == 556);
-  CHECK(ts1_result->d == 3.14159 - 1);
- 
-  free (ts1_result);
-  exit(0);
-}

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

@@ -1,57 +0,0 @@
-/* Area:	ffi_call
-   Purpose:	Check structures.
-   Limitations:	none.
-   PR:		none.
-   Originator:	Sergei Trofimovich <slyfox@gentoo.org>
-
-   The test originally discovered in ruby's bindings
-   for ffi in https://bugs.gentoo.org/634190  */
-
-/* { dg-do run } */
-#include "ffitest.h"
-
-struct s {
-  int s32;
-  float f32;
-  signed char s8;
-};
-
-struct s ABI_ATTR make_s(void) {
-  struct s r;
-  r.s32 = 0x1234;
-  r.f32 = 7.0;
-  r.s8  = 0x78;
-  return r;
-}
-
-int main() {
-  ffi_cif cif;
-  struct s r;
-  ffi_type rtype;
-  ffi_type* s_fields[] = {
-    &ffi_type_sint,
-    &ffi_type_float,
-    &ffi_type_schar,
-    NULL,
-  };
-
-  rtype.size      = 0;
-  rtype.alignment = 0,
-  rtype.type      = FFI_TYPE_STRUCT,
-  rtype.elements  = s_fields,
-
-  r.s32 = 0xbad;
-  r.f32 = 999.999;
-  r.s8  = 0x51;
-
-  // Here we emulate the following call:
-  //r = make_s();
-
-  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 0, &rtype, NULL) == FFI_OK);
-  ffi_call(&cif, FFI_FN(make_s), &r, NULL);
-
-  CHECK(r.s32 == 0x1234);
-  CHECK(r.f32 == 7.0);
-  CHECK(r.s8  == 0x78);
-  exit(0);
-}

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

@@ -1,67 +0,0 @@
-/* Area:	ffi_call
-   Purpose:	Check structures.
-   Limitations:	none.
-   PR:		none.
-   Originator:	From the original ffitest.c  */
-
-/* { dg-do run } */
-#include "ffitest.h"
-
-typedef struct
-{
-  double d1;
-  double d2;
-} test_structure_2;
-
-static test_structure_2 ABI_ATTR struct2(test_structure_2 ts)
-{
-  ts.d1--;
-  ts.d2--;
-
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  test_structure_2 ts2_arg;
-  ffi_type ts2_type;
-  ffi_type *ts2_type_elements[3];
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_2 *ts2_result =
-    (test_structure_2 *) malloc (sizeof(test_structure_2));
-
-  ts2_type.size = 0;
-  ts2_type.alignment = 0;
-  ts2_type.type = FFI_TYPE_STRUCT;
-  ts2_type.elements = ts2_type_elements;
-  ts2_type_elements[0] = &ffi_type_double;
-  ts2_type_elements[1] = &ffi_type_double;
-  ts2_type_elements[2] = NULL;
-
-  args[0] = &ts2_type;
-  values[0] = &ts2_arg;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1, &ts2_type, args) == FFI_OK);
-  
-  ts2_arg.d1 = 5.55;
-  ts2_arg.d2 = 6.66;
-  
-  printf ("%g\n", ts2_arg.d1);
-  printf ("%g\n", ts2_arg.d2);
-  
-  ffi_call(&cif, FFI_FN(struct2), ts2_result, values);
-  
-  printf ("%g\n", ts2_result->d1);
-  printf ("%g\n", ts2_result->d2);
-  
-  CHECK(ts2_result->d1 == 5.55 - 1);
-  CHECK(ts2_result->d2 == 6.66 - 1);
-  
-  free (ts2_result);
-  exit(0);
-}

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

@@ -1,60 +0,0 @@
-/* Area:	ffi_call
-   Purpose:	Check structures.
-   Limitations:	none.
-   PR:		none.
-   Originator:	From the original ffitest.c  */
-
-/* { dg-do run } */
-#include "ffitest.h"
-
-typedef struct
-{
-  int si;
-} test_structure_3;
-
-static test_structure_3 ABI_ATTR struct3(test_structure_3 ts)
-{
-  ts.si = -(ts.si*2);
-
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  int compare_value;
-  ffi_type ts3_type;
-  ffi_type *ts3_type_elements[2];
-
-  test_structure_3 ts3_arg;
-  test_structure_3 *ts3_result =
-    (test_structure_3 *) malloc (sizeof(test_structure_3));
-
-  ts3_type.size = 0;
-  ts3_type.alignment = 0;
-  ts3_type.type = FFI_TYPE_STRUCT;
-  ts3_type.elements = ts3_type_elements;
-  ts3_type_elements[0] = &ffi_type_sint;
-  ts3_type_elements[1] = NULL;
-
-  args[0] = &ts3_type;
-  values[0] = &ts3_arg;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1,
-		     &ts3_type, args) == FFI_OK);
-  
-  ts3_arg.si = -123;
-  compare_value = ts3_arg.si;
-  
-  ffi_call(&cif, FFI_FN(struct3), ts3_result, values);
-  
-  printf ("%d %d\n", ts3_result->si, -(compare_value*2));
-  
-  CHECK(ts3_result->si == -(compare_value*2));
- 
-  free (ts3_result);
-  exit(0);
-}

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

@@ -1,64 +0,0 @@
-/* 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 ui1;
-  unsigned ui2;
-  unsigned ui3;
-} test_structure_4;
-
-static test_structure_4 ABI_ATTR struct4(test_structure_4 ts)
-{
-  ts.ui3 = ts.ui1 * ts.ui2 * ts.ui3;
-
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  ffi_type ts4_type;
-  ffi_type *ts4_type_elements[4];  
-
-  test_structure_4 ts4_arg;
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_4 *ts4_result =
-    (test_structure_4 *) malloc (sizeof(test_structure_4));
-
-  ts4_type.size = 0;
-  ts4_type.alignment = 0;
-  ts4_type.type = FFI_TYPE_STRUCT;
-  ts4_type.elements = ts4_type_elements;
-  ts4_type_elements[0] = &ffi_type_uint;
-  ts4_type_elements[1] = &ffi_type_uint;
-  ts4_type_elements[2] = &ffi_type_uint;
-  ts4_type_elements[3] = NULL;
-
-  args[0] = &ts4_type;
-  values[0] = &ts4_arg;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1, &ts4_type, args) == FFI_OK);
-  
-  ts4_arg.ui1 = 2;
-  ts4_arg.ui2 = 3;
-  ts4_arg.ui3 = 4;
-  
-  ffi_call (&cif, FFI_FN(struct4), ts4_result, values);
-  
-  CHECK(ts4_result->ui3 == 2U * 3U * 4U);
- 
-  
-  free (ts4_result);
-  exit(0);
-}

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

@@ -1,66 +0,0 @@
-/* Area:	ffi_call
-   Purpose:	Check structures.
-   Limitations:	none.
-   PR:		none.
-   Originator:	From the original ffitest.c  */
-
-/* { dg-do run } */
-#include "ffitest.h"
-typedef struct
-{
-  char c1;
-  char c2;
-} test_structure_5;
-
-static test_structure_5 ABI_ATTR struct5(test_structure_5 ts1, test_structure_5 ts2)
-{
-  ts1.c1 += ts2.c1;
-  ts1.c2 -= ts2.c2;
-  
-  return ts1;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  ffi_type ts5_type;
-  ffi_type *ts5_type_elements[3];
-
-  test_structure_5 ts5_arg1, ts5_arg2;
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_5 *ts5_result =
-    (test_structure_5 *) malloc (sizeof(test_structure_5));
-
-  ts5_type.size = 0;
-  ts5_type.alignment = 0;
-  ts5_type.type = FFI_TYPE_STRUCT;
-  ts5_type.elements = ts5_type_elements;
-  ts5_type_elements[0] = &ffi_type_schar;
-  ts5_type_elements[1] = &ffi_type_schar;
-  ts5_type_elements[2] = NULL;
-
-  args[0] = &ts5_type;
-  args[1] = &ts5_type;
-  values[0] = &ts5_arg1;
-  values[1] = &ts5_arg2;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 2, &ts5_type, args) == FFI_OK);
-  
-  ts5_arg1.c1 = 2;
-  ts5_arg1.c2 = 6;
-  ts5_arg2.c1 = 5;
-  ts5_arg2.c2 = 3;
-  
-  ffi_call (&cif, FFI_FN(struct5), ts5_result, values);
-  
-  CHECK(ts5_result->c1 == 7); 
-  CHECK(ts5_result->c2 == 3);
-  
-  
-  free (ts5_result);
-  exit(0);
-}

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

@@ -1,64 +0,0 @@
-/* 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;
-  double d;
-} test_structure_6;
-
-static test_structure_6 ABI_ATTR struct6 (test_structure_6 ts)
-{
-  ts.f += 1;
-  ts.d += 1;
-  
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  ffi_type ts6_type;
-  ffi_type *ts6_type_elements[3];
-
-  test_structure_6 ts6_arg;
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_6 *ts6_result =
-    (test_structure_6 *) malloc (sizeof(test_structure_6));
-
-  ts6_type.size = 0;
-  ts6_type.alignment = 0;
-  ts6_type.type = FFI_TYPE_STRUCT;
-  ts6_type.elements = ts6_type_elements;
-  ts6_type_elements[0] = &ffi_type_float;
-  ts6_type_elements[1] = &ffi_type_double;
-  ts6_type_elements[2] = NULL;
-
-  args[0] = &ts6_type;
-  values[0] = &ts6_arg;
-
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1, &ts6_type, args) == FFI_OK);
-  
-  ts6_arg.f = 5.55f;
-  ts6_arg.d = 6.66;
-  
-  printf ("%g\n", ts6_arg.f);
-  printf ("%g\n", ts6_arg.d);
-
-  ffi_call(&cif, FFI_FN(struct6), ts6_result, values);
-    
-  CHECK(ts6_result->f == 5.55f + 1);
-  CHECK(ts6_result->d == 6.66 + 1);
-    
-  free (ts6_result);
-  exit(0);
-}

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

@@ -1,74 +0,0 @@
-/* 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 f1;
-  float f2;
-  double d;
-} test_structure_7;
-
-static test_structure_7 ABI_ATTR struct7 (test_structure_7 ts)
-{
-  ts.f1 += 1;
-  ts.f2 += 1;
-  ts.d += 1;
-
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  ffi_type ts7_type;
-  ffi_type *ts7_type_elements[4];
-
-  test_structure_7 ts7_arg;
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_7 *ts7_result =
-    (test_structure_7 *) malloc (sizeof(test_structure_7));
-
-  ts7_type.size = 0;
-  ts7_type.alignment = 0;
-  ts7_type.type = FFI_TYPE_STRUCT;
-  ts7_type.elements = ts7_type_elements;
-  ts7_type_elements[0] = &ffi_type_float;
-  ts7_type_elements[1] = &ffi_type_float;
-  ts7_type_elements[2] = &ffi_type_double;
-  ts7_type_elements[3] = NULL;
-
-  args[0] = &ts7_type;
-  values[0] = &ts7_arg;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1, &ts7_type, args) == FFI_OK);
-  
-  ts7_arg.f1 = 5.55f;
-  ts7_arg.f2 = 55.5f;
-  ts7_arg.d = 6.66;
-
-  printf ("%g\n", ts7_arg.f1);
-  printf ("%g\n", ts7_arg.f2);
-  printf ("%g\n", ts7_arg.d);
-  
-  ffi_call(&cif, FFI_FN(struct7), ts7_result, values);
-
-  printf ("%g\n", ts7_result->f1);
-  printf ("%g\n", ts7_result->f2);
-  printf ("%g\n", ts7_result->d);
-  
-  CHECK(ts7_result->f1 == 5.55f + 1);
-  CHECK(ts7_result->f2 == 55.5f + 1);
-  CHECK(ts7_result->d == 6.66 + 1);
-  
-  free (ts7_result);
-  exit(0);
-}

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

@@ -1,81 +0,0 @@
-/* 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 f1;
-  float f2;
-  float f3;
-  float f4;
-} test_structure_8;
-
-static test_structure_8 ABI_ATTR struct8 (test_structure_8 ts)
-{
-  ts.f1 += 1;
-  ts.f2 += 1;
-  ts.f3 += 1;
-  ts.f4 += 1;
-
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  ffi_type ts8_type;
-  ffi_type *ts8_type_elements[5];
-
-  test_structure_8 ts8_arg;
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_8 *ts8_result =
-    (test_structure_8 *) malloc (sizeof(test_structure_8));
-
-  ts8_type.size = 0;
-  ts8_type.alignment = 0;
-  ts8_type.type = FFI_TYPE_STRUCT;
-  ts8_type.elements = ts8_type_elements;
-  ts8_type_elements[0] = &ffi_type_float;
-  ts8_type_elements[1] = &ffi_type_float;
-  ts8_type_elements[2] = &ffi_type_float;
-  ts8_type_elements[3] = &ffi_type_float;
-  ts8_type_elements[4] = NULL;
-
-  args[0] = &ts8_type;
-  values[0] = &ts8_arg;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1, &ts8_type, args) == FFI_OK);
-  
-  ts8_arg.f1 = 5.55f;
-  ts8_arg.f2 = 55.5f;
-  ts8_arg.f3 = -5.55f;
-  ts8_arg.f4 = -55.5f;
-
-  printf ("%g\n", ts8_arg.f1);
-  printf ("%g\n", ts8_arg.f2);
-  printf ("%g\n", ts8_arg.f3);
-  printf ("%g\n", ts8_arg.f4);
-  
-  ffi_call(&cif, FFI_FN(struct8), ts8_result, values);
-
-  printf ("%g\n", ts8_result->f1);
-  printf ("%g\n", ts8_result->f2);
-  printf ("%g\n", ts8_result->f3);
-  printf ("%g\n", ts8_result->f4);
-  
-  CHECK(ts8_result->f1 == 5.55f + 1);
-  CHECK(ts8_result->f2 == 55.5f + 1);
-  CHECK(ts8_result->f3 == -5.55f + 1);
-  CHECK(ts8_result->f4 == -55.5f + 1);
-  
-  free (ts8_result);
-  exit(0);
-}

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

@@ -1,68 +0,0 @@
-/* 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;
-  int i;
-} test_structure_9;
-
-static test_structure_9 ABI_ATTR struct9 (test_structure_9 ts)
-{
-  ts.f += 1;
-  ts.i += 1;
-
-  return ts;
-}
-
-int main (void)
-{
-  ffi_cif cif;
-  ffi_type *args[MAX_ARGS];
-  void *values[MAX_ARGS];
-  ffi_type ts9_type;
-  ffi_type *ts9_type_elements[3];
-
-  test_structure_9 ts9_arg;
-
-  /* This is a hack to get a properly aligned result buffer */
-  test_structure_9 *ts9_result =
-    (test_structure_9 *) malloc (sizeof(test_structure_9));
-
-  ts9_type.size = 0;
-  ts9_type.alignment = 0;
-  ts9_type.type = FFI_TYPE_STRUCT;
-  ts9_type.elements = ts9_type_elements;
-  ts9_type_elements[0] = &ffi_type_float;
-  ts9_type_elements[1] = &ffi_type_sint;
-  ts9_type_elements[2] = NULL;
-
-  args[0] = &ts9_type;
-  values[0] = &ts9_arg;
-  
-  /* Initialize the cif */
-  CHECK(ffi_prep_cif(&cif, ABI_NUM, 1, &ts9_type, args) == FFI_OK);
-  
-  ts9_arg.f = 5.55f;
-  ts9_arg.i = 5;
-  
-  printf ("%g\n", ts9_arg.f);
-  printf ("%d\n", ts9_arg.i);
-  
-  ffi_call(&cif, FFI_FN(struct9), ts9_result, values);
-
-  printf ("%g\n", ts9_result->f);
-  printf ("%d\n", ts9_result->i);
-  
-  CHECK(ts9_result->f == 5.55f + 1);
-  CHECK(ts9_result->i == 5 + 1);
-
-  free (ts9_result);
-  exit(0);
-}