vm/ffi_test.c

   1 #include "ffi_test.h"
   2
   3 #include <assert.h>
   4 #include <stdarg.h>
   5 #include <string.h>
   6
   7 void ffi_test_0(void) {}
   8
   9 int ffi_test_1(void) { return 3; }
  10
  11 int ffi_test_2(int x, int y) { return x + y; }
  12
  13 int ffi_test_3(int x, int y, int z, int t) { return x + y + z * t; }
  14
  15 float ffi_test_4(void) { return 1.5; }
  16
  17 double ffi_test_5(void) { return 1.5; }
  18
  19 double ffi_test_6(float x, float y) { return x * y; }
  20
  21 double ffi_test_7(double x, double y) { return x * y; }
  22
  23 double ffi_test_8(double x, float y, double z, float t, int w) {
  24   return x * y + z * t + w;
  25 }
  26
  27 int ffi_test_9(int a, int b, int c, int d, int e, int f, int g) {
  28   return a + b + c + d + e + f + g;
  29 }
  30
  31 int ffi_test_10(int a, int b, double c, int d, float e, int f, int g, int h) {
  32   return (int)(a - b - c - d - e - f - g - h);
  33 }
  34
  35 int ffi_test_11(int a, struct foo b, int c) { return a * b.x + c * b.y; }
  36
  37 int ffi_test_12(int a, int b, struct rect c, int d, int e, int f) {
  38   return (int)(a + b + c.x + c.y + c.w + c.h + d + e + f);
  39 }
  40
  41 int ffi_test_13(int a, int b, int c, int d, int e, int f, int g, int h, int i,
  42                 int j, int k) {
  43   return a + b + c + d + e + f + g + h + i + j + k;
  44 }
  45
  46 struct foo ffi_test_14(int x, int y) {
  47   struct foo r;
  48   r.x = x;
  49   r.y = y;
  50   return r;
  51 }
  52
  53 char* ffi_test_15(char* x, char* y) {
  54   if (strcmp(x, y))
  55     return "foo";
  56   else
  57     return "bar";
  58 }
  59
  60 struct bar ffi_test_16(long x, long y, long z) {
  61   struct bar r;
  62   r.x = x;
  63   r.y = y;
  64   r.z = z;
  65   return r;
  66 }
  67
  68 struct tiny ffi_test_17(int x) {
  69   struct tiny r;
  70   r.x = x;
  71   return r;
  72 }
  73
  74 FACTOR_STDCALL(int) ffi_test_18(int x, int y, int z, int t) {
  75   return x + y + z * t;
  76 }
  77
  78 FACTOR_STDCALL(struct bar) ffi_test_19(long x, long y, long z) {
  79   struct bar r;
  80   r.x = x;
  81   r.y = y;
  82   r.z = z;
  83   return r;
  84 }
  85
  86 void ffi_test_20(double x1, double x2, double x3, double y1, double y2,
  87                  double y3, double z1, double z2, double z3) {}
  88
  89 long long ffi_test_21(long x, long y) { return (long long) x * (long long) y; }
  90
  91 long ffi_test_22(long x, long long y, long long z) { return (long)(x + y / z); }
  92
  93 float ffi_test_23(float x[3], float y[3]) {
  94   return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
  95 }
  96
  97 struct test_struct_1 ffi_test_24(void) {
  98   struct test_struct_1 s;
  99   s.x = 1;
 100   return s;
 101 }
 102
 103 struct test_struct_2 ffi_test_25(void) {
 104   struct test_struct_2 s;
 105   s.x = 1;
 106   s.y = 2;
 107   return s;
 108 }
 109
 110 struct test_struct_3 ffi_test_26(void) {
 111   struct test_struct_3 s;
 112   s.x = 1;
 113   s.y = 2;
 114   s.z = 3;
 115   return s;
 116 }
 117
 118 struct test_struct_4 ffi_test_27(void) {
 119   struct test_struct_4 s;
 120   s.x = 1;
 121   s.y = 2;
 122   s.z = 3;
 123   s.a = 4;
 124   return s;
 125 }
 126
 127 struct test_struct_5 ffi_test_28(void) {
 128   struct test_struct_5 s;
 129   s.x = 1;
 130   s.y = 2;
 131   s.z = 3;
 132   s.a = 4;
 133   s.b = 5;
 134   return s;
 135 }
 136
 137 struct test_struct_6 ffi_test_29(void) {
 138   struct test_struct_6 s;
 139   s.x = 1;
 140   s.y = 2;
 141   s.z = 3;
 142   s.a = 4;
 143   s.b = 5;
 144   s.c = 6;
 145   return s;
 146 }
 147
 148 struct test_struct_7 ffi_test_30(void) {
 149   struct test_struct_7 s;
 150   s.x = 1;
 151   s.y = 2;
 152   s.z = 3;
 153   s.a = 4;
 154   s.b = 5;
 155   s.c = 6;
 156   s.d = 7;
 157   return s;
 158 }
 159
 160 int ffi_test_31(int x0, int x1, int x2, int x3, int x4, int x5, int x6, int x7,
 161                 int x8, int x9, int x10, int x11, int x12, int x13, int x14,
 162                 int x15, int x16, int x17, int x18, int x19, int x20, int x21,
 163                 int x22, int x23, int x24, int x25, int x26, int x27, int x28,
 164                 int x29, int x30, int x31, int x32, int x33, int x34, int x35,
 165                 int x36, int x37, int x38, int x39, int x40, int x41) {
 166   return x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 +
 167          x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 + x23 + x24 +
 168          x25 + x26 + x27 + x28 + x29 + x30 + x31 + x32 + x33 + x34 + x35 + x36 +
 169          x37 + x38 + x39 + x40 + x41;
 170 }
 171
 172 float ffi_test_31_point_5(float x0, float x1, float x2, float x3, float x4,
 173                           float x5, float x6, float x7, float x8, float x9,
 174                           float x10, float x11, float x12, float x13, float x14,
 175                           float x15, float x16, float x17, float x18, float x19,
 176                           float x20, float x21, float x22, float x23, float x24,
 177                           float x25, float x26, float x27, float x28, float x29,
 178                           float x30, float x31, float x32, float x33, float x34,
 179                           float x35, float x36, float x37, float x38, float x39,
 180                           float x40, float x41) {
 181   return x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 +
 182          x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 + x23 + x24 +
 183          x25 + x26 + x27 + x28 + x29 + x30 + x31 + x32 + x33 + x34 + x35 + x36 +
 184          x37 + x38 + x39 + x40 + x41;
 185 }
 186
 187 double ffi_test_32(struct test_struct_8 x, int y) { return (x.x + x.y) * y; }
 188
 189 double ffi_test_33(struct test_struct_9 x, int y) { return (x.x + x.y) * y; }
 190
 191 double ffi_test_34(struct test_struct_10 x, int y) { return (x.x + x.y) * y; }
 192
 193 double ffi_test_35(struct test_struct_11 x, int y) { return (x.x + x.y) * y; }
 194
 195 double ffi_test_36(struct test_struct_12 x) { return x.x; }
 196
 197 static int global_var;
 198
 199 void ffi_test_36_point_5(void) { global_var = 0; }
 200
 201 int ffi_test_37(int (*f)(int, int, int)) {
 202   global_var = f(global_var, global_var * 2, global_var * 3);
 203   return global_var;
 204 }
 205
 206 unsigned long long ffi_test_38(unsigned long long x, unsigned long long y) {
 207   return x * y;
 208 }
 209
 210 int ffi_test_39(long a, long b, struct test_struct_13 s) {
 211   assert(a == b);
 212   return (int)(s.x1 + s.x2 + s.x3 + s.x4 + s.x5 + s.x6);
 213 }
 214
 215 struct test_struct_14 ffi_test_40(double x1, double x2) {
 216   struct test_struct_14 retval;
 217   retval.x1 = x1;
 218   retval.x2 = x2;
 219   return retval;
 220 }
 221
 222 struct test_struct_12 ffi_test_41(int a, double x) {
 223   struct test_struct_12 retval;
 224   retval.a = a;
 225   retval.x = x;
 226   return retval;
 227 }
 228
 229 struct test_struct_15 ffi_test_42(float x, float y) {
 230   struct test_struct_15 retval;
 231   retval.x = x;
 232   retval.y = y;
 233   return retval;
 234 }
 235
 236 struct test_struct_16 ffi_test_43(float x, int a) {
 237   struct test_struct_16 retval;
 238   retval.x = x;
 239   retval.a = a;
 240   return retval;
 241 }
 242
 243 struct test_struct_14 ffi_test_44(void) {
 244   struct test_struct_14 retval;
 245   retval.x1 = 1.0;
 246   retval.x2 = 2.0;
 247   return retval;
 248 }
 249
 250 /* C99 features */
 251 #ifndef _MSC_VER
 252
 253 _Complex float ffi_test_45(int x) { return x; }
 254
 255 _Complex double ffi_test_46(int x) { return x; }
 256
 257 _Complex float ffi_test_47(_Complex float x, _Complex double y) {
 258   return x + 2 * y;
 259 }
 260
 261 short ffi_test_48(struct bool_field_test x) { return x.parents; }
 262
 263 #endif
 264
 265 FACTOR_FASTCALL(int) ffi_test_49(int x) { return x + 1; }
 266
 267 FACTOR_FASTCALL(int) ffi_test_50(int x, int y) { return x + y + 1; }
 268
 269 FACTOR_FASTCALL(int) ffi_test_51(int x, int y, int z) { return x + y + z + 1; }
 270
 271 FACTOR_FASTCALL(int) ffi_test_52(int x, float y, int z) {
 272   return (int)(x + y + z + 1);
 273 }
 274
 275 FACTOR_FASTCALL(int) ffi_test_53(int x, float y, int z, int w) {
 276   return (int)(x + y + z + w + 1);
 277 }
 278
 279 FACTOR_FASTCALL(int) ffi_test_54(struct test_struct_11 x, int y) {
 280   return x.x + x.y + y + 1;
 281 }
 282
 283 FACTOR_FASTCALL(int) ffi_test_55(struct test_struct_11 x, int y, int z) {
 284   return x.x + x.y + y + z + 1;
 285 }
 286
 287 FACTOR_FASTCALL(int) ffi_test_56(struct test_struct_11 x, int y, int z, int w) {
 288   return x.x + x.y + y + z + w + 1;
 289 }
 290
 291 FACTOR_FASTCALL(struct test_struct_11) ffi_test_57(int x, int y) {
 292   struct test_struct_11 r = { x + y, x - y };
 293   return r;
 294 }
 295
 296 FACTOR_FASTCALL(struct test_struct_11) ffi_test_58(int x, int y, int z) {
 297   struct test_struct_11 r = { x + y, y - z };
 298   return r;
 299 }
 300
 301 signed long long ffi_test_59(signed long long x) {
 302   return x;
 303 }
 304
 305 unsigned long long ffi_test_60(unsigned long long x) {
 306   return x;
 307 }
 308
 309 /* C99 features */
 310 #ifndef _MSC_VER
 311
 312 struct bool_and_ptr ffi_test_61() {
 313   struct bool_and_ptr bap;
 314   bap.b = true;
 315   bap.ptr = NULL;
 316   return bap;
 317 }
 318
 319 #endif
 320
 321 struct uint_pair ffi_test_62() {
 322   struct uint_pair uip;
 323   uip.a = 0xabcdefab;
 324   uip.b = 0x12345678;
 325   return uip;
 326 }
 327
 328 struct ulonglong_pair ffi_test_63() {
 329   struct ulonglong_pair ullp;
 330   ullp.a = 0xabcdefabcdefabcd;
 331   ullp.b = 0x1234567891234567;
 332   return ullp;
 333 }
 334
 335 int ffi_test_64(int n, ...) {
 336     va_list ap;
 337     va_start(ap, n);
 338     int sum = 0;
 339     for (int i = 0; i < n; i++) {
 340         sum += va_arg(ap, int);
 341     }
 342     va_end(ap);
 343     return sum;
 344 }
 345
 346 double ffi_test_65(int n, ...) {
 347     va_list ap;
 348     va_start(ap, n);
 349     double sum = 0.0;
 350     for (int i = 0; i < n; i++) {
 351         sum += va_arg(ap, double);
 352     }
 353     va_end(ap);
 354     return sum;
 355 }
 356
 357
 358 void* bug1021_test_1(void* x, int y) {
 359   return (void*)(y * y + (size_t)x);
 360 }
 361
 362 int bug1021_test_2(int x, char *y, void *z) {
 363   return y[0];
 364 }
 365
 366 void* bug1021_test_3(int x) {
 367   return (void*)(size_t)((long)x);
 368 }