libffi/src/ffitest.c

   1 /* -----------------------------------------------------------------------
   2    ffitest.c - Copyright (c) 1996, 1997, 1998, 2002, 2003  Red Hat, Inc.
   3
   4    Permission is hereby granted, free of charge, to any person obtaining
   5    a copy of this software and associated documentation files (the
   6    ``Software''), to deal in the Software without restriction, including
   7    without limitation the rights to use, copy, modify, merge, publish,
   8    distribute, sublicense, and/or sell copies of the Software, and to
   9    permit persons to whom the Software is furnished to do so, subject to
  10    the following conditions:
  11
  12    The above copyright notice and this permission notice shall be included
  13    in all copies or substantial portions of the Software.
  14
  15    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18    IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21    OTHER DEALINGS IN THE SOFTWARE.
  22    ----------------------------------------------------------------------- */
  23
  24 #include <ffi.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <float.h>
  29
  30 /* This is lame. Long double support is barely there under SunOS 4.x  */
  31 #if defined(SPARC) && (SIZEOF_LONG_DOUBLE != 16)
  32 #define BROKEN_LONG_DOUBLE
  33 #endif
  34
  35 #define CHECK(x) !(x) ? fail(__FILE__, __LINE__) : 0
  36
  37 static int fail(char *file, int line)
  38 {
  39   fprintf(stderr, "Test failure: %s line %d\n", file, line);
  40   exit(EXIT_FAILURE);
  41   /*@notreached@*/
  42   return 0;
  43 }
  44
  45 #define MAX_ARGS 256
  46
  47 static size_t my_strlen(char *s)
  48 {
  49   return (strlen(s));
  50 }
  51
  52 #ifdef X86_WIN32
  53 static size_t __attribute__((stdcall)) my_stdcall_strlen(char *s)
  54 {
  55   return (strlen(s));
  56 }
  57 #endif /* X86_WIN32 */
  58
  59 static int promotion(signed char sc, signed short ss,
  60                      unsigned char uc, unsigned short us)
  61 {
  62   int r = (int) sc + (int) ss + (int) uc + (int) us;
  63
  64   return r;
  65 }
  66
  67 static signed char return_sc(signed char sc)
  68 {
  69   return sc;
  70 }
  71
  72 static unsigned char return_uc(unsigned char uc)
  73 {
  74   return uc;
  75 }
  76
  77 static long long return_ll(long long ll)
  78 {
  79   return ll;
  80 }
  81
  82 static int floating(int a, float b, double c, long double d, int e)
  83 {
  84   int i;
  85
  86 #if 0
  87   /* This is ifdef'd out for now. long double support under SunOS/gcc
  88      is pretty much non-existent.  You'll get the odd bus error in library
  89      routines like printf().  */
  90   printf("%d %f %f %Lf %d\n", a, (double)b, c, d, e);
  91 #endif
  92
  93   i = (int) ((float)a/b + ((float)c/(float)d));
  94
  95   return i;
  96 }
  97
  98 static float many(float f1,
  99                   float f2,
 100                   float f3,
 101                   float f4,
 102                   float f5,
 103                   float f6,
 104                   float f7,
 105                   float f8,
 106                   float f9,
 107                   float f10,
 108                   float f11,
 109                   float f12,
 110                   float f13)
 111 {
 112 #if 0
 113   printf("%f %f %f %f %f %f %f %f %f %f %f %f %f\n",
 114          (double) f1, (double) f2, (double) f3, (double) f4, (double) f5,
 115          (double) f6, (double) f7, (double) f8, (double) f9, (double) f10,
 116          (double) f11, (double) f12, (double) f13);
 117 #endif
 118
 119   return ((f1/f2+f3/f4+f5/f6+f7/f8+f9/f10+f11/f12) * f13);
 120 }
 121
 122 #ifdef X86_WIN32
 123 static float __attribute__((stdcall)) stdcall_many(float f1,
 124                                                    float f2,
 125                                                    float f3,
 126                                                    float f4,
 127                                                    float f5,
 128                                                    float f6,
 129                                                    float f7,
 130                                                    float f8,
 131                                                    float f9,
 132                                                    float f10,
 133                                                    float f11,
 134                                                    float f12,
 135                                                    float f13)
 136 {
 137   return ((f1/f2+f3/f4+f5/f6+f7/f8+f9/f10+f11/f12) * f13);
 138 }
 139 #endif /* X86_WIN32 */
 140
 141 static double dblit(float f)
 142 {
 143   return f/3.0;
 144 }
 145
 146 static long double ldblit(float f)
 147 {
 148   return (long double) (((long double) f)/ (long double) 3.0);
 149 }
 150
 151 typedef struct
 152 {
 153   unsigned char uc;
 154   double d;
 155   unsigned int ui;
 156 } test_structure_1;
 157
 158 typedef struct
 159 {
 160   double d1;
 161   double d2;
 162 } test_structure_2;
 163
 164 typedef struct
 165 {
 166   int si;
 167 } test_structure_3;
 168
 169 typedef struct
 170 {
 171   unsigned ui1;
 172   unsigned ui2;
 173   unsigned ui3;
 174 } test_structure_4;
 175
 176 typedef struct
 177 {
 178   char c1;
 179   char c2;
 180 } test_structure_5;
 181
 182 typedef struct
 183 {
 184   float f;
 185   double d;
 186 } test_structure_6;
 187
 188 typedef struct
 189 {
 190   float f1;
 191   float f2;
 192   double d;
 193 } test_structure_7;
 194
 195 typedef struct
 196 {
 197   float f1;
 198   float f2;
 199   float f3;
 200   float f4;
 201 } test_structure_8;
 202
 203 typedef struct
 204 {
 205   float f;
 206   int i;
 207 } test_structure_9;
 208
 209 static test_structure_1 struct1(test_structure_1 ts)
 210 {
 211   /*@-type@*/
 212   ts.uc++;
 213   /*@=type@*/
 214   ts.d--;
 215   ts.ui++;
 216
 217   return ts;
 218 }
 219
 220 static test_structure_2 struct2(test_structure_2 ts)
 221 {
 222   ts.d1--;
 223   ts.d2--;
 224
 225   return ts;
 226 }
 227
 228 static test_structure_3 struct3(test_structure_3 ts)
 229 {
 230   ts.si = -(ts.si*2);
 231
 232   return ts;
 233 }
 234
 235 static test_structure_4 struct4(test_structure_4 ts)
 236 {
 237   ts.ui3 = ts.ui1 * ts.ui2 * ts.ui3;
 238
 239   return ts;
 240 }
 241
 242 static test_structure_5 struct5(test_structure_5 ts1, test_structure_5 ts2)
 243 {
 244   ts1.c1 += ts2.c1;
 245   ts1.c2 -= ts2.c2;
 246
 247   return ts1;
 248 }
 249
 250 static test_structure_6 struct6 (test_structure_6 ts)
 251 {
 252   ts.f += 1;
 253   ts.d += 1;
 254
 255   return ts;
 256 }
 257
 258 static test_structure_7 struct7 (test_structure_7 ts)
 259 {
 260   ts.f1 += 1;
 261   ts.f2 += 1;
 262   ts.d += 1;
 263
 264   return ts;
 265 }
 266
 267 static test_structure_8 struct8 (test_structure_8 ts)
 268 {
 269   ts.f1 += 1;
 270   ts.f2 += 1;
 271   ts.f3 += 1;
 272   ts.f4 += 1;
 273
 274   return ts;
 275 }
 276
 277 static test_structure_9 struct9 (test_structure_9 ts)
 278 {
 279   ts.f += 1;
 280   ts.i += 1;
 281
 282   return ts;
 283 }
 284
 285 /* Take an int and a float argument, together with int userdata, and    */
 286 /* return the sum.                                                      */
 287 #if FFI_CLOSURES
 288 static void
 289 closure_test_fn(ffi_cif* cif,void* resp,void** args, void* userdata)
 290 {
 291   *(ffi_arg*)resp =
 292     (int)*(unsigned long long *)args[0] + (int)(*(int *)args[1]) +
 293     (int)(*(unsigned long long *)args[2]) + (int)*(int *)args[3] +
 294     (int)(*(signed short *)args[4]) +
 295     (int)(*(unsigned long long *)args[5]) +
 296     (int)*(int *)args[6] + (int)(*(int *)args[7]) +
 297     (int)(*(double *)args[8]) + (int)*(int *)args[9] +
 298     (int)(*(int *)args[10]) + (int)(*(float *)args[11]) +
 299     (int)*(int *)args[12] + (int)(*(int *)args[13]) +
 300     (int)(*(int *)args[14]) +  *(int *)args[15] + (int)(long)userdata;
 301
 302         printf("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d: %d\n",
 303                (int)*(unsigned long long *)args[0], (int)(*(int *)args[1]),
 304                (int)(*(unsigned long long *)args[2]),
 305                (int)*(int *)args[3], (int)(*(signed short *)args[4]),
 306                (int)(*(unsigned long long *)args[5]),
 307                (int)*(int *)args[6], (int)(*(int *)args[7]),
 308                (int)(*(double *)args[8]), (int)*(int *)args[9],
 309                (int)(*(int *)args[10]), (int)(*(float *)args[11]),
 310                (int)*(int *)args[12], (int)(*(int *)args[13]),
 311                (int)(*(int *)args[14]),*(int *)args[15],
 312                (int)(long)userdata, (int)*(ffi_arg *)resp);
 313 }
 314
 315 typedef int (*closure_test_type)(unsigned long long, int, unsigned long long,
 316                                  int, signed short, unsigned long long, int,
 317                                  int, double, int, int, float, int, int,
 318                                  int, int);
 319
 320 static void closure_test_fn1(ffi_cif* cif,void* resp,void** args,
 321                              void* userdata)
 322  {
 323     *(ffi_arg*)resp =
 324       (int)*(float *)args[0] +(int)(*(float *)args[1]) +
 325       (int)(*(float *)args[2]) + (int)*(float *)args[3] +
 326       (int)(*(signed short *)args[4]) + (int)(*(float *)args[5]) +
 327       (int)*(float *)args[6] + (int)(*(int *)args[7]) +
 328       (int)(*(double*)args[8]) + (int)*(int *)args[9] +
 329       (int)(*(int *)args[10]) + (int)(*(float *)args[11]) +
 330       (int)*(int *)args[12] + (int)(*(int *)args[13]) +
 331       (int)(*(int *)args[14]) + *(int *)args[15] + (int)(long)userdata;
 332
 333     printf("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d: %d\n",
 334            (int)*(float *)args[0], (int)(*(float *)args[1]),
 335            (int)(*(float *)args[2]), (int)*(float *)args[3],
 336            (int)(*(signed short *)args[4]), (int)(*(float *)args[5]),
 337            (int)*(float *)args[6], (int)(*(int *)args[7]),
 338            (int)(*(double *)args[8]), (int)*(int *)args[9],
 339            (int)(*(int *)args[10]), (int)(*(float *)args[11]),
 340            (int)*(int *)args[12], (int)(*(int *)args[13]),
 341            (int)(*(int *)args[14]), *(int *)args[15],
 342            (int)(long)userdata, (int)*(ffi_arg *)resp);
 343 }
 344
 345 typedef int (*closure_test_type1)(float, float, float, float, signed short,
 346                                   float, float, int, double, int, int, float,
 347                                   int, int, int, int);
 348
 349 static void closure_test_fn2(ffi_cif* cif,void* resp,void** args,
 350                              void* userdata)
 351  {
 352     *(ffi_arg*)resp =
 353       (int)*(double *)args[0] +(int)(*(double *)args[1]) +
 354       (int)(*(double *)args[2]) + (int)*(double *)args[3] +
 355       (int)(*(signed short *)args[4]) + (int)(*(double *)args[5]) +
 356       (int)*(double *)args[6] + (int)(*(int *)args[7]) +
 357       (int)(*(double *)args[8]) + (int)*(int *)args[9] +
 358       (int)(*(int *)args[10]) + (int)(*(float *)args[11]) +
 359       (int)*(int *)args[12] + (int)(*(float *)args[13]) +
 360       (int)(*(int *)args[14]) + *(int *)args[15] + (int)(long)userdata;
 361
 362     printf("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d: %d\n",
 363            (int)*(double *)args[0], (int)(*(double *)args[1]),
 364            (int)(*(double *)args[2]), (int)*(double *)args[3],
 365            (int)(*(signed short *)args[4]), (int)(*(double *)args[5]),
 366            (int)*(double *)args[6], (int)(*(int *)args[7]),
 367            (int)(*(double*)args[8]), (int)*(int *)args[9],
 368            (int)(*(int *)args[10]), (int)(*(float *)args[11]),
 369            (int)*(int *)args[12], (int)(*(float *)args[13]),
 370            (int)(*(int *)args[14]), *(int *)args[15], (int)(long)userdata,
 371            (int)*(ffi_arg *)resp);
 372  }
 373
 374 typedef int (*closure_test_type2)(double, double, double, double, signed short,
 375                                   double, double, int, double, int, int, float,
 376                                   int, float, int, int);
 377
 378 static void closure_test_fn3(ffi_cif* cif,void* resp,void** args,
 379                              void* userdata)
 380  {
 381     *(ffi_arg*)resp =
 382       (int)*(float *)args[0] +(int)(*(float *)args[1]) +
 383       (int)(*(float *)args[2]) + (int)*(float *)args[3] +
 384       (int)(*(float *)args[4]) + (int)(*(float *)args[5]) +
 385       (int)*(float *)args[6] + (int)(*(float *)args[7]) +
 386       (int)(*(double *)args[8]) + (int)*(int *)args[9] +
 387       (int)(*(float *)args[10]) + (int)(*(float *)args[11]) +
 388       (int)*(int *)args[12] + (int)(*(float *)args[13]) +
 389       (int)(*(float *)args[14]) +  *(int *)args[15] + (int)(long)userdata;
 390
 391     printf("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d: %d\n",
 392            (int)*(float *)args[0], (int)(*(float *)args[1]),
 393            (int)(*(float *)args[2]), (int)*(float *)args[3],
 394            (int)(*(float *)args[4]), (int)(*(float *)args[5]),
 395            (int)*(float *)args[6], (int)(*(float *)args[7]),
 396            (int)(*(double *)args[8]), (int)*(int *)args[9],
 397            (int)(*(float *)args[10]), (int)(*(float *)args[11]),
 398            (int)*(int *)args[12], (int)(*(float *)args[13]),
 399            (int)(*(float *)args[14]), *(int *)args[15], (int)(long)userdata,
 400            (int)*(ffi_arg *)resp);
 401  }
 402
 403 typedef int (*closure_test_type3)(float, float, float, float, float, float,
 404                                   float, float, double, int, float, float, int,
 405                                   float, float, int);
 406 #endif
 407
 408 int main(/*@unused@*/ int argc, /*@unused@*/ char *argv[])
 409 {
 410   ffi_cif cif;
 411   ffi_type *args[MAX_ARGS];
 412   void *values[MAX_ARGS];
 413   char *s;
 414   signed char sc;
 415   unsigned char uc;
 416   signed short ss;
 417   unsigned short us;
 418   unsigned long ul;
 419   long long ll;
 420   float f;
 421   double d;
 422   long double ld;
 423   signed int si1;
 424   signed int si2;
 425
 426   ffi_arg rint;
 427   long long rlonglong;
 428
 429 # if FFI_CLOSURES
 430   /* The closure must not be an automatic variable on
 431      platforms (Solaris) that forbid stack execution by default. */
 432   static ffi_closure cl;
 433   ffi_closure *pcl = &cl;
 434 #endif
 435
 436   ffi_type * cl_arg_types[17];
 437
 438   ffi_type ts1_type;
 439   ffi_type ts2_type;
 440   ffi_type ts3_type;
 441   ffi_type ts4_type;
 442   ffi_type ts5_type;
 443   ffi_type ts6_type;
 444   ffi_type ts7_type;
 445   ffi_type ts8_type;
 446   ffi_type ts9_type;
 447   ffi_type *ts1_type_elements[4];
 448   ffi_type *ts2_type_elements[3];
 449   ffi_type *ts3_type_elements[2];
 450   ffi_type *ts4_type_elements[4];
 451   ffi_type *ts5_type_elements[3];
 452   ffi_type *ts6_type_elements[3];
 453   ffi_type *ts7_type_elements[4];
 454   ffi_type *ts8_type_elements[5];
 455   ffi_type *ts9_type_elements[3];
 456
 457   ts1_type.size = 0;
 458   ts1_type.alignment = 0;
 459   ts1_type.type = FFI_TYPE_STRUCT;
 460
 461   ts2_type.size = 0;
 462   ts2_type.alignment = 0;
 463   ts2_type.type = FFI_TYPE_STRUCT;
 464
 465   ts3_type.size = 0;
 466   ts3_type.alignment = 0;
 467   ts3_type.type = FFI_TYPE_STRUCT;
 468
 469   ts4_type.size = 0;
 470   ts4_type.alignment = 0;
 471   ts4_type.type = FFI_TYPE_STRUCT;
 472
 473   ts5_type.size = 0;
 474   ts5_type.alignment = 0;
 475   ts5_type.type = FFI_TYPE_STRUCT;
 476
 477   ts6_type.size = 0;
 478   ts6_type.alignment = 0;
 479   ts6_type.type = FFI_TYPE_STRUCT;
 480
 481   ts7_type.size = 0;
 482   ts7_type.alignment = 0;
 483   ts7_type.type = FFI_TYPE_STRUCT;
 484
 485   ts8_type.size = 0;
 486   ts8_type.alignment = 0;
 487   ts8_type.type = FFI_TYPE_STRUCT;
 488
 489   ts9_type.size = 0;
 490   ts9_type.alignment = 0;
 491   ts9_type.type = FFI_TYPE_STRUCT;
 492
 493   /*@-immediatetrans@*/
 494   ts1_type.elements = ts1_type_elements;
 495   ts2_type.elements = ts2_type_elements;
 496   ts3_type.elements = ts3_type_elements;
 497   ts4_type.elements = ts4_type_elements;
 498   ts5_type.elements = ts5_type_elements;
 499   ts6_type.elements = ts6_type_elements;
 500   ts7_type.elements = ts7_type_elements;
 501   ts8_type.elements = ts8_type_elements;
 502   ts9_type.elements = ts9_type_elements;
 503   /*@=immediatetrans@*/
 504
 505   ts1_type_elements[0] = &ffi_type_uchar;
 506   ts1_type_elements[1] = &ffi_type_double;
 507   ts1_type_elements[2] = &ffi_type_uint;
 508   ts1_type_elements[3] = NULL;
 509
 510   ts2_type_elements[0] = &ffi_type_double;
 511   ts2_type_elements[1] = &ffi_type_double;
 512   ts2_type_elements[2] = NULL;
 513
 514   ts3_type_elements[0] = &ffi_type_sint;
 515   ts3_type_elements[1] = NULL;
 516
 517   ts4_type_elements[0] = &ffi_type_uint;
 518   ts4_type_elements[1] = &ffi_type_uint;
 519   ts4_type_elements[2] = &ffi_type_uint;
 520   ts4_type_elements[3] = NULL;
 521
 522   ts5_type_elements[0] = &ffi_type_schar;
 523   ts5_type_elements[1] = &ffi_type_schar;
 524   ts5_type_elements[2] = NULL;
 525
 526   ts6_type_elements[0] = &ffi_type_float;
 527   ts6_type_elements[1] = &ffi_type_double;
 528   ts6_type_elements[2] = NULL;
 529
 530   ts7_type_elements[0] = &ffi_type_float;
 531   ts7_type_elements[1] = &ffi_type_float;
 532   ts7_type_elements[2] = &ffi_type_double;
 533   ts7_type_elements[3] = NULL;
 534
 535   ts8_type_elements[0] = &ffi_type_float;
 536   ts8_type_elements[1] = &ffi_type_float;
 537   ts8_type_elements[2] = &ffi_type_float;
 538   ts8_type_elements[3] = &ffi_type_float;
 539   ts8_type_elements[4] = NULL;
 540
 541   ts9_type_elements[0] = &ffi_type_float;
 542   ts9_type_elements[1] = &ffi_type_sint;
 543   ts9_type_elements[2] = NULL;
 544
 545   ul = 0;
 546
 547   /* return value tests */
 548   {
 549 #if defined(MIPS) /* || defined(ARM) */
 550     puts ("long long tests not run. This is a known bug on this architecture.");
 551 #else
 552     args[0] = &ffi_type_sint64;
 553     values[0] = &ll;
 554
 555     /* Initialize the cif */
 556     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 557                        &ffi_type_sint64, args) == FFI_OK);
 558
 559     for (ll = 0LL; ll < 100LL; ll++)
 560       {
 561         ul++;
 562         ffi_call(&cif, FFI_FN(return_ll), &rlonglong, values);
 563         CHECK(rlonglong == ll);
 564       }
 565
 566     for (ll = 55555555555000LL; ll < 55555555555100LL; ll++)
 567       {
 568         ul++;
 569         ffi_call(&cif, FFI_FN(return_ll), &rlonglong, values);
 570         CHECK(rlonglong == ll);
 571       }
 572 #endif
 573
 574     args[0] = &ffi_type_schar;
 575     values[0] = &sc;
 576
 577     /* Initialize the cif */
 578     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 579                        &ffi_type_schar, args) == FFI_OK);
 580
 581     for (sc = (signed char) -127;
 582          sc < (signed char) 127; /*@-type@*/ sc++ /*@=type@*/)
 583       {
 584         ul++;
 585         ffi_call(&cif, FFI_FN(return_sc), &rint, values);
 586         CHECK(rint == (ffi_arg) sc);
 587       }
 588
 589     args[0] = &ffi_type_uchar;
 590     values[0] = &uc;
 591
 592     /* Initialize the cif */
 593     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 594                        &ffi_type_uchar, args) == FFI_OK);
 595
 596     for (uc = (unsigned char) '\x00';
 597          uc < (unsigned char) '\xff'; /*@-type@*/ uc++ /*@=type@*/)
 598       {
 599         ul++;
 600         ffi_call(&cif, FFI_FN(return_uc), &rint, values);
 601         CHECK(rint == (signed int) uc);
 602       }
 603
 604     printf("%lu return value tests run\n", ul);
 605   }
 606
 607 #ifdef BROKEN_LONG_DOUBLE
 608   printf ("This architecture has broken `long double' support. No floating point\ntests have been run.\n");
 609 #else
 610   /* float arg tests */
 611   {
 612     args[0] = &ffi_type_float;
 613     values[0] = &f;
 614
 615     /* Initialize the cif */
 616     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 617                        &ffi_type_longdouble, args) == FFI_OK);
 618
 619     f = 3.14159;
 620
 621 #if 0
 622   /* This is ifdef'd out for now. long double support under SunOS/gcc
 623      is pretty much non-existent.  You'll get the odd bus error in library
 624      routines like printf().  */
 625     printf ("%Lf\n", ldblit(f));
 626 #endif
 627     ld = 666;
 628     ffi_call(&cif, FFI_FN(ldblit), &ld, values);
 629
 630 #if 0
 631   /* This is ifdef'd out for now. long double support under SunOS/gcc
 632      is pretty much non-existent.  You'll get the odd bus error in library
 633      routines like printf().  */
 634     printf ("%Lf, %Lf, %Lf, %Lf\n", ld, ldblit(f), ld - ldblit(f), LDBL_EPSILON);
 635 #endif
 636
 637     /* These are not always the same!! Check for a reasonable delta */
 638     /*@-realcompare@*/
 639     if (ld - ldblit(f) < LDBL_EPSILON)
 640     /*@=realcompare@*/
 641         puts("long double return value tests ok!");
 642     else
 643         CHECK(0);
 644   }
 645
 646   /* float arg tests */
 647   {
 648     args[0] = &ffi_type_sint;
 649     values[0] = &si1;
 650     args[1] = &ffi_type_float;
 651     values[1] = &f;
 652     args[2] = &ffi_type_double;
 653     values[2] = &d;
 654     args[3] = &ffi_type_longdouble;
 655     values[3] = &ld;
 656     args[4] = &ffi_type_sint;
 657     values[4] = &si2;
 658
 659     /* Initialize the cif */
 660     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 5,
 661                        &ffi_type_sint, args) == FFI_OK);
 662
 663     si1 = 6;
 664     f = 3.14159;
 665     d = (double)1.0/(double)3.0;
 666     ld = 2.71828182846L;
 667     si2 = 10;
 668
 669     floating (si1, f, d, ld, si2);
 670
 671     ffi_call(&cif, FFI_FN(floating), &rint, values);
 672
 673     printf ("%d vs %d\n", (int)rint, floating (si1, f, d, ld, si2));
 674
 675     CHECK(rint == floating(si1, f, d, ld, si2));
 676
 677     printf("float arg tests ok!\n");
 678   }
 679 #endif
 680
 681   /* strlen tests */
 682   {
 683     args[0] = &ffi_type_pointer;
 684     values[0] = (void*) &s;
 685
 686     /* Initialize the cif */
 687     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 688                        &ffi_type_sint, args) == FFI_OK);
 689
 690     s = "a";
 691     ffi_call(&cif, FFI_FN(my_strlen), &rint, values);
 692     CHECK(rint == 1);
 693
 694     s = "1234567";
 695     ffi_call(&cif, FFI_FN(my_strlen), &rint, values);
 696     CHECK(rint == 7);
 697
 698     s = "1234567890123456789012345";
 699     ffi_call(&cif, FFI_FN(my_strlen), &rint, values);
 700     CHECK(rint == 25);
 701
 702     printf("strlen tests passed\n");
 703   }
 704
 705   /* float arg tests */
 706   {
 707     args[0] = &ffi_type_float;
 708     values[0] = &f;
 709
 710     /* Initialize the cif */
 711     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 712                        &ffi_type_double, args) == FFI_OK);
 713
 714     f = 3.14159;
 715
 716     ffi_call(&cif, FFI_FN(dblit), &d, values);
 717
 718     /* These are not always the same!! Check for a reasonable delta */
 719     /*@-realcompare@*/
 720     CHECK(d - dblit(f) < DBL_EPSILON);
 721     /*@=realcompare@*/
 722
 723     printf("double return value tests ok!\n");
 724   }
 725
 726   /* many arg tests */
 727   {
 728     float ff;
 729     float fa[13];
 730
 731     for (ul = 0; ul < 13; ul++)
 732       {
 733         args[ul] = &ffi_type_float;
 734         values[ul] = &fa[ul];
 735         fa[ul] = (float) ul;
 736       }
 737
 738     /* Initialize the cif */
 739     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 13,
 740                        &ffi_type_float, args) == FFI_OK);
 741
 742     /*@-usedef@*/
 743     ff = many (fa[0], fa[1],
 744                fa[2], fa[3],
 745                fa[4], fa[5],
 746                fa[6], fa[7],
 747                fa[8], fa[9],
 748                fa[10],fa[11],fa[12]);
 749     /*@=usedef@*/
 750
 751     ffi_call(&cif, FFI_FN(many), &f, values);
 752
 753     /*@-realcompare@*/
 754     if (f - ff < FLT_EPSILON)
 755     /*@=realcompare@*/
 756         printf("many arg tests ok!\n");
 757     else
 758 #ifdef POWERPC
 759         printf("many arg tests failed!  This is a gcc bug.\n");
 760 #else
 761         CHECK(0);
 762 #endif
 763   }
 764
 765   /* promotion tests */
 766   {
 767     args[0] = &ffi_type_schar;
 768     args[1] = &ffi_type_sshort;
 769     args[2] = &ffi_type_uchar;
 770     args[3] = &ffi_type_ushort;
 771     values[0] = &sc;
 772     values[1] = &ss;
 773     values[2] = &uc;
 774     values[3] = &us;
 775
 776     /* Initialize the cif */
 777     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 4,
 778                        &ffi_type_sint, args) == FFI_OK);
 779
 780     us = 0;
 781     ul = 0;
 782
 783     for (sc = (signed char) -127;
 784          sc <= (signed char) 120; /*@-type@*/ sc += 1 /*@=type@*/)
 785       for (ss = -30000; ss <= 30000; ss += 10000)
 786         for (uc = (unsigned char) 0;
 787              uc <= (unsigned char) 200; /*@-type@*/ uc += 20 /*@=type@*/)
 788           for (us = 0; us <= 60000; us += 10000)
 789             {
 790               ul++;
 791               ffi_call(&cif, FFI_FN(promotion), &rint, values);
 792               CHECK((int)rint == (signed char) sc + (signed short) ss +
 793                     (unsigned char) uc + (unsigned short) us);
 794             }
 795     printf("%lu promotion tests run\n", ul);
 796   }
 797
 798 #ifndef X86_WIN32 /* Structures dont work on Win32 */
 799
 800   /* struct tests */
 801   {
 802     test_structure_1 ts1_arg;
 803     /* This is a hack to get a properly aligned result buffer */
 804     test_structure_1 *ts1_result =
 805       (test_structure_1 *) malloc (sizeof(test_structure_1));
 806
 807     args[0] = &ts1_type;
 808     values[0] = &ts1_arg;
 809
 810     /* Initialize the cif */
 811     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 812                        &ts1_type, args) == FFI_OK);
 813
 814     ts1_arg.uc = '\x01';
 815     ts1_arg.d = 3.14159;
 816     ts1_arg.ui = 555;
 817
 818     ffi_call(&cif, FFI_FN(struct1), ts1_result, values);
 819
 820     CHECK(ts1_result->ui == 556);
 821     CHECK(ts1_result->d == 3.14159 - 1);
 822
 823     puts ("structure test 1 ok!\n");
 824
 825     free (ts1_result);
 826   }
 827
 828   /* struct tests */
 829   {
 830     test_structure_2 ts2_arg;
 831
 832     /* This is a hack to get a properly aligned result buffer */
 833     test_structure_2 *ts2_result =
 834       (test_structure_2 *) malloc (sizeof(test_structure_2));
 835
 836     args[0] = &ts2_type;
 837     values[0] = &ts2_arg;
 838
 839     /* Initialize the cif */
 840     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ts2_type, args) == FFI_OK);
 841
 842     ts2_arg.d1 = 5.55;
 843     ts2_arg.d2 = 6.66;
 844
 845     printf ("%g\n", ts2_arg.d1);
 846     printf ("%g\n", ts2_arg.d2);
 847
 848     ffi_call(&cif, FFI_FN(struct2), ts2_result, values);
 849
 850     printf ("%g\n", ts2_result->d1);
 851     printf ("%g\n", ts2_result->d2);
 852
 853     CHECK(ts2_result->d1 == 5.55 - 1);
 854     CHECK(ts2_result->d2 == 6.66 - 1);
 855
 856     printf("structure test 2 ok!\n");
 857
 858     free (ts2_result);
 859   }
 860
 861   /* struct tests */
 862   {
 863     int compare_value;
 864     test_structure_3 ts3_arg;
 865     test_structure_3 *ts3_result =
 866       (test_structure_3 *) malloc (sizeof(test_structure_3));
 867
 868     args[0] = &ts3_type;
 869     values[0] = &ts3_arg;
 870
 871     /* Initialize the cif */
 872     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
 873                        &ts3_type, args) == FFI_OK);
 874
 875     ts3_arg.si = -123;
 876     compare_value = ts3_arg.si;
 877
 878     ffi_call(&cif, FFI_FN(struct3), ts3_result, values);
 879
 880     printf ("%d %d\n", ts3_result->si, -(compare_value*2));
 881
 882     if (ts3_result->si == -(ts3_arg.si*2))
 883         puts ("structure test 3 ok!");
 884     else
 885       {
 886         puts ("Structure test 3 found structure passing bug.");
 887         puts ("  Current versions of GCC are not 100% compliant with the");
 888         puts ("  n32 ABI.  There is a known problem related to passing");
 889         puts ("  small structures.  Send a bug report to the gcc maintainers.");
 890       }
 891
 892     free (ts3_result);
 893   }
 894
 895   /* struct tests */
 896   {
 897     test_structure_4 ts4_arg;
 898
 899     /* This is a hack to get a properly aligned result buffer */
 900     test_structure_4 *ts4_result =
 901       (test_structure_4 *) malloc (sizeof(test_structure_4));
 902
 903     args[0] = &ts4_type;
 904     values[0] = &ts4_arg;
 905
 906     /* Initialize the cif */
 907     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ts4_type, args) == FFI_OK);
 908
 909     ts4_arg.ui1 = 2;
 910     ts4_arg.ui2 = 3;
 911     ts4_arg.ui3 = 4;
 912
 913     ffi_call (&cif, FFI_FN(struct4), ts4_result, values);
 914
 915     if (ts4_result->ui3 == 2U * 3U * 4U)
 916       puts ("structure test 4 ok!");
 917     else
 918       puts ("Structure test 4 found GCC's structure passing bug.");
 919
 920     free (ts4_result);
 921   }
 922
 923   /* struct tests */
 924   {
 925     test_structure_5 ts5_arg1, ts5_arg2;
 926
 927     /* This is a hack to get a properly aligned result buffer */
 928     test_structure_5 *ts5_result =
 929       (test_structure_5 *) malloc (sizeof(test_structure_5));
 930
 931     args[0] = &ts5_type;
 932     args[1] = &ts5_type;
 933     values[0] = &ts5_arg1;
 934     values[1] = &ts5_arg2;
 935
 936     /* Initialize the cif */
 937     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &ts5_type, args) == FFI_OK);
 938
 939     ts5_arg1.c1 = 2;
 940     ts5_arg1.c2 = 6;
 941     ts5_arg2.c1 = 5;
 942     ts5_arg2.c2 = 3;
 943
 944     ffi_call (&cif, FFI_FN(struct5), ts5_result, values);
 945
 946     if (ts5_result->c1 == 7
 947         && ts5_result->c2 == 3)
 948       puts ("structure test 5 ok!");
 949     else
 950       puts ("Structure test 5 found GCC's structure passing bug.");
 951
 952     free (ts5_result);
 953   }
 954
 955   /* struct tests */
 956   {
 957     test_structure_6 ts6_arg;
 958
 959     /* This is a hack to get a properly aligned result buffer */
 960     test_structure_6 *ts6_result =
 961       (test_structure_6 *) malloc (sizeof(test_structure_6));
 962
 963     args[0] = &ts6_type;
 964     values[0] = &ts6_arg;
 965
 966     /* Initialize the cif */
 967     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ts6_type, args) == FFI_OK);
 968
 969     ts6_arg.f = 5.55f;
 970     ts6_arg.d = 6.66;
 971
 972     printf ("%g\n", ts6_arg.f);
 973     printf ("%g\n", ts6_arg.d);
 974
 975     ffi_call(&cif, FFI_FN(struct6), ts6_result, values);
 976
 977     printf ("%g\n", ts6_result->f);
 978     printf ("%g\n", ts6_result->d);
 979
 980     CHECK(ts6_result->f == 5.55f + 1);
 981     CHECK(ts6_result->d == 6.66 + 1);
 982
 983     printf("structure test 6 ok!\n");
 984
 985     free (ts6_result);
 986   }
 987
 988   /* struct tests */
 989   {
 990     test_structure_7 ts7_arg;
 991
 992     /* This is a hack to get a properly aligned result buffer */
 993     test_structure_7 *ts7_result =
 994       (test_structure_7 *) malloc (sizeof(test_structure_7));
 995
 996     args[0] = &ts7_type;
 997     values[0] = &ts7_arg;
 998
 999     /* Initialize the cif */
1000     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ts7_type, args) == FFI_OK);
1001
1002     ts7_arg.f1 = 5.55f;
1003     ts7_arg.f2 = 55.5f;
1004     ts7_arg.d = 6.66;
1005
1006     printf ("%g\n", ts7_arg.f1);
1007     printf ("%g\n", ts7_arg.f2);
1008     printf ("%g\n", ts7_arg.d);
1009
1010     ffi_call(&cif, FFI_FN(struct7), ts7_result, values);
1011
1012     printf ("%g\n", ts7_result->f1);
1013     printf ("%g\n", ts7_result->f2);
1014     printf ("%g\n", ts7_result->d);
1015
1016     CHECK(ts7_result->f1 == 5.55f + 1);
1017     CHECK(ts7_result->f2 == 55.5f + 1);
1018     CHECK(ts7_result->d == 6.66 + 1);
1019
1020     printf("structure test 7 ok!\n");
1021
1022     free (ts7_result);
1023   }
1024
1025   /* struct tests */
1026   {
1027     test_structure_8 ts8_arg;
1028
1029     /* This is a hack to get a properly aligned result buffer */
1030     test_structure_8 *ts8_result =
1031       (test_structure_8 *) malloc (sizeof(test_structure_8));
1032
1033     args[0] = &ts8_type;
1034     values[0] = &ts8_arg;
1035
1036     /* Initialize the cif */
1037     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ts8_type, args) == FFI_OK);
1038
1039     ts8_arg.f1 = 5.55f;
1040     ts8_arg.f2 = 55.5f;
1041     ts8_arg.f3 = -5.55f;
1042     ts8_arg.f4 = -55.5f;
1043
1044     printf ("%g\n", ts8_arg.f1);
1045     printf ("%g\n", ts8_arg.f2);
1046     printf ("%g\n", ts8_arg.f3);
1047     printf ("%g\n", ts8_arg.f4);
1048
1049     ffi_call(&cif, FFI_FN(struct8), ts8_result, values);
1050
1051     printf ("%g\n", ts8_result->f1);
1052     printf ("%g\n", ts8_result->f2);
1053     printf ("%g\n", ts8_result->f3);
1054     printf ("%g\n", ts8_result->f4);
1055
1056     CHECK(ts8_result->f1 == 5.55f + 1);
1057     CHECK(ts8_result->f2 == 55.5f + 1);
1058     CHECK(ts8_result->f3 == -5.55f + 1);
1059     CHECK(ts8_result->f4 == -55.5f + 1);
1060
1061     printf("structure test 8 ok!\n");
1062
1063     free (ts8_result);
1064   }
1065
1066   /* struct tests */
1067   {
1068     test_structure_9 ts9_arg;
1069
1070     /* This is a hack to get a properly aligned result buffer */
1071     test_structure_9 *ts9_result =
1072       (test_structure_9 *) malloc (sizeof(test_structure_9));
1073
1074     args[0] = &ts9_type;
1075     values[0] = &ts9_arg;
1076
1077     /* Initialize the cif */
1078     CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ts9_type, args) == FFI_OK);
1079
1080     ts9_arg.f = 5.55f;
1081     ts9_arg.i = 5;
1082
1083     printf ("%g\n", ts9_arg.f);
1084     printf ("%d\n", ts9_arg.i);
1085
1086     ffi_call(&cif, FFI_FN(struct9), ts9_result, values);
1087
1088     printf ("%g\n", ts9_result->f);
1089     printf ("%d\n", ts9_result->i);
1090
1091     CHECK(ts9_result->f == 5.55f + 1);
1092     CHECK(ts9_result->i == 5 + 1);
1093
1094     printf("structure test 9 ok!\n");
1095
1096     free (ts9_result);
1097   }
1098
1099 #else
1100   printf("Structure passing doesn't work on Win32.\n");
1101 #endif /* X86_WIN32 */
1102
1103 #ifdef X86_WIN32
1104   /* stdcall strlen tests */
1105   {
1106     args[0] = &ffi_type_pointer;
1107     values[0] = (void*) &s;
1108
1109     /* Initialize the cif */
1110     CHECK(ffi_prep_cif(&cif, FFI_STDCALL, 1,
1111                        &ffi_type_sint, args) == FFI_OK);
1112
1113     s = "a";
1114     ffi_call(&cif, FFI_FN(my_stdcall_strlen), &rint, values);
1115     CHECK(rint == 1);
1116
1117     s = "1234567";
1118     ffi_call(&cif, FFI_FN(my_stdcall_strlen), &rint, values);
1119     CHECK(rint == 7);
1120
1121     s = "1234567890123456789012345";
1122     ffi_call(&cif, FFI_FN(my_stdcall_strlen), &rint, values);
1123     CHECK(rint == 25);
1124
1125     printf("stdcall strlen tests passed\n");
1126   }
1127
1128   /* stdcall many arg tests */
1129   {
1130     float ff;
1131     float fa[13];
1132
1133     for (ul = 0; ul < 13; ul++)
1134       {
1135         args[ul] = &ffi_type_float;
1136         values[ul] = &fa[ul];
1137         fa[ul] = (float) ul;
1138       }
1139
1140     /* Initialize the cif */
1141     CHECK(ffi_prep_cif(&cif, FFI_STDCALL, 13,
1142                        &ffi_type_float, args) == FFI_OK);
1143
1144     /*@-usedef@*/
1145     ff =  stdcall_many(fa[0], fa[1],
1146                fa[2], fa[3],
1147                fa[4], fa[5],
1148                fa[6], fa[7],
1149                fa[8], fa[9],
1150                fa[10],fa[11],fa[12]);
1151     /*@=usedef@*/
1152
1153     ffi_call(&cif, FFI_FN(stdcall_many), &f, values);
1154
1155     /*@-realcompare@*/
1156     if (f - ff < FLT_EPSILON)
1157     /*@=realcompare@*/
1158         printf("stdcall many arg tests ok!\n");
1159     else
1160         CHECK(0);
1161   }
1162 #endif /* X86_WIN32 */
1163
1164 # if FFI_CLOSURES
1165 #  if __GNUC__ >= 2
1166    /* Hide before the compiler that pcl is &cl, since on
1167       some architectures it is not possible to call a data
1168       object using direct function call.  */
1169    asm ("" : "=g" (pcl) : "0" (pcl));
1170 #  endif
1171
1172   /* A simple closure test */
1173     {
1174       (void) puts("\nEnter FFI_CLOSURES\n");
1175
1176       cl_arg_types[0] = &ffi_type_uint64;
1177       cl_arg_types[1] = &ffi_type_uint;
1178       cl_arg_types[2] = &ffi_type_uint64;
1179       cl_arg_types[3] = &ffi_type_uint;
1180       cl_arg_types[4] = &ffi_type_sshort;
1181       cl_arg_types[5] = &ffi_type_uint64;
1182       cl_arg_types[6] = &ffi_type_uint;
1183       cl_arg_types[7] = &ffi_type_uint;
1184       cl_arg_types[8] = &ffi_type_double;
1185       cl_arg_types[9] = &ffi_type_uint;
1186       cl_arg_types[10] = &ffi_type_uint;
1187       cl_arg_types[11] = &ffi_type_float;
1188       cl_arg_types[12] = &ffi_type_uint;
1189       cl_arg_types[13] = &ffi_type_uint;
1190       cl_arg_types[14] = &ffi_type_uint;
1191       cl_arg_types[15] = &ffi_type_uint;
1192       cl_arg_types[16] = NULL;
1193
1194       /* Initialize the cif */
1195       CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 16,
1196                          &ffi_type_sint, cl_arg_types) == FFI_OK);
1197
1198       CHECK(ffi_prep_closure(pcl, &cif, closure_test_fn,
1199                              (void *) 3 /* userdata */) == FFI_OK);
1200
1201       CHECK((*((closure_test_type)pcl))
1202             (1LL, 2, 3LL, 4, 127, 429LL, 7, 8, 9.5, 10, 11, 12, 13,
1203              19, 21, 1) == 680);
1204     }
1205
1206     {
1207
1208       cl_arg_types[0] = &ffi_type_float;
1209       cl_arg_types[1] = &ffi_type_float;
1210       cl_arg_types[2] = &ffi_type_float;
1211       cl_arg_types[3] = &ffi_type_float;
1212       cl_arg_types[4] = &ffi_type_sshort;
1213       cl_arg_types[5] = &ffi_type_float;
1214       cl_arg_types[6] = &ffi_type_float;
1215       cl_arg_types[7] = &ffi_type_uint;
1216       cl_arg_types[8] = &ffi_type_double;
1217       cl_arg_types[9] = &ffi_type_uint;
1218       cl_arg_types[10] = &ffi_type_uint;
1219       cl_arg_types[11] = &ffi_type_float;
1220       cl_arg_types[12] = &ffi_type_uint;
1221       cl_arg_types[13] = &ffi_type_uint;
1222       cl_arg_types[14] = &ffi_type_uint;
1223       cl_arg_types[15] = &ffi_type_uint;
1224       cl_arg_types[16] = NULL;
1225
1226       /* Initialize the cif */
1227       CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 16,
1228                          &ffi_type_sint, cl_arg_types) == FFI_OK);
1229
1230       CHECK(ffi_prep_closure(pcl, &cif, closure_test_fn1,
1231                              (void *) 3 /* userdata */)  == FFI_OK);
1232
1233       CHECK((*((closure_test_type1)pcl))
1234             (1.1, 2.2, 3.3, 4.4, 127, 5.5, 6.6, 8, 9, 10, 11, 12.0, 13,
1235              19, 21, 1) == 255);
1236     }
1237
1238     {
1239
1240       cl_arg_types[0] = &ffi_type_double;
1241       cl_arg_types[1] = &ffi_type_double;
1242       cl_arg_types[2] = &ffi_type_double;
1243       cl_arg_types[3] = &ffi_type_double;
1244       cl_arg_types[4] = &ffi_type_sshort;
1245       cl_arg_types[5] = &ffi_type_double;
1246       cl_arg_types[6] = &ffi_type_double;
1247       cl_arg_types[7] = &ffi_type_uint;
1248       cl_arg_types[8] = &ffi_type_double;
1249       cl_arg_types[9] = &ffi_type_uint;
1250       cl_arg_types[10] = &ffi_type_uint;
1251       cl_arg_types[11] = &ffi_type_float;
1252       cl_arg_types[12] = &ffi_type_uint;
1253       cl_arg_types[13] = &ffi_type_float;
1254       cl_arg_types[14] = &ffi_type_uint;
1255       cl_arg_types[15] = &ffi_type_uint;
1256       cl_arg_types[16] = NULL;
1257
1258       /* Initialize the cif */
1259       CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 16,
1260                          &ffi_type_sint, cl_arg_types) == FFI_OK);
1261
1262       CHECK(ffi_prep_closure(pcl, &cif, closure_test_fn2,
1263                              (void *) 3 /* userdata */) == FFI_OK);
1264
1265       CHECK((*((closure_test_type2)pcl))
1266             (1, 2, 3, 4, 127, 5, 6, 8, 9, 10, 11, 12.0, 13,
1267              19.0, 21, 1) == 255);
1268
1269     }
1270
1271     {
1272
1273       cl_arg_types[0] = &ffi_type_float;
1274       cl_arg_types[1] = &ffi_type_float;
1275       cl_arg_types[2] = &ffi_type_float;
1276       cl_arg_types[3] = &ffi_type_float;
1277       cl_arg_types[4] = &ffi_type_float;
1278       cl_arg_types[5] = &ffi_type_float;
1279       cl_arg_types[6] = &ffi_type_float;
1280       cl_arg_types[7] = &ffi_type_float;
1281       cl_arg_types[8] = &ffi_type_double;
1282       cl_arg_types[9] = &ffi_type_uint;
1283       cl_arg_types[10] = &ffi_type_float;
1284       cl_arg_types[11] = &ffi_type_float;
1285       cl_arg_types[12] = &ffi_type_uint;
1286       cl_arg_types[13] = &ffi_type_float;
1287       cl_arg_types[14] = &ffi_type_float;
1288       cl_arg_types[15] = &ffi_type_uint;
1289       cl_arg_types[16] = NULL;
1290
1291       /* Initialize the cif */
1292       CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 16,
1293                          &ffi_type_sint, cl_arg_types) == FFI_OK);
1294
1295       CHECK(ffi_prep_closure(pcl, &cif, closure_test_fn3,
1296                              (void *) 3 /* userdata */)  == FFI_OK);
1297
1298       CHECK((*((closure_test_type3)pcl))
1299             (1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9, 10, 11.11, 12.0, 13,
1300              19.19, 21.21, 1) == 135);
1301     }
1302
1303     (void) puts("\nFinished FFI_CLOSURES\n");
1304
1305 # endif
1306
1307   /* If we arrived here, all is good */
1308   (void) puts("\nLooks good. No surprises.\n");
1309
1310   /*@-compdestroy@*/
1311
1312   return 0;
1313 }
1314