mono/tests/libtest.c

   1 #include <config.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <glib.h>
   6 #include <gmodule.h>
   7 #include <errno.h>
   8 #include <time.h>
   9 #include <math.h>
  10 #include <setjmp.h>
  11 #include "../utils/mono-errno.h"
  12 #include "../utils/mono-compiler.h"
  13
  14 #ifndef HOST_WIN32
  15 #include <dlfcn.h>
  16 #endif
  17
  18 #ifdef WIN32
  19 #include <windows.h>
  20 #include "initguid.h"
  21 #else
  22 #include <pthread.h>
  23 #endif
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 #ifdef WIN32
  30 #define STDCALL __stdcall
  31 #else
  32 #define STDCALL
  33 #define __thiscall /* nothing */
  34 #endif
  35
  36 #ifdef __GNUC__
  37 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
  38 #endif
  39
  40 #ifdef WIN32
  41 extern __declspec(dllimport) void __stdcall CoTaskMemFree(void *ptr);
  42 #endif
  43
  44 typedef int (STDCALL *SimpleDelegate) (int a);
  45
  46 #if defined(WIN32) && defined (_MSC_VER)
  47 #define LIBTEST_API __declspec(dllexport)
  48 #elif defined(__GNUC__)
  49 #define LIBTEST_API  __attribute__ ((__visibility__ ("default")))
  50 #else
  51 #define LIBTEST_API
  52 #endif
  53
  54 static void marshal_free (void *ptr)
  55 {
  56 #ifdef WIN32
  57         CoTaskMemFree (ptr);
  58 #else
  59         g_free (ptr);
  60 #endif
  61 }
  62
  63 static void* marshal_alloc (gsize size)
  64 {
  65 #ifdef WIN32
  66         return CoTaskMemAlloc (size);
  67 #else
  68         return g_malloc (size);
  69 #endif
  70 }
  71
  72 static void* marshal_alloc0 (gsize size)
  73 {
  74 #ifdef WIN32
  75         void* ptr = CoTaskMemAlloc (size);
  76         memset(ptr, 0, size);
  77         return ptr;
  78 #else
  79         return g_malloc0 (size);
  80 #endif
  81 }
  82
  83 static char* marshal_strdup (const char *str)
  84 {
  85 #ifdef WIN32
  86         if (!str)
  87                 return NULL;
  88
  89         char *buf = (char *) CoTaskMemAlloc (strlen (str) + 1);
  90         return strcpy (buf, str);
  91 #else
  92         return g_strdup (str);
  93 #endif
  94 }
  95
  96 static gunichar2* marshal_bstr_alloc(const gchar* str)
  97 {
  98 #ifdef WIN32
  99         gunichar2* temp = g_utf8_to_utf16 (str, -1, NULL, NULL, NULL);
 100         gunichar2* ret = SysAllocString (temp);
 101         g_free (temp);
 102         return ret;
 103 #else
 104         gchar* ret = NULL;
 105         int slen = strlen (str);
 106         gunichar2* temp;
 107         /* allocate len + 1 utf16 characters plus 4 byte integer for length*/
 108         ret = (gchar *)g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
 109         if (ret == NULL)
 110                 return NULL;
 111         temp = g_utf8_to_utf16 (str, -1, NULL, NULL, NULL);
 112         memcpy (ret + sizeof(guint32), temp, slen * sizeof(gunichar2));
 113         * ((guint32 *) ret) = slen * sizeof(gunichar2);
 114         ret [4 + slen * sizeof(gunichar2)] = 0;
 115         ret [5 + slen * sizeof(gunichar2)] = 0;
 116
 117         return (gunichar2*)(ret + 4);
 118 #endif
 119 }
 120
 121 #define marshal_new0(type,size)       ((type *) marshal_alloc0 (sizeof (type)* (size)))
 122
 123 LIBTEST_API int STDCALL
 124 mono_cominterop_is_supported (void)
 125 {
 126 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 127         return 1;
 128 #endif
 129         return 0;
 130 }
 131
 132 LIBTEST_API unsigned short* STDCALL
 133 test_lpwstr_marshal (unsigned short* chars, int length)
 134 {
 135         int i = 0;
 136         unsigned short *res;
 137
 138         res = (unsigned short *)marshal_alloc (2 * (length + 1));
 139
 140         // printf("test_lpwstr_marshal()\n");
 141
 142         while ( i < length ) {
 143                 // printf("X|%u|\n", chars[i]);
 144                 res [i] = chars[i];
 145                 i++;
 146         }
 147
 148         res [i] = 0;
 149
 150         return res;
 151 }
 152
 153
 154 LIBTEST_API void STDCALL
 155 test_lpwstr_marshal_out (unsigned short** chars)
 156 {
 157         int i = 0;
 158         const char abc[] = "ABC";
 159         glong len = strlen(abc);
 160
 161         *chars = (unsigned short *)marshal_alloc (2 * (len + 1));
 162
 163         while ( i < len ) {
 164                 (*chars) [i] = abc[i];
 165                 i++;
 166         }
 167
 168         (*chars) [i] = 0;
 169 }
 170
 171 typedef struct {
 172         int b;
 173         int a;
 174         int c;
 175 } union_test_1_type;
 176
 177 LIBTEST_API int STDCALL
 178 mono_union_test_1 (union_test_1_type u1) {
 179         // printf ("Got values %d %d %d\n", u1.b, u1.a, u1.c);
 180         return u1.a + u1.b + u1.c;
 181 }
 182
 183 LIBTEST_API int STDCALL
 184 mono_return_int (int a) {
 185         // printf ("Got value %d\n", a);
 186         return a;
 187 }
 188
 189 LIBTEST_API float STDCALL
 190 mono_test_marshal_pass_return_float (float f) {
 191         return f + 1.0;
 192 }
 193
 194 struct ss
 195 {
 196         int i;
 197 };
 198
 199 LIBTEST_API int STDCALL
 200 mono_return_int_ss (struct ss a) {
 201         // printf ("Got value %d\n", a.i);
 202         return a.i;
 203 }
 204
 205 LIBTEST_API struct ss STDCALL
 206 mono_return_ss (struct ss a) {
 207         // printf ("Got value %d\n", a.i);
 208         a.i++;
 209         return a;
 210 }
 211
 212 struct sc1
 213 {
 214         char c[1];
 215 };
 216
 217 LIBTEST_API struct sc1 STDCALL
 218 mono_return_sc1 (struct sc1 a) {
 219         // printf ("Got value %d\n", a.c[0]);
 220         a.c[0]++;
 221         return a;
 222 }
 223
 224
 225 struct sc3
 226 {
 227         char c[3];
 228 };
 229
 230 LIBTEST_API struct sc3 STDCALL
 231 mono_return_sc3 (struct sc3 a) {
 232         // printf ("Got values %d %d %d\n", a.c[0], a.c[1], a.c[2]);
 233         a.c[0]++;
 234         a.c[1] += 2;
 235         a.c[2] += 3;
 236         return a;
 237 }
 238
 239 struct sc5
 240 {
 241         char c[5];
 242 };
 243
 244 LIBTEST_API struct sc5 STDCALL
 245 mono_return_sc5 (struct sc5 a) {
 246         // printf ("Got values %d %d %d %d %d\n", a.c[0], a.c[1], a.c[2], a.c[3], a.c[4]);
 247         a.c[0]++;
 248         a.c[1] += 2;
 249         a.c[2] += 3;
 250         a.c[3] += 4;
 251         a.c[4] += 5;
 252         return a;
 253 }
 254
 255 union su
 256 {
 257         int i1;
 258         int i2;
 259 };
 260
 261 LIBTEST_API int STDCALL
 262 mono_return_int_su (union su a) {
 263         // printf ("Got value %d\n", a.i1);
 264         return a.i1;
 265 }
 266
 267 struct FI {
 268         float f1;
 269         float f2;
 270         float f3;
 271 };
 272
 273 struct NestedFloat {
 274         struct FI fi;
 275         float f4;
 276 };
 277
 278 LIBTEST_API struct NestedFloat STDCALL
 279 mono_return_nested_float (void)
 280 {
 281         struct NestedFloat f;
 282         f.fi.f1 = 1.0;
 283         f.fi.f2 = 2.0;
 284         f.fi.f3 = 3.0;
 285         f.f4 = 4.0;
 286         return f;
 287 }
 288
 289 struct Scalar4 {
 290         double val[4];
 291 };
 292
 293 struct Rect {
 294         int x;
 295         int y;
 296         int width;
 297         int height;
 298 };
 299
 300 LIBTEST_API char * STDCALL
 301 mono_return_struct_4_double (void *ptr, struct Rect rect, struct Scalar4 sc4, int a, int b, int c)
 302 {
 303         char *buffer = (char *)marshal_alloc (1024 * sizeof (char));
 304         sprintf (buffer, "sc4 = {%.1f, %.1f, %.1f, %.1f }, a=%x, b=%x, c=%x\n", (float) sc4.val [0], (float) sc4.val [1], (float) sc4.val [2], (float) sc4.val [3], a, b, c);
 305         return buffer;
 306 }
 307
 308 LIBTEST_API int STDCALL
 309 mono_test_many_int_arguments (int a, int b, int c, int d, int e,
 310                                                           int f, int g, int h, int i, int j);
 311 LIBTEST_API short STDCALL
 312 mono_test_many_short_arguments (short a, short b, short c, short d, short e,
 313                                                                 short f, short g, short h, short i, short j);
 314 LIBTEST_API char STDCALL
 315 mono_test_many_char_arguments (char a, char b, char c, char d, char e,
 316                                                            char f, char g, char h, char i, char j);
 317
 318 LIBTEST_API int STDCALL
 319 mono_test_many_int_arguments (int a, int b, int c, int d, int e, int f, int g, int h, int i, int j)
 320 {
 321         return a + b + c + d + e + f + g + h + i + j;
 322 }
 323
 324 LIBTEST_API short STDCALL
 325 mono_test_many_short_arguments (short a, short b, short c, short d, short e, short f, short g, short h, short i, short j)
 326 {
 327         return a + b + c + d + e + f + g + h + i + j;
 328 }
 329
 330 LIBTEST_API char STDCALL
 331 mono_test_many_byte_arguments (char a, char b, char c, char d, char e, char f, char g, char h, char i, char j)
 332 {
 333         return a + b + c + d + e + f + g + h + i + j;
 334 }
 335
 336 LIBTEST_API float STDCALL
 337 mono_test_many_float_arguments (float a, float b, float c, float d, float e, float f, float g, float h, float i, float j)
 338 {
 339         return a + b + c + d + e + f + g + h + i + j;
 340 }
 341
 342 LIBTEST_API double STDCALL
 343 mono_test_many_double_arguments (double a, double b, double c, double d, double e, double f, double g, double h, double i, double j)
 344 {
 345         return a + b + c + d + e + f + g + h + i + j;
 346 }
 347
 348 LIBTEST_API double STDCALL
 349 mono_test_split_double_arguments (double a, double b, float c, double d, double e)
 350 {
 351         return a + b + c + d + e;
 352 }
 353
 354 LIBTEST_API int STDCALL
 355 mono_test_puts_static (char *s)
 356 {
 357         // printf ("TEST %s\n", s);
 358         return 1;
 359 }
 360
 361 typedef int (STDCALL *SimpleDelegate3) (int a, int b);
 362
 363 LIBTEST_API int STDCALL
 364 mono_invoke_delegate (SimpleDelegate3 delegate)
 365 {
 366         int res;
 367
 368         // printf ("start invoke %p\n", delegate);
 369
 370         res = delegate (2, 3);
 371
 372         // printf ("end invoke\n");
 373
 374         return res;
 375 }
 376
 377 LIBTEST_API int STDCALL
 378 mono_invoke_simple_delegate (SimpleDelegate d)
 379 {
 380         return d (4);
 381 }
 382
 383 LIBTEST_API int STDCALL
 384 mono_test_marshal_char (short a1)
 385 {
 386         if (a1 == 'a')
 387                 return 0;
 388
 389         return 1;
 390 }
 391
 392 LIBTEST_API void STDCALL
 393 mono_test_marshal_char_array (gunichar2 *s)
 394 {
 395         const char m[] = "abcdef";
 396         gunichar2* s2;
 397         glong len;
 398
 399         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
 400
 401         len = (len * 2) + 2;
 402         memcpy (s, s2, len);
 403
 404         g_free (s2);
 405 }
 406
 407 LIBTEST_API int STDCALL
 408 mono_test_marshal_ansi_char_array (char *s)
 409 {
 410         const char m[] = "abcdef";
 411
 412         if (strncmp ("qwer", s, 4))
 413                 return 1;
 414
 415         memcpy (s, m, sizeof (m));
 416         return 0;
 417 }
 418
 419 LIBTEST_API int STDCALL
 420 mono_test_marshal_unicode_char_array (gunichar2 *s)
 421 {
 422         const char m[] = "abcdef";
 423         const char expected[] = "qwer";
 424         gunichar2 *s1, *s2;
 425         glong len1, len2;
 426
 427         s1 = g_utf8_to_utf16 (m, -1, NULL, &len1, NULL);
 428         s2 = g_utf8_to_utf16 (expected, -1, NULL, &len2, NULL);
 429         len1 = (len1 * 2);
 430         len2 = (len2 * 2);
 431
 432         if (memcmp (s, s2, len2))
 433                 return 1;
 434
 435         memcpy (s, s1, len1);
 436         return 0;
 437 }
 438
 439 LIBTEST_API int STDCALL
 440 mono_test_empty_pinvoke (int i)
 441 {
 442         return i;
 443 }
 444
 445 LIBTEST_API int STDCALL
 446 mono_test_marshal_bool_byref (int a, int *b, int c)
 447 {
 448     int res = *b;
 449
 450         *b = 1;
 451
 452         return res;
 453 }
 454
 455 LIBTEST_API int STDCALL
 456 mono_test_marshal_bool_in_as_I1_U1 (char bTrue, char bFalse)
 457 {
 458         if (!bTrue)
 459                 return 1;
 460         if (bFalse)
 461                 return 2;
 462         return 0;
 463 }
 464
 465 LIBTEST_API int STDCALL
 466 mono_test_marshal_bool_out_as_I1_U1 (char* bTrue, char* bFalse)
 467 {
 468         if (!bTrue || !bFalse)
 469                 return 3;
 470
 471         *bTrue = 1;
 472         *bFalse = 0;
 473
 474         return 0;
 475 }
 476
 477 LIBTEST_API int STDCALL
 478 mono_test_marshal_bool_ref_as_I1_U1 (char* bTrue, char* bFalse)
 479 {
 480         if (!bTrue || !bFalse)
 481                 return 4;
 482
 483         if (!(*bTrue))
 484                 return 5;
 485         if (*bFalse)
 486                 return 6;
 487
 488         *bFalse = 1;
 489         *bTrue = 0;
 490
 491         return 0;
 492 }
 493
 494 LIBTEST_API int STDCALL
 495 mono_test_marshal_array (int *a1)
 496 {
 497         int i, sum = 0;
 498
 499         for (i = 0; i < 50; i++)
 500                 sum += a1 [i];
 501
 502         return sum;
 503 }
 504
 505 LIBTEST_API int STDCALL
 506 mono_test_marshal_inout_array (int *a1)
 507 {
 508         int i, sum = 0;
 509
 510         for (i = 0; i < 50; i++) {
 511                 sum += a1 [i];
 512                 a1 [i] = 50 - a1 [i];
 513         }
 514
 515         return sum;
 516 }
 517
 518 LIBTEST_API int /* cdecl */
 519 mono_test_marshal_inout_array_cdecl (int *a1)
 520 {
 521         return mono_test_marshal_inout_array (a1);
 522 }
 523
 524 LIBTEST_API int STDCALL
 525 mono_test_marshal_out_array (int *a1)
 526 {
 527         int i;
 528
 529         for (i = 0; i < 50; i++) {
 530                 a1 [i] = i;
 531         }
 532
 533         return 0;
 534 }
 535
 536 LIBTEST_API int STDCALL
 537 mono_test_marshal_out_byref_array_out_size_param (int **out_arr, int *out_len)
 538 {
 539         int *arr;
 540         int i, len;
 541
 542         len = 4;
 543         arr = (gint32 *)marshal_alloc (sizeof (gint32) * len);
 544         for (i = 0; i < len; ++i)
 545                 arr [i] = i;
 546         *out_arr = arr;
 547         *out_len = len;
 548
 549         return 0;
 550 }
 551
 552 LIBTEST_API int STDCALL
 553 mono_test_marshal_out_lparray_out_size_param (int *arr, int *out_len)
 554 {
 555         int i, len;
 556
 557         len = 4;
 558         for (i = 0; i < len; ++i)
 559                 arr [i] = i;
 560         *out_len = len;
 561
 562         return 0;
 563 }
 564
 565 LIBTEST_API int STDCALL
 566 mono_test_marshal_inout_nonblittable_array (gunichar2 *a1)
 567 {
 568         int i, sum = 0;
 569
 570         for (i = 0; i < 10; i++) {
 571                 a1 [i] = 'F';
 572         }
 573
 574         return sum;
 575 }
 576
 577 typedef struct {
 578         int a;
 579         int b;
 580         int c;
 581         const char *d;
 582         gunichar2 *d2;
 583 } simplestruct;
 584
 585 typedef struct {
 586         double x;
 587         double y;
 588 } point;
 589
 590 LIBTEST_API simplestruct STDCALL
 591 mono_test_return_vtype (int i)
 592 {
 593         simplestruct res;
 594         static gunichar2 test2 [] = { 'T', 'E', 'S', 'T', '2', 0 };
 595
 596         res.a = 0;
 597         res.b = 1;
 598         res.c = 0;
 599         res.d = "TEST";
 600         res.d2 = test2;
 601
 602         return res;
 603 }
 604
 605 LIBTEST_API void STDCALL
 606 mono_test_delegate_struct (void)
 607 {
 608         // printf ("TEST\n");
 609 }
 610
 611 typedef char* (STDCALL *ReturnStringDelegate) (const char *s);
 612
 613 LIBTEST_API char * STDCALL
 614 mono_test_return_string (ReturnStringDelegate func)
 615 {
 616         char *res;
 617
 618         // printf ("mono_test_return_string\n");
 619
 620         res = func ("TEST");
 621         marshal_free (res);
 622
 623         // printf ("got string: %s\n", res);
 624         return marshal_strdup ("12345");
 625 }
 626
 627 typedef int (STDCALL *RefVTypeDelegate) (int a, simplestruct *ss, int b);
 628
 629 LIBTEST_API int STDCALL
 630 mono_test_ref_vtype (int a, simplestruct *ss, int b, RefVTypeDelegate func)
 631 {
 632         if (a == 1 && b == 2 && ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 633             !strcmp (ss->d, "TEST1")) {
 634                 ss->a = 1;
 635                 ss->b = 0;
 636                 ss->c = 1;
 637                 ss->d = "TEST2";
 638
 639                 return func (a, ss, b);
 640         }
 641
 642         return 1;
 643 }
 644
 645 typedef int (STDCALL *OutVTypeDelegate) (int a, simplestruct *ss, int b);
 646
 647 LIBTEST_API int STDCALL
 648 mono_test_marshal_out_struct (int a, simplestruct *ss, int b, OutVTypeDelegate func)
 649 {
 650         /* Check that the input pointer is ignored */
 651         ss->d = (const char *)0x12345678;
 652
 653         func (a, ss, b);
 654
 655         if (ss->a && ss->b && ss->c && !strcmp (ss->d, "TEST3"))
 656                 return 0;
 657         else
 658                 return 1;
 659 }
 660
 661 typedef int (STDCALL *InVTypeDelegate) (int a, simplestruct *ss, int b);
 662
 663 LIBTEST_API int STDCALL
 664 mono_test_marshal_in_struct (int a, simplestruct *ss, int b, InVTypeDelegate func)
 665 {
 666         simplestruct ss2;
 667         int res;
 668
 669         memcpy (&ss2, ss, sizeof (simplestruct));
 670
 671         res = func (a, ss, b);
 672         if (res) {
 673                 printf ("mono_test_marshal_in_struct () failed: %d\n", res);
 674                 return 1;
 675         }
 676
 677         /* Check that no modifications is made to the struct */
 678         if (ss2.a == ss->a && ss2.b == ss->b && ss2.c == ss->c && ss2.d == ss->d)
 679                 return 0;
 680         else
 681                 return 1;
 682 }
 683
 684 typedef struct {
 685         int a;
 686         SimpleDelegate func, func2, func3;
 687 } DelegateStruct;
 688
 689 LIBTEST_API DelegateStruct STDCALL
 690 mono_test_marshal_delegate_struct (DelegateStruct ds)
 691 {
 692         DelegateStruct res;
 693
 694         res.a = ds.func (ds.a) + ds.func2 (ds.a) + (ds.func3 == NULL ? 0 : 1);
 695         res.func = ds.func;
 696         res.func2 = ds.func2;
 697         res.func3 = NULL;
 698
 699         return res;
 700 }
 701
 702 LIBTEST_API int STDCALL
 703 mono_test_marshal_struct (simplestruct ss)
 704 {
 705         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 706             !strcmp (ss.d, "TEST"))
 707                 return 0;
 708
 709         return 1;
 710 }
 711
 712 LIBTEST_API int STDCALL
 713 mono_test_marshal_byref_struct (simplestruct *ss, int a, int b, int c, char *d)
 714 {
 715         gboolean res = (ss->a == a && ss->b == b && ss->c == c && strcmp (ss->d, d) == 0);
 716
 717         marshal_free ((char*)ss->d);
 718
 719         ss->a = !ss->a;
 720         ss->b = !ss->b;
 721         ss->c = !ss->c;
 722         ss->d = marshal_strdup ("DEF");
 723
 724         return res ? 0 : 1;
 725 }
 726
 727 typedef struct {
 728         int a;
 729         int b;
 730         int c;
 731         char *d;
 732         unsigned char e;
 733         double f;
 734         unsigned char g;
 735         guint64 h;
 736 } simplestruct2;
 737
 738 LIBTEST_API int STDCALL
 739 mono_test_marshal_struct2 (simplestruct2 ss)
 740 {
 741         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 742             !strcmp (ss.d, "TEST") &&
 743             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
 744                 return 0;
 745
 746         return 1;
 747 }
 748
 749 /* on HP some of the struct should be on the stack and not in registers */
 750 LIBTEST_API int STDCALL
 751 mono_test_marshal_struct2_2 (int i, int j, int k, simplestruct2 ss)
 752 {
 753         if (i != 10 || j != 11 || k != 12)
 754                 return 1;
 755         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 756             !strcmp (ss.d, "TEST") &&
 757             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
 758                 return 0;
 759
 760         return 1;
 761 }
 762
 763 LIBTEST_API int STDCALL
 764 mono_test_marshal_lpstruct (simplestruct *ss)
 765 {
 766         if (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 767             !strcmp (ss->d, "TEST"))
 768                 return 0;
 769
 770         return 1;
 771 }
 772
 773 LIBTEST_API int STDCALL
 774 mono_test_marshal_lpstruct_blittable (point *p)
 775 {
 776         if (p->x == 1.0 && p->y == 2.0)
 777                 return 0;
 778         else
 779                 return 1;
 780 }
 781
 782 LIBTEST_API int STDCALL
 783 mono_test_marshal_struct_array (simplestruct2 *ss)
 784 {
 785         if (! (ss[0].a == 0 && ss[0].b == 1 && ss[0].c == 0 &&
 786                    !strcmp (ss[0].d, "TEST") &&
 787                    ss[0].e == 99 && ss[0].f == 1.5 && ss[0].g == 42 && ss[0].h == (guint64)123))
 788                 return 1;
 789
 790         if (! (ss[1].a == 0 && ss[1].b == 0 && ss[1].c == 0 &&
 791                    !strcmp (ss[1].d, "TEST2") &&
 792                    ss[1].e == 100 && ss[1].f == 2.5 && ss[1].g == 43 && ss[1].h == (guint64)124))
 793                 return 1;
 794
 795         return 0;
 796 }
 797
 798 typedef struct long_align_struct {
 799         gint32 a;
 800         gint64 b;
 801         gint64 c;
 802 } long_align_struct;
 803
 804 LIBTEST_API int STDCALL
 805 mono_test_marshal_long_align_struct_array (long_align_struct *ss)
 806 {
 807         return ss[0].a + ss[0].b + ss[0].c + ss[1].a + ss[1].b + ss[1].c;
 808 }
 809
 810 LIBTEST_API simplestruct2 * STDCALL
 811 mono_test_marshal_class (int i, int j, int k, simplestruct2 *ss, int l)
 812 {
 813         simplestruct2 *res;
 814
 815         if (!ss)
 816                 return NULL;
 817
 818         if (i != 10 || j != 11 || k != 12 || l != 14)
 819                 return NULL;
 820         if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 821                    !strcmp (ss->d, "TEST") &&
 822                    ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
 823                 return NULL;
 824
 825         res = marshal_new0 (simplestruct2, 1);
 826         memcpy (res, ss, sizeof (simplestruct2));
 827         res->d = marshal_strdup ("TEST");
 828         return res;
 829 }
 830
 831 LIBTEST_API int STDCALL
 832 mono_test_marshal_byref_class (simplestruct2 **ssp)
 833 {
 834         simplestruct2 *ss = *ssp;
 835         simplestruct2 *res;
 836
 837         if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 838                    !strcmp (ss->d, "TEST") &&
 839                    ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
 840                 return 1;
 841
 842         res = marshal_new0 (simplestruct2, 1);
 843         memcpy (res, ss, sizeof (simplestruct2));
 844         res->d = marshal_strdup ("TEST-RES");
 845
 846         *ssp = res;
 847         return 0;
 848 }
 849
 850 static void *
 851 get_sp (void)
 852 {
 853         int i;
 854         void *p;
 855
 856         /* Yes, this is correct, we are only trying to determine the value of the stack here */
 857         p = &i;
 858         return p;
 859 }
 860
 861 LIBTEST_API int STDCALL
 862 reliable_delegate (int a)
 863 {
 864         return a;
 865 }
 866
 867 /*
 868  * Checks whether get_sp() works as expected. It doesn't work with gcc-2.95.3 on linux.
 869  */
 870 static gboolean
 871 is_get_sp_reliable (void)
 872 {
 873         void *sp1, *sp2;
 874
 875         reliable_delegate(1);
 876         sp1 = get_sp();
 877         reliable_delegate(1);
 878         sp2 = get_sp();
 879         return sp1 == sp2;
 880 }
 881
 882 LIBTEST_API int STDCALL
 883 mono_test_marshal_delegate (SimpleDelegate delegate)
 884 {
 885         void *sp1, *sp2;
 886
 887         /* Check that the delegate wrapper is stdcall */
 888         delegate (2);
 889         sp1 = get_sp ();
 890         delegate (2);
 891         sp2 = get_sp ();
 892         if (is_get_sp_reliable())
 893                 g_assert (sp1 == sp2);
 894
 895         return delegate (2);
 896 }
 897
 898 static int STDCALL inc_cb (int i)
 899 {
 900         return i + 1;
 901 }
 902
 903 LIBTEST_API int STDCALL
 904 mono_test_marshal_out_delegate (SimpleDelegate *delegate)
 905 {
 906         *delegate = inc_cb;
 907
 908         return 0;
 909 }
 910
 911 LIBTEST_API SimpleDelegate STDCALL
 912 mono_test_marshal_return_delegate (SimpleDelegate delegate)
 913 {
 914         return delegate;
 915 }
 916
 917 typedef int (STDCALL *DelegateByrefDelegate) (void *);
 918
 919 LIBTEST_API int STDCALL
 920 mono_test_marshal_delegate_ref_delegate (DelegateByrefDelegate del)
 921 {
 922         int (STDCALL *ptr) (int i);
 923
 924         del (&ptr);
 925
 926         return ptr (54);
 927 }
 928
 929 static int STDCALL
 930 return_plus_one (int i)
 931 {
 932         return i + 1;
 933 }
 934
 935 LIBTEST_API SimpleDelegate STDCALL
 936 mono_test_marshal_return_delegate_2 (void)
 937 {
 938         return return_plus_one;
 939 }
 940
 941 typedef simplestruct (STDCALL *SimpleDelegate2) (simplestruct ss);
 942
 943 static gboolean
 944 is_utf16_equals (gunichar2 *s1, const char *s2)
 945 {
 946         char *s;
 947         int res;
 948
 949         s = g_utf16_to_utf8 (s1, -1, NULL, NULL, NULL);
 950         res = strcmp (s, s2);
 951         g_free (s);
 952
 953         return res == 0;
 954 }
 955
 956 LIBTEST_API int STDCALL
 957 mono_test_marshal_delegate2 (SimpleDelegate2 delegate)
 958 {
 959         simplestruct ss, res;
 960
 961         ss.a = 0;
 962         ss.b = 1;
 963         ss.c = 0;
 964         ss.d = "TEST";
 965         ss.d2 = g_utf8_to_utf16 ("TEST2", -1, NULL, NULL, NULL);
 966
 967         res = delegate (ss);
 968         if (! (res.a && !res.b && res.c && !strcmp (res.d, "TEST-RES") && is_utf16_equals (res.d2, "TEST2-RES")))
 969                 return 1;
 970
 971         return 0;
 972 }
 973
 974 typedef simplestruct* (STDCALL *SimpleDelegate4) (simplestruct *ss);
 975
 976 LIBTEST_API int STDCALL
 977 mono_test_marshal_delegate4 (SimpleDelegate4 delegate)
 978 {
 979         simplestruct ss;
 980         simplestruct *res;
 981
 982         ss.a = 0;
 983         ss.b = 1;
 984         ss.c = 0;
 985         ss.d = "TEST";
 986
 987         /* Check argument */
 988         res = delegate (&ss);
 989         if (!res)
 990                 return 1;
 991
 992         /* Check return value */
 993         if (! (!res->a && res->b && !res->c && !strcmp (res->d, "TEST")))
 994                 return 2;
 995
 996         /* Check NULL argument and NULL result */
 997         res = delegate (NULL);
 998         if (res)
 999                 return 3;
1000
1001         return 0;
1002 }
1003
1004 typedef int (STDCALL *SimpleDelegate5) (simplestruct **ss);
1005
1006 LIBTEST_API int STDCALL
1007 mono_test_marshal_delegate5 (SimpleDelegate5 delegate)
1008 {
1009         simplestruct ss;
1010         int res;
1011         simplestruct *ptr;
1012
1013         ss.a = 0;
1014         ss.b = 1;
1015         ss.c = 0;
1016         ss.d = "TEST";
1017
1018         ptr = &ss;
1019
1020         res = delegate (&ptr);
1021         if (res != 0)
1022                 return 1;
1023
1024         if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
1025                 return 2;
1026
1027         return 0;
1028 }
1029
1030 LIBTEST_API int STDCALL
1031 mono_test_marshal_delegate6 (SimpleDelegate5 delegate)
1032 {
1033         delegate (NULL);
1034         return 0;
1035 }
1036
1037 typedef int (STDCALL *SimpleDelegate7) (simplestruct **ss);
1038
1039 LIBTEST_API int STDCALL
1040 mono_test_marshal_delegate7 (SimpleDelegate7 delegate)
1041 {
1042         int res;
1043         simplestruct *ptr;
1044
1045         /* Check that the input pointer is ignored */
1046         ptr = (simplestruct *)0x12345678;
1047
1048         res = delegate (&ptr);
1049         if (res != 0)
1050                 return 1;
1051
1052         if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
1053                 return 2;
1054
1055         return 0;
1056 }
1057
1058 typedef int (STDCALL *InOutByvalClassDelegate) (simplestruct *ss);
1059
1060 LIBTEST_API int STDCALL
1061 mono_test_marshal_inout_byval_class_delegate (InOutByvalClassDelegate delegate)
1062 {
1063         int res;
1064         simplestruct ss;
1065
1066         ss.a = FALSE;
1067         ss.b = TRUE;
1068         ss.c = FALSE;
1069         ss.d = g_strdup_printf ("%s", "FOO");
1070
1071         res = delegate (&ss);
1072         if (res != 0)
1073                 return 1;
1074
1075         if (!(ss.a && !ss.b && ss.c && !strcmp (ss.d, "RES")))
1076                 return 2;
1077
1078         return 0;
1079 }
1080
1081 typedef int (STDCALL *SimpleDelegate8) (gunichar2 *s);
1082
1083 LIBTEST_API int STDCALL
1084 mono_test_marshal_delegate8 (SimpleDelegate8 delegate, gunichar2 *s)
1085 {
1086         return delegate (s);
1087 }
1088
1089 typedef int (STDCALL *return_int_fnt) (int i);
1090 typedef int (STDCALL *SimpleDelegate9) (return_int_fnt d);
1091
1092 LIBTEST_API int STDCALL
1093 mono_test_marshal_delegate9 (SimpleDelegate9 delegate, gpointer ftn)
1094 {
1095         return delegate ((return_int_fnt)ftn);
1096 }
1097
1098 static int STDCALL
1099 return_self (int i)
1100 {
1101         return i;
1102 }
1103
1104 LIBTEST_API int STDCALL
1105 mono_test_marshal_delegate10 (SimpleDelegate9 delegate)
1106 {
1107         return delegate (return_self);
1108 }
1109
1110 typedef int (STDCALL *PrimitiveByrefDelegate) (int *i);
1111
1112 LIBTEST_API int STDCALL
1113 mono_test_marshal_primitive_byref_delegate (PrimitiveByrefDelegate delegate)
1114 {
1115         int i = 1;
1116
1117         int res = delegate (&i);
1118         if (res != 0)
1119                 return res;
1120
1121         if (i != 2)
1122                 return 2;
1123
1124         return 0;
1125 }
1126
1127 typedef int (STDCALL *return_int_delegate) (int i);
1128
1129 typedef return_int_delegate (STDCALL *ReturnDelegateDelegate) (void);
1130
1131 LIBTEST_API int STDCALL
1132 mono_test_marshal_return_delegate_delegate (ReturnDelegateDelegate d)
1133 {
1134         return (d ()) (55);
1135 }
1136
1137 typedef int (STDCALL *VirtualDelegate) (int);
1138
1139 LIBTEST_API int STDCALL
1140 mono_test_marshal_virtual_delegate (VirtualDelegate del)
1141 {
1142         return del (42);
1143 }
1144
1145 typedef char* (STDCALL *IcallDelegate) (const char *);
1146 LIBTEST_API int STDCALL
1147 mono_test_marshal_icall_delegate (IcallDelegate del)
1148 {
1149         char *res = del ("ABC");
1150         return strcmp (res, "ABC") == 0 ? 0 : 1;
1151 }
1152
1153 LIBTEST_API int STDCALL
1154 mono_test_marshal_stringbuilder (char *s, int n)
1155 {
1156         const char m[] = "This is my message.  Isn't it nice?";
1157
1158         if (strcmp (s, "ABCD") != 0)
1159                 return 1;
1160         memcpy(s, m, n);
1161         s [n] = '\0';
1162         return 0;
1163 }
1164
1165 LIBTEST_API int STDCALL
1166 mono_test_marshal_stringbuilder_append (char *s, int length)
1167 {
1168         const char out_sentinel[] = "CSHARP_";
1169         const char out_len = strlen (out_sentinel);
1170
1171         for (int i=0; i < length; i++) {
1172                 s [i] = out_sentinel [i % out_len];
1173         }
1174
1175         s [length] = '\0';
1176
1177
1178         return 0;
1179 }
1180
1181 LIBTEST_API int STDCALL
1182 mono_test_marshal_stringbuilder_default (char *s, int n)
1183 {
1184         const char m[] = "This is my message.  Isn't it nice?";
1185
1186         memcpy(s, m, n);
1187         s [n] = '\0';
1188         return 0;
1189 }
1190
1191 LIBTEST_API int STDCALL
1192 mono_test_marshal_stringbuilder_unicode (gunichar2 *s, int n)
1193 {
1194         const char m[] = "This is my message.  Isn't it nice?";
1195         gunichar2* s2;
1196         glong len;
1197
1198         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
1199
1200         len = (len * 2) + 2;
1201         if (len > (n * 2))
1202                 len = n * 2;
1203         memcpy (s, s2, len);
1204
1205         g_free (s2);
1206
1207         return 0;
1208 }
1209
1210 LIBTEST_API void STDCALL
1211 mono_test_marshal_stringbuilder_out (char **s)
1212 {
1213         const char m[] = "This is my message.  Isn't it nice?";
1214         char *str;
1215
1216         str = (char *)marshal_alloc (strlen (m) + 1);
1217         memcpy (str, m, strlen (m) + 1);
1218
1219         *s = str;
1220 }
1221
1222 LIBTEST_API int STDCALL
1223 mono_test_marshal_stringbuilder_out_unicode (gunichar2 **s)
1224 {
1225         const char m[] = "This is my message.  Isn't it nice?";
1226         gunichar2 *s2;
1227         glong len;
1228
1229         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
1230
1231         len = (len * 2) + 2;
1232         *s = (gunichar2 *)marshal_alloc (len);
1233         memcpy (*s, s2, len);
1234
1235         g_free (s2);
1236
1237         return 0;
1238 }
1239
1240 LIBTEST_API int STDCALL
1241 mono_test_marshal_stringbuilder_ref (char **s)
1242 {
1243         const char m[] = "This is my message.  Isn't it nice?";
1244         char *str;
1245
1246         if (strcmp (*s, "ABC"))
1247                 return 1;
1248
1249         str = (char *)marshal_alloc (strlen (m) + 1);
1250         memcpy (str, m, strlen (m) + 1);
1251
1252         *s = str;
1253         return 0;
1254 }
1255
1256 LIBTEST_API void STDCALL
1257 mono_test_marshal_stringbuilder_utf16_tolower (short *s, int n)
1258 {
1259         for (int i = 0; i < n; i++)
1260                 s[i] = tolower(s[i]);
1261 }
1262
1263
1264 #ifdef __GNUC__
1265 #pragma GCC diagnostic push
1266 #pragma GCC diagnostic ignored "-Wc++-compat"
1267 #endif
1268
1269 /*
1270 * Standard C and C++ doesn't allow empty structs, empty structs will always have a size of 1 byte.
1271 * GCC have an extension to allow empty structs, https://gcc.gnu.org/onlinedocs/gcc/Empty-Structures.html.
1272 * This cause a little dilemma since runtime build using none GCC compiler will not be compatible with
1273 * GCC build C libraries and the other way around. On platforms where empty structs has size of 1 byte
1274 * it must be represented in call and cannot be dropped. On Windows x64 structs will always be represented in the call
1275 * meaning that an empty struct must have a representation in the callee in order to correctly follow the ABI used by the
1276 * C/C++ standard and the runtime.
1277 */
1278 typedef struct {
1279 #if !defined(__GNUC__) || defined(TARGET_WIN32)
1280     char a;
1281 #endif
1282 } EmptyStruct;
1283
1284 #ifdef __GNUC__
1285 #pragma GCC diagnostic pop
1286 #endif
1287
1288 LIBTEST_API int STDCALL
1289 mono_test_marshal_empty_string_array (char **array)
1290 {
1291         return (array == NULL) ? 0 : 1;
1292 }
1293
1294 LIBTEST_API int STDCALL
1295 mono_test_marshal_string_array (char **array)
1296 {
1297         if (strcmp (array [0], "ABC"))
1298                 return 1;
1299         if (strcmp (array [1], "DEF"))
1300                 return 2;
1301
1302         if (array [2] != NULL)
1303                 return 3;
1304
1305         return 0;
1306 }
1307
1308 LIBTEST_API int STDCALL
1309 mono_test_marshal_byref_string_array (char ***array)
1310 {
1311         if (*array == NULL)
1312                 return 0;
1313
1314         if (strcmp ((*array) [0], "Alpha"))
1315                 return 2;
1316         if (strcmp ((*array) [1], "Beta"))
1317                 return 2;
1318         if (strcmp ((*array) [2], "Gamma"))
1319                 return 2;
1320
1321         return 1;
1322 }
1323
1324 LIBTEST_API int STDCALL
1325 mono_test_marshal_stringbuilder_array (char **array)
1326 {
1327         if (strcmp (array [0], "ABC"))
1328                 return 1;
1329         if (strcmp (array [1], "DEF"))
1330                 return 2;
1331
1332         strcpy (array [0], "DEF");
1333         strcpy (array [1], "ABC");
1334
1335         return 0;
1336 }
1337
1338 LIBTEST_API int STDCALL
1339 mono_test_marshal_unicode_string_array (gunichar2 **array, char **array2)
1340 {
1341         GError *gerror = NULL;
1342         char *s;
1343
1344         s = g_utf16_to_utf8 (array [0], -1, NULL, NULL, &gerror);
1345         if (strcmp (s, "ABC")) {
1346                 g_free (s);
1347                 return 1;
1348         }
1349         else
1350                 g_free (s);
1351
1352         s = g_utf16_to_utf8 (array [1], -1, NULL, NULL, &gerror);
1353         if (strcmp (s, "DEF")) {
1354                 g_free (s);
1355                 return 2;
1356         }
1357         else
1358                 g_free (s);
1359
1360         if (strcmp (array2 [0], "ABC"))
1361                 return 3;
1362
1363         if (strcmp (array2 [1], "DEF"))
1364                 return 4;
1365
1366         return 0;
1367 }
1368
1369 /* this does not work on Redhat gcc 2.96 */
1370 LIBTEST_API int STDCALL
1371 mono_test_empty_struct (int a, EmptyStruct es, int b)
1372 {
1373         // printf ("mono_test_empty_struct %d %d\n", a, b);
1374
1375         // Intel icc on ia64 passes 'es' in 2 registers
1376 #if defined(__ia64) && defined(__INTEL_COMPILER)
1377         return 0;
1378 #else
1379         if (a == 1 && b == 2)
1380                 return 0;
1381         return 1;
1382 #endif
1383 }
1384
1385 LIBTEST_API EmptyStruct STDCALL
1386 mono_test_return_empty_struct (int a)
1387 {
1388         EmptyStruct s;
1389
1390         memset (&s, 0, sizeof (s));
1391
1392 #if !(defined(__i386__) && defined(__clang__))
1393         /* https://bugzilla.xamarin.com/show_bug.cgi?id=58901 */
1394         g_assert (a == 42);
1395 #endif
1396
1397         return s;
1398 }
1399
1400 typedef struct {
1401        char a[100];
1402 } ByValStrStruct;
1403
1404 LIBTEST_API ByValStrStruct * STDCALL
1405 mono_test_byvalstr_gen (void)
1406 {
1407         ByValStrStruct *ret;
1408
1409         ret = (ByValStrStruct *)malloc (sizeof (ByValStrStruct));
1410         memset(ret, 'a', sizeof(ByValStrStruct)-1);
1411         ret->a[sizeof(ByValStrStruct)-1] = 0;
1412
1413         return ret;
1414 }
1415
1416 LIBTEST_API int STDCALL
1417 mono_test_byvalstr_check (ByValStrStruct* data, char* correctString)
1418 {
1419         int ret;
1420
1421         ret = strcmp(data->a, correctString);
1422         // printf ("T1: %s\n", data->a);
1423         // printf ("T2: %s\n", correctString);
1424
1425         /* we need g_free because the allocation was performed by mono_test_byvalstr_gen */
1426         g_free (data);
1427         return (ret != 0);
1428 }
1429
1430 typedef struct {
1431         guint16 a[4];
1432         int  flag;
1433 } ByValStrStruct_Unicode;
1434
1435 LIBTEST_API int STDCALL
1436 mono_test_byvalstr_check_unicode (ByValStrStruct_Unicode *ref, int test)
1437 {
1438         if (ref->flag != 0x1234abcd){
1439                 printf ("overwritten data");
1440                 return 1;
1441         }
1442
1443         if (test == 1 || test == 3){
1444                 if (ref->a [0] != '1' ||
1445                     ref->a [1] != '2'   ||
1446                     ref->a [2] != '3')
1447                         return 1;
1448                 return 0;
1449         }
1450         if (test == 2){
1451                 if (ref->a [0] != '1' ||
1452                     ref->a [1] != '2')
1453                         return 1;
1454                 return 0;
1455         }
1456         return 10;
1457 }
1458
1459 LIBTEST_API int STDCALL
1460 NameManglingAnsi (char *data)
1461 {
1462         return data [0] + data [1] + data [2];
1463 }
1464
1465 LIBTEST_API int STDCALL
1466 NameManglingAnsiA (char *data)
1467 {
1468         g_assert_not_reached ();
1469 }
1470
1471 LIBTEST_API int STDCALL
1472 NameManglingAnsiW (char *data)
1473 {
1474         g_assert_not_reached ();
1475 }
1476
1477 LIBTEST_API int STDCALL
1478 NameManglingAnsi2A (char *data)
1479 {
1480         return data [0] + data [1] + data [2];
1481 }
1482
1483 LIBTEST_API int STDCALL
1484 NameManglingAnsi2W (char *data)
1485 {
1486         g_assert_not_reached ();
1487 }
1488
1489 LIBTEST_API int STDCALL
1490 NameManglingUnicode (char *data)
1491 {
1492         g_assert_not_reached ();
1493 }
1494
1495 LIBTEST_API int STDCALL
1496 NameManglingUnicodeW (gunichar2 *data)
1497 {
1498         return data [0] + data [1] + data [2];
1499 }
1500
1501 LIBTEST_API int STDCALL
1502 NameManglingUnicode2 (gunichar2 *data)
1503 {
1504         return data [0] + data [1] + data [2];
1505 }
1506
1507 LIBTEST_API int STDCALL
1508 NameManglingAutoW (char *data)
1509 {
1510 #ifdef WIN32
1511         return (data [0] + data [1] + data [2]) == 131 ? 0 : 1;
1512 #else
1513         g_assert_not_reached ();
1514 #endif
1515 }
1516
1517 LIBTEST_API int STDCALL
1518 NameManglingAuto (char *data)
1519 {
1520 #ifndef WIN32
1521         return (data [0] + data [1] + data [2]) == 198 ? 0 : 1;
1522 #else
1523         g_assert_not_reached ();
1524 #endif
1525 }
1526
1527 typedef int (STDCALL *intcharFunc)(const char*);
1528
1529 LIBTEST_API void STDCALL
1530 callFunction (intcharFunc f)
1531 {
1532         f ("ABC");
1533 }
1534
1535 typedef struct {
1536         const char* str;
1537         int i;
1538 } SimpleObj;
1539
1540 LIBTEST_API int STDCALL
1541 class_marshal_test0 (SimpleObj *obj1)
1542 {
1543         // printf ("class_marshal_test0 %s %d\n", obj1->str, obj1->i);
1544
1545         if (strcmp(obj1->str, "T1"))
1546                 return -1;
1547         if (obj1->i != 4)
1548                 return -2;
1549
1550         return 0;
1551 }
1552
1553 LIBTEST_API int STDCALL
1554 class_marshal_test4 (SimpleObj *obj1)
1555 {
1556         if (obj1)
1557                 return -1;
1558
1559         return 0;
1560 }
1561
1562 LIBTEST_API void STDCALL
1563 class_marshal_test1 (SimpleObj **obj1)
1564 {
1565         SimpleObj *res = (SimpleObj *)malloc (sizeof (SimpleObj));
1566
1567         res->str = marshal_strdup ("ABC");
1568         res->i = 5;
1569
1570         *obj1 = res;
1571 }
1572
1573 LIBTEST_API int STDCALL
1574 class_marshal_test2 (SimpleObj **obj1)
1575 {
1576         // printf ("class_marshal_test2 %s %d\n", (*obj1)->str, (*obj1)->i);
1577
1578         if (strcmp((*obj1)->str, "ABC"))
1579                 return -1;
1580         if ((*obj1)->i != 5)
1581                 return -2;
1582
1583         return 0;
1584 }
1585
1586 LIBTEST_API int STDCALL
1587 string_marshal_test0 (char *str)
1588 {
1589         if (strcmp (str, "TEST0"))
1590                 return -1;
1591
1592         return 0;
1593 }
1594
1595 LIBTEST_API void STDCALL
1596 string_marshal_test1 (const char **str)
1597 {
1598         *str = marshal_strdup ("TEST1");
1599 }
1600
1601 LIBTEST_API int STDCALL
1602 string_marshal_test2 (char **str)
1603 {
1604         // printf ("string_marshal_test2 %s\n", *str);
1605
1606         if (strcmp (*str, "TEST1"))
1607                 return -1;
1608
1609         *str = marshal_strdup ("TEST2");
1610
1611         return 0;
1612 }
1613
1614 LIBTEST_API int STDCALL
1615 string_marshal_test3 (char *str)
1616 {
1617         if (str)
1618                 return -1;
1619
1620         return 0;
1621 }
1622
1623 typedef struct {
1624         int a;
1625         int b;
1626 } BlittableClass;
1627
1628 LIBTEST_API BlittableClass* STDCALL
1629 TestBlittableClass (BlittableClass *vl)
1630 {
1631         BlittableClass *res;
1632
1633         // printf ("TestBlittableClass %d %d\n", vl->a, vl->b);
1634
1635         if (vl) {
1636                 vl->a++;
1637                 vl->b++;
1638
1639                 res = marshal_new0 (BlittableClass, 1);
1640                 memcpy (res, vl, sizeof (BlittableClass));
1641         } else {
1642                 res = marshal_new0 (BlittableClass, 1);
1643                 res->a = 42;
1644                 res->b = 43;
1645         }
1646
1647         return res;
1648 }
1649
1650 typedef struct OSVERSIONINFO_STRUCT
1651 {
1652         int a;
1653         int b;
1654 } OSVERSIONINFO_STRUCT;
1655
1656 LIBTEST_API int STDCALL
1657 MyGetVersionEx (OSVERSIONINFO_STRUCT *osvi)
1658 {
1659
1660         // printf ("GOT %d %d\n", osvi->a, osvi->b);
1661
1662         osvi->a += 1;
1663         osvi->b += 1;
1664
1665         return osvi->a + osvi->b;
1666 }
1667
1668 LIBTEST_API int STDCALL
1669 BugGetVersionEx (int a, int b, int c, int d, int e, int f, int g, int h, OSVERSIONINFO_STRUCT *osvi)
1670 {
1671
1672         // printf ("GOT %d %d\n", osvi->a, osvi->b);
1673
1674         osvi->a += 1;
1675         osvi->b += 1;
1676
1677         return osvi->a + osvi->b;
1678 }
1679
1680 LIBTEST_API int STDCALL
1681 mono_test_marshal_point (point pt)
1682 {
1683         // printf("point %g %g\n", pt.x, pt.y);
1684         if (pt.x == 1.25 && pt.y == 3.5)
1685                 return 0;
1686
1687         return 1;
1688 }
1689
1690 typedef struct {
1691         int x;
1692         double y;
1693 } mixed_point;
1694
1695 LIBTEST_API int STDCALL
1696 mono_test_marshal_mixed_point (mixed_point pt)
1697 {
1698         // printf("mixed point %d %g\n", pt.x, pt.y);
1699         if (pt.x == 5 && pt.y == 6.75)
1700                 return 0;
1701
1702         return 1;
1703 }
1704
1705 LIBTEST_API int STDCALL
1706 mono_test_marshal_mixed_point_2 (mixed_point *pt)
1707 {
1708         if (pt->x != 5 || pt->y != 6.75)
1709                 return 1;
1710
1711         pt->x = 10;
1712         pt->y = 12.35;
1713
1714         return 0;
1715 }
1716
1717 LIBTEST_API int STDCALL
1718 marshal_test_ref_bool(int i, char *b1, short *b2, int *b3)
1719 {
1720     int res = 1;
1721     if (*b1 != 0 && *b1 != 1)
1722         return 1;
1723     if (*b2 != 0 && *b2 != -1) /* variant_bool */
1724         return 1;
1725     if (*b3 != 0 && *b3 != 1)
1726         return 1;
1727     if (i == ((*b1 << 2) | (-*b2 << 1) | *b3))
1728         res = 0;
1729     *b1 = !*b1;
1730     *b2 = ~*b2;
1731     *b3 = !*b3;
1732     return res;
1733 }
1734
1735 struct BoolStruct
1736 {
1737     int i;
1738     char b1;
1739     short b2; /* variant_bool */
1740     int b3;
1741 };
1742
1743 LIBTEST_API int STDCALL
1744 marshal_test_bool_struct(struct BoolStruct *s)
1745 {
1746     int res = 1;
1747     if (s->b1 != 0 && s->b1 != 1)
1748         return 1;
1749     if (s->b2 != 0 && s->b2 != -1)
1750         return 1;
1751     if (s->b3 != 0 && s->b3 != 1)
1752         return 1;
1753     if (s->i == ((s->b1 << 2) | (-s->b2 << 1) | s->b3))
1754         res = 0;
1755     s->b1 = !s->b1;
1756     s->b2 = ~s->b2;
1757     s->b3 = !s->b3;
1758     return res;
1759 }
1760
1761 typedef struct {
1762         gint64 l;
1763 } LongStruct2;
1764
1765 typedef struct {
1766         int i;
1767         LongStruct2 l;
1768 } LongStruct;
1769
1770 LIBTEST_API int STDCALL
1771 mono_test_marshal_long_struct (LongStruct *s)
1772 {
1773         return s->i + s->l.l;
1774 }
1775
1776 LIBTEST_API void STDCALL
1777 mono_test_last_error (int err)
1778 {
1779 #ifdef WIN32
1780         SetLastError (err);
1781
1782         /*
1783         * Make sure argument register used calling SetLastError
1784         * get's cleaned before returning back to caller. This is done to ensure
1785         * we don't get a undetected failure if error is preserved in register
1786         * on return since we read back value directly when doing p/invoke with SetLastError = true
1787         * into first argument register and then pass it to Mono function setting value in TLS.
1788         * If there is a codegen bug reading last error or the code has been incorrectly eliminated
1789         * this test could still succeed since expected error code could be left in argument register.
1790         * Below code just do something that shouldn't touch last error and won't be optimized away
1791         * but will change the argument registers to something different than err.
1792         */
1793         char buffer[256] = { 0 };
1794         char value[] = "Dummy";
1795         strncpy (buffer, value, G_N_ELEMENTS (value) - 1);
1796 #else
1797         mono_set_errno (err);
1798 #endif
1799 }
1800
1801 LIBTEST_API int STDCALL
1802 mono_test_asany (void *ptr, int what)
1803 {
1804         switch (what) {
1805         case 1:
1806                 return (*(int*)ptr == 5) ? 0 : 1;
1807         case 2:
1808                 return strcmp ((const char*)ptr, "ABC") == 0 ? 0 : 1;
1809         case 3: {
1810                 simplestruct2 ss = *(simplestruct2*)ptr;
1811
1812                 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
1813             !strcmp (ss.d, "TEST") &&
1814             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
1815                         return 0;
1816                 else
1817                         return 1;
1818         }
1819         case 4: {
1820                 GError *gerror = NULL;
1821                 char *s;
1822
1823                 s = g_utf16_to_utf8 ((const gunichar2 *)ptr, -1, NULL, NULL, &gerror);
1824
1825                 if (!s)
1826                         return 1;
1827
1828                 if (!strcmp (s, "ABC")) {
1829                         g_free (s);
1830                         return 0;
1831                 }
1832                 else {
1833                         g_free (s);
1834                         return 1;
1835                 }
1836         }
1837         default:
1838                 g_assert_not_reached ();
1839         }
1840
1841         return 1;
1842 }
1843
1844 typedef struct
1845 {
1846         int i;
1847         int j;
1848         int k;
1849         char *s;
1850 } AsAnyStruct;
1851
1852 LIBTEST_API int STDCALL
1853 mono_test_marshal_asany_in (void* ptr)
1854 {
1855         AsAnyStruct *asAny = (AsAnyStruct *)ptr;
1856         int res = asAny->i + asAny->j + asAny->k;
1857
1858         return res;
1859 }
1860
1861 LIBTEST_API int STDCALL
1862 mono_test_marshal_asany_inout (void* ptr)
1863 {
1864         AsAnyStruct *asAny = (AsAnyStruct *)ptr;
1865         int res = asAny->i + asAny->j + asAny->k;
1866
1867         marshal_free (asAny->s);
1868
1869         asAny->i = 10;
1870         asAny->j = 20;
1871         asAny->k = 30;
1872         asAny->s = 0;
1873
1874         return res;
1875 }
1876
1877 LIBTEST_API int STDCALL
1878 mono_test_marshal_asany_out (void* ptr)
1879 {
1880         AsAnyStruct *asAny = (AsAnyStruct *)ptr;
1881         int res = asAny->i + asAny->j + asAny->k;
1882
1883         asAny->i = 10;
1884         asAny->j = 20;
1885         asAny->k = 30;
1886         asAny->s = 0;
1887
1888         return res;
1889 }
1890
1891 /*
1892  * AMD64 marshalling tests.
1893  */
1894
1895 typedef struct amd64_struct1 {
1896         int i;
1897         int j;
1898         int k;
1899         int l;
1900 } amd64_struct1;
1901
1902 LIBTEST_API amd64_struct1 STDCALL
1903 mono_test_marshal_amd64_pass_return_struct1 (amd64_struct1 s)
1904 {
1905         s.i ++;
1906         s.j ++;
1907         s.k ++;
1908         s.l ++;
1909
1910         return s;
1911 }
1912
1913 LIBTEST_API amd64_struct1 STDCALL
1914 mono_test_marshal_amd64_pass_return_struct1_many_args (amd64_struct1 s, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8)
1915 {
1916         s.i ++;
1917         s.j ++;
1918         s.k ++;
1919         s.l += 1 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8;
1920
1921         return s;
1922 }
1923
1924 typedef struct amd64_struct2 {
1925         int i;
1926         int j;
1927 } amd64_struct2;
1928
1929 LIBTEST_API amd64_struct2 STDCALL
1930 mono_test_marshal_amd64_pass_return_struct2 (amd64_struct2 s)
1931 {
1932         s.i ++;
1933         s.j ++;
1934
1935         return s;
1936 }
1937
1938 typedef struct amd64_struct3 {
1939         int i;
1940 } amd64_struct3;
1941
1942 LIBTEST_API amd64_struct3 STDCALL
1943 mono_test_marshal_amd64_pass_return_struct3 (amd64_struct3 s)
1944 {
1945         s.i ++;
1946
1947         return s;
1948 }
1949
1950 typedef struct amd64_struct4 {
1951         double d1, d2;
1952 } amd64_struct4;
1953
1954 LIBTEST_API amd64_struct4 STDCALL
1955 mono_test_marshal_amd64_pass_return_struct4 (amd64_struct4 s)
1956 {
1957         s.d1 ++;
1958         s.d2 ++;
1959
1960         return s;
1961 }
1962
1963 /*
1964  * IA64 marshalling tests.
1965  */
1966 typedef struct test_struct5 {
1967         float d1, d2;
1968 } test_struct5;
1969
1970 LIBTEST_API test_struct5 STDCALL
1971 mono_test_marshal_ia64_pass_return_struct5 (double d1, double d2, test_struct5 s, int i, double d3, double d4)
1972 {
1973         s.d1 += d1 + d2 + i;
1974         s.d2 += d3 + d4 + i;
1975
1976         return s;
1977 }
1978
1979 typedef struct test_struct6 {
1980         double d1, d2;
1981 } test_struct6;
1982
1983 LIBTEST_API test_struct6 STDCALL
1984 mono_test_marshal_ia64_pass_return_struct6 (double d1, double d2, test_struct6 s, int i, double d3, double d4)
1985 {
1986         s.d1 += d1 + d2 + i;
1987         s.d2 += d3 + d4;
1988
1989         return s;
1990 }
1991
1992 static guint32 custom_res [2];
1993
1994 LIBTEST_API void* STDCALL
1995 mono_test_marshal_pass_return_custom (int i, guint32 *ptr, int j)
1996 {
1997         /* ptr will be freed by CleanupNative, so make a copy */
1998         custom_res [0] = 0; /* not allocated by AllocHGlobal */
1999         custom_res [1] = ptr [1];
2000
2001         return &custom_res;
2002 }
2003
2004 LIBTEST_API int STDCALL
2005 mono_test_marshal_pass_out_custom (int i, guint32 **ptr, int j)
2006 {
2007         custom_res [0] = 0;
2008         custom_res [1] = i + j + 10;
2009
2010         *ptr = custom_res;
2011
2012         return 0;
2013 }
2014
2015 LIBTEST_API int STDCALL
2016 mono_test_marshal_pass_inout_custom (int i, guint32 *ptr, int j)
2017 {
2018         ptr [0] = 0;
2019         ptr [1] = i + ptr [1] + j;
2020
2021         return 0;
2022 }
2023
2024 LIBTEST_API int STDCALL
2025 mono_test_marshal_pass_out_byval_custom (int i, guint32 *ptr, int j)
2026 {
2027         return ptr == NULL ? 0 : 1;
2028 }
2029
2030 LIBTEST_API int STDCALL
2031 mono_test_marshal_pass_byref_custom (int i, guint32 **ptr, int j)
2032 {
2033         (*ptr)[1] += i + j;
2034
2035         return 0;
2036 }
2037
2038 LIBTEST_API void* STDCALL
2039 mono_test_marshal_pass_return_custom2 (int i, guint32 *ptr, int j)
2040 {
2041         g_assert_not_reached ();
2042
2043         return NULL;
2044 }
2045
2046 LIBTEST_API void* STDCALL
2047 mono_test_marshal_pass_return_custom_null (int i, guint32 *ptr, int j)
2048 {
2049         g_assert (ptr == NULL);
2050
2051         return NULL;
2052 }
2053
2054 typedef void *(STDCALL *PassReturnPtrDelegate) (void *ptr);
2055
2056 LIBTEST_API int STDCALL
2057 mono_test_marshal_pass_return_custom_in_delegate (PassReturnPtrDelegate del)
2058 {
2059         guint32 buf [2];
2060         guint32 res;
2061         guint32 *ptr;
2062
2063         buf [0] = 0;
2064         buf [1] = 10;
2065
2066         ptr = (guint32 *)del (&buf);
2067
2068         res = ptr [1];
2069
2070 #ifdef WIN32
2071         /* FIXME: Freed with FreeHGlobal */
2072 #else
2073         g_free (ptr);
2074 #endif
2075
2076         return res;
2077 }
2078
2079 LIBTEST_API int STDCALL
2080 mono_test_marshal_pass_return_custom_null_in_delegate (PassReturnPtrDelegate del)
2081 {
2082         void *ptr = del (NULL);
2083
2084         return (ptr == NULL) ? 15 : 0;
2085 }
2086
2087 typedef void (STDCALL *CustomOutParamDelegate) (void **pptr);
2088
2089 LIBTEST_API int STDCALL
2090 mono_test_marshal_custom_out_param_delegate (CustomOutParamDelegate del)
2091 {
2092         void* pptr = (void*)del;
2093
2094         del (&pptr);
2095
2096         if(pptr != NULL)
2097                 return 1;
2098
2099         return 0;
2100 }
2101
2102 typedef int (STDCALL *ReturnEnumDelegate) (int e);
2103
2104 LIBTEST_API int STDCALL
2105 mono_test_marshal_return_enum_delegate (ReturnEnumDelegate func)
2106 {
2107         return func (1);
2108 }
2109
2110 typedef struct {
2111         int a, b, c;
2112         gint64 d;
2113 } BlittableStruct;
2114
2115 typedef BlittableStruct (STDCALL *SimpleDelegate10) (BlittableStruct ss);
2116
2117 LIBTEST_API int STDCALL
2118 mono_test_marshal_blittable_struct_delegate (SimpleDelegate10 delegate)
2119 {
2120         BlittableStruct ss, res;
2121
2122         ss.a = 1;
2123         ss.b = 2;
2124         ss.c = 3;
2125         ss.d = 55;
2126
2127         res = delegate (ss);
2128         if (! ((res.a == -1) && (res.b == -2) && (res.c == -3) && (res.d == -55)))
2129                 return 1;
2130
2131         return 0;
2132 }
2133
2134 LIBTEST_API int STDCALL
2135 mono_test_stdcall_name_mangling (int a, int b, int c)
2136 {
2137         return a + b + c;
2138 }
2139
2140 LIBTEST_API int
2141 mono_test_stdcall_mismatch_1 (int a, int b, int c)
2142 {
2143         return a + b + c;
2144 }
2145
2146 LIBTEST_API int STDCALL
2147 mono_test_stdcall_mismatch_2 (int a, int b, int c)
2148 {
2149         return a + b + c;
2150 }
2151
2152 /*
2153  * PASSING AND RETURNING SMALL STRUCTURES FROM DELEGATES TESTS
2154  */
2155
2156 typedef struct {
2157         int i;
2158 } SmallStruct1;
2159
2160 typedef SmallStruct1 (STDCALL *SmallStructDelegate1) (SmallStruct1 ss);
2161
2162 LIBTEST_API int STDCALL
2163 mono_test_marshal_small_struct_delegate1 (SmallStructDelegate1 delegate)
2164 {
2165         SmallStruct1 ss, res;
2166
2167         ss.i = 1;
2168
2169         res = delegate (ss);
2170         if (! (res.i == -1))
2171                 return 1;
2172
2173         return 0;
2174 }
2175
2176 typedef struct {
2177         gint16 i, j;
2178 } SmallStruct2;
2179
2180 typedef SmallStruct2 (STDCALL *SmallStructDelegate2) (SmallStruct2 ss);
2181
2182 LIBTEST_API int STDCALL
2183 mono_test_marshal_small_struct_delegate2 (SmallStructDelegate2 delegate)
2184 {
2185         SmallStruct2 ss, res;
2186
2187         ss.i = 2;
2188         ss.j = 3;
2189
2190         res = delegate (ss);
2191         if (! ((res.i == -2) && (res.j == -3)))
2192                 return 1;
2193
2194         return 0;
2195 }
2196
2197 typedef struct {
2198         gint16 i;
2199         gint8 j;
2200 } SmallStruct3;
2201
2202 typedef SmallStruct3 (STDCALL *SmallStructDelegate3) (SmallStruct3 ss);
2203
2204 LIBTEST_API int STDCALL
2205 mono_test_marshal_small_struct_delegate3 (SmallStructDelegate3 delegate)
2206 {
2207         SmallStruct3 ss, res;
2208
2209         ss.i = 1;
2210         ss.j = 2;
2211
2212         res = delegate (ss);
2213         if (! ((res.i == -1) && (res.j == -2)))
2214                 return 1;
2215
2216         return 0;
2217 }
2218
2219 typedef struct {
2220         gint16 i;
2221 } SmallStruct4;
2222
2223 typedef SmallStruct4 (STDCALL *SmallStructDelegate4) (SmallStruct4 ss);
2224
2225 LIBTEST_API int STDCALL
2226 mono_test_marshal_small_struct_delegate4 (SmallStructDelegate4 delegate)
2227 {
2228         SmallStruct4 ss, res;
2229
2230         ss.i = 1;
2231
2232         res = delegate (ss);
2233         if (! (res.i == -1))
2234                 return 1;
2235
2236         return 0;
2237 }
2238
2239 typedef struct {
2240         gint64 i;
2241 } SmallStruct5;
2242
2243 typedef SmallStruct5 (STDCALL *SmallStructDelegate5) (SmallStruct5 ss);
2244
2245 LIBTEST_API int STDCALL
2246 mono_test_marshal_small_struct_delegate5 (SmallStructDelegate5 delegate)
2247 {
2248         SmallStruct5 ss, res;
2249
2250         ss.i = 5;
2251
2252         res = delegate (ss);
2253         if (! (res.i == -5))
2254                 return 1;
2255
2256         return 0;
2257 }
2258
2259 typedef struct {
2260         int i, j;
2261 } SmallStruct6;
2262
2263 typedef SmallStruct6 (STDCALL *SmallStructDelegate6) (SmallStruct6 ss);
2264
2265 LIBTEST_API int STDCALL
2266 mono_test_marshal_small_struct_delegate6 (SmallStructDelegate6 delegate)
2267 {
2268         SmallStruct6 ss, res;
2269
2270         ss.i = 1;
2271         ss.j = 2;
2272
2273         res = delegate (ss);
2274         if (! ((res.i == -1) && (res.j == -2)))
2275                 return 1;
2276
2277         return 0;
2278 }
2279
2280 typedef struct {
2281         int i;
2282         gint16 j;
2283 } SmallStruct7;
2284
2285 typedef SmallStruct7 (STDCALL *SmallStructDelegate7) (SmallStruct7 ss);
2286
2287 LIBTEST_API int STDCALL
2288 mono_test_marshal_small_struct_delegate7 (SmallStructDelegate7 delegate)
2289 {
2290         SmallStruct7 ss, res;
2291
2292         ss.i = 1;
2293         ss.j = 2;
2294
2295         res = delegate (ss);
2296         if (! ((res.i == -1) && (res.j == -2)))
2297                 return 1;
2298
2299         return 0;
2300 }
2301
2302 typedef struct {
2303         float i;
2304 } SmallStruct8;
2305
2306 typedef SmallStruct8 (STDCALL *SmallStructDelegate8) (SmallStruct8 ss);
2307
2308 LIBTEST_API int STDCALL
2309 mono_test_marshal_small_struct_delegate8 (SmallStructDelegate8 delegate)
2310 {
2311         SmallStruct8 ss, res;
2312
2313         ss.i = 1.0;
2314
2315         res = delegate (ss);
2316         if (! ((res.i == -1.0)))
2317                 return 1;
2318
2319         return 0;
2320 }
2321
2322 typedef struct {
2323         double i;
2324 } SmallStruct9;
2325
2326 typedef SmallStruct9 (STDCALL *SmallStructDelegate9) (SmallStruct9 ss);
2327
2328 LIBTEST_API int STDCALL
2329 mono_test_marshal_small_struct_delegate9 (SmallStructDelegate9 delegate)
2330 {
2331         SmallStruct9 ss, res;
2332
2333         ss.i = 1.0;
2334
2335         res = delegate (ss);
2336         if (! ((res.i == -1.0)))
2337                 return 1;
2338
2339         return 0;
2340 }
2341
2342 typedef struct {
2343         float i, j;
2344 } SmallStruct10;
2345
2346 typedef SmallStruct10 (STDCALL *SmallStructDelegate10) (SmallStruct10 ss);
2347
2348 LIBTEST_API int STDCALL
2349 mono_test_marshal_small_struct_delegate10 (SmallStructDelegate10 delegate)
2350 {
2351         SmallStruct10 ss, res;
2352
2353         ss.i = 1.0;
2354         ss.j = 2.0;
2355
2356         res = delegate (ss);
2357         if (! ((res.i == -1.0) && (res.j == -2.0)))
2358                 return 1;
2359
2360         return 0;
2361 }
2362
2363 typedef struct {
2364         float i;
2365         int j;
2366 } SmallStruct11;
2367
2368 typedef SmallStruct11 (STDCALL *SmallStructDelegate11) (SmallStruct11 ss);
2369
2370 LIBTEST_API int STDCALL
2371 mono_test_marshal_small_struct_delegate11 (SmallStructDelegate11 delegate)
2372 {
2373         SmallStruct11 ss, res;
2374
2375         ss.i = 1.0;
2376         ss.j = 2;
2377
2378         res = delegate (ss);
2379         if (! ((res.i == -1.0) && (res.j == -2)))
2380                 return 1;
2381
2382         return 0;
2383 }
2384
2385 typedef int (STDCALL *ArrayDelegate) (int i, char *j, void *arr);
2386
2387 LIBTEST_API int STDCALL
2388 mono_test_marshal_array_delegate (void *arr, int len, ArrayDelegate del)
2389 {
2390         return del (len, NULL, arr);
2391 }
2392
2393 typedef int (STDCALL *ArrayDelegateLong) (gint64 i, char *j, void *arr);
2394
2395 LIBTEST_API int STDCALL
2396 mono_test_marshal_array_delegate_long (void *arr, gint64 len, ArrayDelegateLong del)
2397 {
2398         return del (len, NULL, arr);
2399 }
2400
2401 LIBTEST_API int STDCALL
2402 mono_test_marshal_out_array_delegate (int *arr, int len, ArrayDelegate del)
2403 {
2404         del (len, NULL, arr);
2405
2406         if ((arr [0] != 1) || (arr [1] != 2))
2407                 return 1;
2408         else
2409                 return 0;
2410 }
2411
2412 typedef gunichar2* (STDCALL *UnicodeStringDelegate) (gunichar2 *message);
2413
2414 LIBTEST_API int STDCALL
2415 mono_test_marshal_return_unicode_string_delegate (UnicodeStringDelegate del)
2416 {
2417         const char m[] = "abcdef";
2418         gunichar2 *s2, *res;
2419         glong len;
2420
2421         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
2422
2423         res = del (s2);
2424
2425         marshal_free (res);
2426
2427         return 0;
2428 }
2429
2430 LIBTEST_API int STDCALL
2431 mono_test_marshal_out_string_array_delegate (char **arr, int len, ArrayDelegate del)
2432 {
2433         del (len, NULL, arr);
2434
2435         if (!strcmp (arr [0], "ABC") && !strcmp (arr [1], "DEF"))
2436                 return 0;
2437         else
2438                 return 1;
2439 }
2440
2441 typedef int (*CdeclDelegate) (int i, int j);
2442
2443 LIBTEST_API int STDCALL
2444 mono_test_marshal_cdecl_delegate (CdeclDelegate del)
2445 {
2446         int i;
2447
2448         for (i = 0; i < 1000; ++i)
2449                 del (1, 2);
2450
2451         return 0;
2452 }
2453
2454 typedef char** (STDCALL *ReturnStringArrayDelegate) (int i);
2455
2456 LIBTEST_API int STDCALL
2457 mono_test_marshal_return_string_array_delegate (ReturnStringArrayDelegate d)
2458 {
2459         char **arr = d (2);
2460         int res;
2461
2462         if (arr == NULL)
2463                 return 3;
2464
2465         if (strcmp (arr [0], "ABC") || strcmp (arr [1], "DEF"))
2466                 res = 1;
2467         else
2468                 res = 0;
2469
2470         marshal_free (arr);
2471
2472         return res;
2473 }
2474
2475 typedef int (STDCALL *ByrefStringDelegate) (char **s);
2476
2477 LIBTEST_API int STDCALL
2478 mono_test_marshal_byref_string_delegate (ByrefStringDelegate d)
2479 {
2480         char *s = (char*)"ABC";
2481         int res;
2482
2483         res = d (&s);
2484         if (res != 0)
2485                 return res;
2486
2487         if (!strcmp (s, "DEF"))
2488                 res = 0;
2489         else
2490                 res = 2;
2491
2492         marshal_free (s);
2493
2494         return res;
2495 }
2496
2497 LIBTEST_API int STDCALL
2498 add_delegate (int i, int j)
2499 {
2500         return i + j;
2501 }
2502
2503 LIBTEST_API gpointer STDCALL
2504 mono_test_marshal_return_fnptr (void)
2505 {
2506         return (gpointer)&add_delegate;
2507 }
2508
2509 LIBTEST_API int STDCALL
2510 mono_xr (int code)
2511 {
2512         printf ("codigo %x\n", code);
2513         return code + 1234;
2514 }
2515
2516 typedef struct {
2517         int handle;
2518 } HandleRef;
2519
2520 LIBTEST_API HandleRef STDCALL
2521 mono_xr_as_handle (int code)
2522 {
2523         HandleRef ref;
2524
2525         memset (&ref, 0, sizeof (ref));
2526
2527         return ref;
2528 }
2529
2530 typedef struct {
2531         int   a;
2532         void *handle1;
2533         void *handle2;
2534         int   b;
2535 } HandleStructs;
2536
2537 LIBTEST_API int STDCALL
2538 mono_safe_handle_struct_ref (HandleStructs *x)
2539 {
2540         printf ("Dingus Ref! \n");
2541         printf ("Values: %d %d %p %p\n", x->a, x->b, x->handle1, x->handle2);
2542         if (x->a != 1234)
2543                 return 1;
2544         if (x->b != 8743)
2545                 return 2;
2546
2547         if (x->handle1 != (void*) 0x7080feed)
2548                 return 3;
2549
2550         if (x->handle2 != (void*) 0x1234abcd)
2551                 return 4;
2552
2553         return 0xf00d;
2554 }
2555
2556 LIBTEST_API int STDCALL
2557 mono_safe_handle_struct (HandleStructs x)
2558 {
2559         printf ("Dingus Standard! \n");
2560         printf ("Values: %d %d %p %p\n", x.a, x.b, x.handle1, x.handle2);
2561         if (x.a != 1234)
2562                 return 1;
2563         if (x.b != 8743)
2564                 return 2;
2565
2566         if (x.handle1 != (void*) 0x7080feed)
2567                 return 3;
2568
2569         if (x.handle2 != (void*) 0x1234abcd)
2570                 return 4;
2571
2572         return 0xf00f;
2573 }
2574
2575 typedef struct {
2576         void *a;
2577 } TrivialHandle;
2578
2579 LIBTEST_API int STDCALL
2580 mono_safe_handle_struct_simple (TrivialHandle x)
2581 {
2582         printf ("The value is %p\n", x.a);
2583         return ((int)(gsize)x.a) * 2;
2584 }
2585
2586 LIBTEST_API int STDCALL
2587 mono_safe_handle_return (void)
2588 {
2589         return 0x1000f00d;
2590 }
2591
2592 LIBTEST_API void STDCALL
2593 mono_safe_handle_ref (void **handle)
2594 {
2595         if (*handle != 0){
2596                 *handle = (void *) 0x800d;
2597                 return;
2598         }
2599
2600         *handle = (void *) 0xbad;
2601 }
2602
2603 LIBTEST_API void* STDCALL
2604 mono_safe_handle_ref_nomod (void **handle)
2605 {
2606         return *handle;
2607 }
2608
2609 LIBTEST_API double STDCALL
2610 mono_test_marshal_date_time (double d, double *d2)
2611 {
2612         *d2 = d;
2613         return d;
2614 }
2615
2616 /*
2617  * COM INTEROP TESTS
2618  */
2619
2620 #ifndef WIN32
2621
2622 typedef struct {
2623         guint16 vt;
2624         guint16 wReserved1;
2625         guint16 wReserved2;
2626         guint16 wReserved3;
2627         union {
2628                 gint64 llVal;
2629                 gint32 lVal;
2630                 guint8  bVal;
2631                 gint16 iVal;
2632                 float  fltVal;
2633                 double dblVal;
2634                 gint16 boolVal;
2635                 gunichar2* bstrVal;
2636                 gint8 cVal;
2637                 guint16 uiVal;
2638                 guint32 ulVal;
2639                 guint64 ullVal;
2640                 gpointer byref;
2641                 struct {
2642                         gpointer pvRecord;
2643                         gpointer pRecInfo;
2644                 };
2645         };
2646 } VARIANT;
2647
2648 typedef enum {
2649         VARIANT_TRUE = -1,
2650         VARIANT_FALSE = 0
2651 } VariantBool;
2652
2653 typedef enum {
2654         VT_EMPTY = 0,
2655         VT_NULL = 1,
2656         VT_I2 = 2,
2657         VT_I4 = 3,
2658         VT_R4 = 4,
2659         VT_R8 = 5,
2660         VT_CY = 6,
2661         VT_DATE = 7,
2662         VT_BSTR = 8,
2663         VT_DISPATCH = 9,
2664         VT_ERROR = 10,
2665         VT_BOOL = 11,
2666         VT_VARIANT = 12,
2667         VT_UNKNOWN = 13,
2668         VT_DECIMAL = 14,
2669         VT_I1 = 16,
2670         VT_UI1 = 17,
2671         VT_UI2 = 18,
2672         VT_UI4 = 19,
2673         VT_I8 = 20,
2674         VT_UI8 = 21,
2675         VT_INT = 22,
2676         VT_UINT = 23,
2677         VT_VOID = 24,
2678         VT_HRESULT = 25,
2679         VT_PTR = 26,
2680         VT_SAFEARRAY = 27,
2681         VT_CARRAY = 28,
2682         VT_USERDEFINED = 29,
2683         VT_LPSTR = 30,
2684         VT_LPWSTR = 31,
2685         VT_RECORD = 36,
2686         VT_FILETIME = 64,
2687         VT_BLOB = 65,
2688         VT_STREAM = 66,
2689         VT_STORAGE = 67,
2690         VT_STREAMED_OBJECT = 68,
2691         VT_STORED_OBJECT = 69,
2692         VT_BLOB_OBJECT = 70,
2693         VT_CF = 71,
2694         VT_CLSID = 72,
2695         VT_VECTOR = 4096,
2696         VT_ARRAY = 8192,
2697         VT_BYREF = 16384
2698 } VarEnum;
2699
2700 void VariantInit(VARIANT* vt)
2701 {
2702         vt->vt = VT_EMPTY;
2703 }
2704
2705 typedef struct
2706 {
2707         guint32 a;
2708         guint16 b;
2709         guint16 c;
2710         guint8 d[8];
2711 } GUID;
2712
2713 #define S_OK 0
2714
2715 #endif
2716
2717 LIBTEST_API int STDCALL
2718 mono_test_marshal_bstr_in(gunichar2* bstr)
2719 {
2720         gint32 result = 0;
2721         gchar* bstr_utf8 = g_utf16_to_utf8 (bstr, -1, NULL, NULL, NULL);
2722         result = strcmp("mono_test_marshal_bstr_in", bstr_utf8);
2723         g_free(bstr_utf8);
2724         if (result == 0)
2725                 return 0;
2726         return 1;
2727 }
2728
2729 LIBTEST_API int STDCALL
2730 mono_test_marshal_bstr_out(gunichar2** bstr)
2731 {
2732         *bstr = marshal_bstr_alloc ("mono_test_marshal_bstr_out");
2733         return 0;
2734 }
2735
2736 LIBTEST_API int STDCALL
2737 mono_test_marshal_bstr_in_null(gunichar2* bstr)
2738 {
2739         if (!bstr)
2740                 return 0;
2741         return 1;
2742 }
2743
2744 LIBTEST_API int STDCALL
2745 mono_test_marshal_bstr_out_null(gunichar2** bstr)
2746 {
2747         *bstr = NULL;
2748         return 0;
2749 }
2750
2751 LIBTEST_API int STDCALL
2752 mono_test_marshal_variant_in_sbyte(VARIANT variant)
2753 {
2754         if (variant.vt == VT_I1 && variant.cVal == 100)
2755                 return 0;
2756         return 1;
2757 }
2758
2759 LIBTEST_API int STDCALL
2760 mono_test_marshal_variant_in_byte(VARIANT variant)
2761 {
2762         if (variant.vt == VT_UI1 && variant.bVal == 100)
2763                 return 0;
2764         return 1;
2765 }
2766
2767 LIBTEST_API int STDCALL
2768 mono_test_marshal_variant_in_short(VARIANT variant)
2769 {
2770         if (variant.vt == VT_I2 && variant.iVal == 314)
2771                 return 0;
2772         return 1;
2773 }
2774
2775 LIBTEST_API int STDCALL
2776 mono_test_marshal_variant_in_ushort(VARIANT variant)
2777 {
2778         if (variant.vt == VT_UI2 && variant.uiVal == 314)
2779                 return 0;
2780         return 1;
2781 }
2782
2783 LIBTEST_API int STDCALL
2784 mono_test_marshal_variant_in_int(VARIANT variant)
2785 {
2786         if (variant.vt == VT_I4 && variant.lVal == 314)
2787                 return 0;
2788         return 1;
2789 }
2790
2791 LIBTEST_API int STDCALL
2792 mono_test_marshal_variant_in_uint(VARIANT variant)
2793 {
2794         if (variant.vt == VT_UI4 && variant.ulVal == 314)
2795                 return 0;
2796         return 1;
2797 }
2798
2799 LIBTEST_API int STDCALL
2800 mono_test_marshal_variant_in_long(VARIANT variant)
2801 {
2802         if (variant.vt == VT_I8 && variant.llVal == 314)
2803                 return 0;
2804         return 1;
2805 }
2806
2807 LIBTEST_API int STDCALL
2808 mono_test_marshal_variant_in_ulong(VARIANT variant)
2809 {
2810         if (variant.vt == VT_UI8 && variant.ullVal == 314)
2811                 return 0;
2812         return 1;
2813 }
2814
2815 LIBTEST_API int STDCALL
2816 mono_test_marshal_variant_in_float(VARIANT variant)
2817 {
2818         if (variant.vt == VT_R4 && (variant.fltVal - 3.14)/3.14 < .001)
2819                 return 0;
2820         return 1;
2821 }
2822
2823 LIBTEST_API int STDCALL
2824 mono_test_marshal_variant_in_double(VARIANT variant)
2825 {
2826         if (variant.vt == VT_R8 && (variant.dblVal - 3.14)/3.14 < .001)
2827                 return 0;
2828         return 1;
2829 }
2830
2831 LIBTEST_API int STDCALL
2832 mono_test_marshal_variant_in_bstr(VARIANT variant)
2833 {
2834         gint32 result = 0;
2835         gchar* bstr_utf8 = g_utf16_to_utf8 (variant.bstrVal, -1, NULL, NULL, NULL);
2836         result = strcmp("PI", bstr_utf8);
2837         g_free(bstr_utf8);
2838
2839         if (variant.vt == VT_BSTR && !result)
2840                 return 0;
2841         return 1;
2842 }
2843
2844 LIBTEST_API int STDCALL
2845 mono_test_marshal_variant_in_bool_true (VARIANT variant)
2846 {
2847         if (variant.vt == VT_BOOL && variant.boolVal == VARIANT_TRUE)
2848                 return 0;
2849         return 1;
2850 }
2851
2852 LIBTEST_API int STDCALL
2853 mono_test_marshal_variant_in_bool_false (VARIANT variant)
2854 {
2855         if (variant.vt == VT_BOOL && variant.boolVal == VARIANT_FALSE)
2856                 return 0;
2857         return 1;
2858 }
2859
2860 LIBTEST_API int STDCALL
2861 mono_test_marshal_variant_out_sbyte(VARIANT* variant)
2862 {
2863         variant->vt = VT_I1;
2864         variant->cVal = 100;
2865
2866         return 0;
2867 }
2868
2869 LIBTEST_API int STDCALL
2870 mono_test_marshal_variant_out_sbyte_byref(VARIANT* variant)
2871 {
2872         variant->vt = VT_I1|VT_BYREF;
2873         variant->byref = marshal_alloc(1);
2874         *((gint8*)variant->byref) = 100;
2875
2876         return 0;
2877 }
2878
2879 LIBTEST_API int STDCALL
2880 mono_test_marshal_variant_out_byte(VARIANT* variant)
2881 {
2882         variant->vt = VT_UI1;
2883         variant->bVal = 100;
2884
2885         return 0;
2886 }
2887
2888 LIBTEST_API int STDCALL
2889 mono_test_marshal_variant_out_byte_byref(VARIANT* variant)
2890 {
2891         variant->vt = VT_UI1|VT_BYREF;
2892         variant->byref = marshal_alloc(1);
2893         *((gint8*)variant->byref) = 100;
2894
2895         return 0;
2896 }
2897
2898 LIBTEST_API int STDCALL
2899 mono_test_marshal_variant_out_short(VARIANT* variant)
2900 {
2901         variant->vt = VT_I2;
2902         variant->iVal = 314;
2903
2904         return 0;
2905 }
2906
2907 LIBTEST_API int STDCALL
2908 mono_test_marshal_variant_out_short_byref(VARIANT* variant)
2909 {
2910         variant->vt = VT_I2|VT_BYREF;
2911         variant->byref = marshal_alloc(2);
2912         *((gint16*)variant->byref) = 314;
2913
2914         return 0;
2915 }
2916
2917 LIBTEST_API int STDCALL
2918 mono_test_marshal_variant_out_ushort(VARIANT* variant)
2919 {
2920         variant->vt = VT_UI2;
2921         variant->uiVal = 314;
2922
2923         return 0;
2924 }
2925
2926 LIBTEST_API int STDCALL
2927 mono_test_marshal_variant_out_ushort_byref(VARIANT* variant)
2928 {
2929         variant->vt = VT_UI2|VT_BYREF;
2930         variant->byref = marshal_alloc(2);
2931         *((guint16*)variant->byref) = 314;
2932
2933         return 0;
2934 }
2935
2936 LIBTEST_API int STDCALL
2937 mono_test_marshal_variant_out_int(VARIANT* variant)
2938 {
2939         variant->vt = VT_I4;
2940         variant->lVal = 314;
2941
2942         return 0;
2943 }
2944
2945 LIBTEST_API int STDCALL
2946 mono_test_marshal_variant_out_int_byref(VARIANT* variant)
2947 {
2948         variant->vt = VT_I4|VT_BYREF;
2949         variant->byref = marshal_alloc(4);
2950         *((gint32*)variant->byref) = 314;
2951
2952         return 0;
2953 }
2954
2955 LIBTEST_API int STDCALL
2956 mono_test_marshal_variant_out_uint(VARIANT* variant)
2957 {
2958         variant->vt = VT_UI4;
2959         variant->ulVal = 314;
2960
2961         return 0;
2962 }
2963
2964 LIBTEST_API int STDCALL
2965 mono_test_marshal_variant_out_uint_byref(VARIANT* variant)
2966 {
2967         variant->vt = VT_UI4|VT_BYREF;
2968         variant->byref = marshal_alloc(4);
2969         *((guint32*)variant->byref) = 314;
2970
2971         return 0;
2972 }
2973
2974 LIBTEST_API int STDCALL
2975 mono_test_marshal_variant_out_long(VARIANT* variant)
2976 {
2977         variant->vt = VT_I8;
2978         variant->llVal = 314;
2979
2980         return 0;
2981 }
2982
2983 LIBTEST_API int STDCALL
2984 mono_test_marshal_variant_out_long_byref(VARIANT* variant)
2985 {
2986         variant->vt = VT_I8|VT_BYREF;
2987         variant->byref = marshal_alloc(8);
2988         *((gint64*)variant->byref) = 314;
2989
2990         return 0;
2991 }
2992
2993 LIBTEST_API int STDCALL
2994 mono_test_marshal_variant_out_ulong(VARIANT* variant)
2995 {
2996         variant->vt = VT_UI8;
2997         variant->ullVal = 314;
2998
2999         return 0;
3000 }
3001
3002 LIBTEST_API int STDCALL
3003 mono_test_marshal_variant_out_ulong_byref(VARIANT* variant)
3004 {
3005         variant->vt = VT_UI8|VT_BYREF;
3006         variant->byref = marshal_alloc(8);
3007         *((guint64*)variant->byref) = 314;
3008
3009         return 0;
3010 }
3011
3012 LIBTEST_API int STDCALL
3013 mono_test_marshal_variant_out_float(VARIANT* variant)
3014 {
3015         variant->vt = VT_R4;
3016         variant->fltVal = 3.14;
3017
3018         return 0;
3019 }
3020
3021 LIBTEST_API int STDCALL
3022 mono_test_marshal_variant_out_float_byref(VARIANT* variant)
3023 {
3024         variant->vt = VT_R4|VT_BYREF;
3025         variant->byref = marshal_alloc(4);
3026         *((float*)variant->byref) = 3.14;
3027
3028         return 0;
3029 }
3030
3031 LIBTEST_API int STDCALL
3032 mono_test_marshal_variant_out_double(VARIANT* variant)
3033 {
3034         variant->vt = VT_R8;
3035         variant->dblVal = 3.14;
3036
3037         return 0;
3038 }
3039
3040 LIBTEST_API int STDCALL
3041 mono_test_marshal_variant_out_double_byref(VARIANT* variant)
3042 {
3043         variant->vt = VT_R8|VT_BYREF;
3044         variant->byref = marshal_alloc(8);
3045         *((double*)variant->byref) = 3.14;
3046
3047         return 0;
3048 }
3049
3050 LIBTEST_API int STDCALL
3051 mono_test_marshal_variant_out_bstr(VARIANT* variant)
3052 {
3053         variant->vt = VT_BSTR;
3054         variant->bstrVal = marshal_bstr_alloc("PI");
3055
3056         return 0;
3057 }
3058
3059 LIBTEST_API int STDCALL
3060 mono_test_marshal_variant_out_bstr_byref(VARIANT* variant)
3061 {
3062         variant->vt = VT_BSTR|VT_BYREF;
3063         variant->byref = marshal_alloc(sizeof(gpointer));
3064         *((gunichar**)variant->byref) = (gunichar*)marshal_bstr_alloc("PI");
3065
3066         return 0;
3067 }
3068
3069 LIBTEST_API int STDCALL
3070 mono_test_marshal_variant_out_bool_true (VARIANT* variant)
3071 {
3072         variant->vt = VT_BOOL;
3073         variant->boolVal = VARIANT_TRUE;
3074
3075         return 0;
3076 }
3077
3078 LIBTEST_API int STDCALL
3079 mono_test_marshal_variant_out_bool_true_byref (VARIANT* variant)
3080 {
3081         variant->vt = VT_BOOL|VT_BYREF;
3082         variant->byref = marshal_alloc(2);
3083         *((gint16*)variant->byref) = VARIANT_TRUE;
3084
3085         return 0;
3086 }
3087
3088 LIBTEST_API int STDCALL
3089 mono_test_marshal_variant_out_bool_false (VARIANT* variant)
3090 {
3091         variant->vt = VT_BOOL;
3092         variant->boolVal = VARIANT_FALSE;
3093
3094         return 0;
3095 }
3096
3097 LIBTEST_API int STDCALL
3098 mono_test_marshal_variant_out_bool_false_byref (VARIANT* variant)
3099 {
3100         variant->vt = VT_BOOL|VT_BYREF;
3101         variant->byref = marshal_alloc(2);
3102         *((gint16*)variant->byref) = VARIANT_FALSE;
3103
3104         return 0;
3105 }
3106
3107 typedef int (STDCALL *VarFunc) (int vt, VARIANT variant);
3108 typedef int (STDCALL *VarRefFunc) (int vt, VARIANT* variant);
3109
3110 LIBTEST_API int STDCALL
3111 mono_test_marshal_variant_in_sbyte_unmanaged(VarFunc func)
3112 {
3113         VARIANT vt;
3114         vt.vt = VT_I1;
3115         vt.cVal = -100;
3116         return func (VT_I1, vt);
3117 }
3118
3119 LIBTEST_API int STDCALL
3120 mono_test_marshal_variant_in_byte_unmanaged(VarFunc func)
3121 {
3122         VARIANT vt;
3123         vt.vt = VT_UI1;
3124         vt.bVal = 100;
3125         return func (VT_UI1, vt);
3126 }
3127
3128 LIBTEST_API int STDCALL
3129 mono_test_marshal_variant_in_short_unmanaged(VarFunc func)
3130 {
3131         VARIANT vt;
3132         vt.vt = VT_I2;
3133         vt.iVal = -100;
3134         return func (VT_I2, vt);
3135 }
3136
3137 LIBTEST_API int STDCALL
3138 mono_test_marshal_variant_in_ushort_unmanaged(VarFunc func)
3139 {
3140         VARIANT vt;
3141         vt.vt = VT_UI2;
3142         vt.uiVal = 100;
3143         return func (VT_UI2, vt);
3144 }
3145
3146 LIBTEST_API int STDCALL
3147 mono_test_marshal_variant_in_int_unmanaged(VarFunc func)
3148 {
3149         VARIANT vt;
3150         vt.vt = VT_I4;
3151         vt.lVal = -100;
3152         return func (VT_I4, vt);
3153 }
3154
3155 LIBTEST_API int STDCALL
3156 mono_test_marshal_variant_in_uint_unmanaged(VarFunc func)
3157 {
3158         VARIANT vt;
3159         vt.vt = VT_UI4;
3160         vt.ulVal = 100;
3161         return func (VT_UI4, vt);
3162 }
3163
3164 LIBTEST_API int STDCALL
3165 mono_test_marshal_variant_in_long_unmanaged(VarFunc func)
3166 {
3167         VARIANT vt;
3168         vt.vt = VT_I8;
3169         vt.llVal = -100;
3170         return func (VT_I8, vt);
3171 }
3172
3173 LIBTEST_API int STDCALL
3174 mono_test_marshal_variant_in_ulong_unmanaged(VarFunc func)
3175 {
3176         VARIANT vt;
3177         vt.vt = VT_UI8;
3178         vt.ullVal = 100;
3179         return func (VT_UI8, vt);
3180 }
3181
3182 LIBTEST_API int STDCALL
3183 mono_test_marshal_variant_in_float_unmanaged(VarFunc func)
3184 {
3185         VARIANT vt;
3186         vt.vt = VT_R4;
3187         vt.fltVal = 3.14;
3188         return func (VT_R4, vt);
3189 }
3190
3191 LIBTEST_API int STDCALL
3192 mono_test_marshal_variant_in_double_unmanaged(VarFunc func)
3193 {
3194         VARIANT vt;
3195         vt.vt = VT_R8;
3196         vt.dblVal = 3.14;
3197         return func (VT_R8, vt);
3198 }
3199
3200 LIBTEST_API int STDCALL
3201 mono_test_marshal_variant_in_bstr_unmanaged(VarFunc func)
3202 {
3203         VARIANT vt;
3204         vt.vt = VT_BSTR;
3205         vt.bstrVal = marshal_bstr_alloc("PI");
3206         return func (VT_BSTR, vt);
3207 }
3208
3209 LIBTEST_API int STDCALL
3210 mono_test_marshal_variant_in_bool_true_unmanaged(VarFunc func)
3211 {
3212         VARIANT vt;
3213         vt.vt = VT_BOOL;
3214         vt.boolVal = VARIANT_TRUE;
3215         return func (VT_BOOL, vt);
3216 }
3217
3218 LIBTEST_API int STDCALL
3219 mono_test_marshal_variant_in_bool_false_unmanaged(VarFunc func)
3220 {
3221         VARIANT vt;
3222         vt.vt = VT_BOOL;
3223         vt.boolVal = VARIANT_FALSE;
3224         return func (VT_BOOL, vt);
3225 }
3226
3227 LIBTEST_API int STDCALL
3228 mono_test_marshal_variant_out_sbyte_unmanaged(VarRefFunc func)
3229 {
3230         VARIANT vt;
3231         VariantInit (&vt);
3232         func (VT_I1, &vt);
3233         if (vt.vt == VT_I1 && vt.cVal == -100)
3234                 return 0;
3235         return 1;
3236 }
3237
3238 LIBTEST_API int STDCALL
3239 mono_test_marshal_variant_out_byte_unmanaged(VarRefFunc func)
3240 {
3241         VARIANT vt;
3242         VariantInit (&vt);
3243         func (VT_UI1, &vt);
3244         if (vt.vt == VT_UI1 && vt.bVal == 100)
3245                 return 0;
3246         return 1;
3247 }
3248
3249 LIBTEST_API int STDCALL
3250 mono_test_marshal_variant_out_short_unmanaged(VarRefFunc func)
3251 {
3252         VARIANT vt;
3253         VariantInit (&vt);
3254         func (VT_I2, &vt);
3255         if (vt.vt == VT_I2 && vt.iVal == -100)
3256                 return 0;
3257         return 1;
3258 }
3259
3260 LIBTEST_API int STDCALL
3261 mono_test_marshal_variant_out_ushort_unmanaged(VarRefFunc func)
3262 {
3263         VARIANT vt;
3264         VariantInit (&vt);
3265         func (VT_UI2, &vt);
3266         if (vt.vt == VT_UI2 && vt.uiVal == 100)
3267                 return 0;
3268         return 1;
3269 }
3270
3271 LIBTEST_API int STDCALL
3272 mono_test_marshal_variant_out_int_unmanaged(VarRefFunc func)
3273 {
3274         VARIANT vt;
3275         VariantInit (&vt);
3276         func (VT_I4, &vt);
3277         if (vt.vt == VT_I4 && vt.lVal == -100)
3278                 return 0;
3279         return 1;
3280 }
3281
3282 LIBTEST_API int STDCALL
3283 mono_test_marshal_variant_out_uint_unmanaged(VarRefFunc func)
3284 {
3285         VARIANT vt;
3286         VariantInit (&vt);
3287         func (VT_UI4, &vt);
3288         if (vt.vt == VT_UI4 && vt.ulVal == 100)
3289                 return 0;
3290         return 1;
3291 }
3292
3293 LIBTEST_API int STDCALL
3294 mono_test_marshal_variant_out_long_unmanaged(VarRefFunc func)
3295 {
3296         VARIANT vt;
3297         VariantInit (&vt);
3298         func (VT_I8, &vt);
3299         if (vt.vt == VT_I8 && vt.llVal == -100)
3300                 return 0;
3301         return 1;
3302 }
3303
3304 LIBTEST_API int STDCALL
3305 mono_test_marshal_variant_out_ulong_unmanaged(VarRefFunc func)
3306 {
3307         VARIANT vt;
3308         VariantInit (&vt);
3309         func (VT_UI8, &vt);
3310         if (vt.vt == VT_UI8 && vt.ullVal == 100)
3311                 return 0;
3312         return 1;
3313 }
3314
3315 LIBTEST_API int STDCALL
3316 mono_test_marshal_variant_out_float_unmanaged(VarRefFunc func)
3317 {
3318         VARIANT vt;
3319         VariantInit (&vt);
3320         func (VT_R4, &vt);
3321         if (vt.vt == VT_R4 && fabs (vt.fltVal - 3.14f) < 1e-10)
3322                 return 0;
3323         return 1;
3324 }
3325
3326 LIBTEST_API int STDCALL
3327 mono_test_marshal_variant_out_double_unmanaged(VarRefFunc func)
3328 {
3329         VARIANT vt;
3330         VariantInit (&vt);
3331         func (VT_R8, &vt);
3332         if (vt.vt == VT_R8 && fabs (vt.dblVal - 3.14) < 1e-10)
3333                 return 0;
3334         return 1;
3335 }
3336
3337 LIBTEST_API int STDCALL
3338 mono_test_marshal_variant_out_bstr_unmanaged(VarRefFunc func)
3339 {
3340         VARIANT vt;
3341         gchar* bstr_utf8;
3342         gint32 result = 0;
3343
3344
3345         VariantInit (&vt);
3346         func (VT_BSTR, &vt);
3347         bstr_utf8 = g_utf16_to_utf8 (vt.bstrVal, -1, NULL, NULL, NULL);
3348         result = strcmp("PI", bstr_utf8);
3349         g_free(bstr_utf8);
3350         if (vt.vt == VT_BSTR && !result)
3351                 return 0;
3352         return 1;
3353 }
3354
3355 LIBTEST_API int STDCALL
3356 mono_test_marshal_variant_out_bool_true_unmanaged(VarRefFunc func)
3357 {
3358         VARIANT vt;
3359         VariantInit (&vt);
3360         func (VT_BOOL, &vt);
3361         if (vt.vt == VT_BOOL && vt.boolVal == VARIANT_TRUE)
3362                 return 0;
3363         return 1;
3364 }
3365
3366 LIBTEST_API int STDCALL
3367 mono_test_marshal_variant_out_bool_false_unmanaged(VarRefFunc func)
3368 {
3369         VARIANT vt;
3370         VariantInit (&vt);
3371         func (VT_BOOL, &vt);
3372         if (vt.vt == VT_BOOL && vt.boolVal == VARIANT_TRUE)
3373                 return 0;
3374         return 1;
3375 }
3376
3377 typedef struct MonoComObject MonoComObject;
3378 typedef struct MonoDefItfObject MonoDefItfObject;
3379
3380 typedef struct
3381 {
3382         int (STDCALL *QueryInterface)(MonoDefItfObject* pUnk, gpointer riid, gpointer* ppv);
3383         int (STDCALL *AddRef)(MonoDefItfObject* pUnk);
3384         int (STDCALL *Release)(MonoDefItfObject* pUnk);
3385         int (STDCALL *Method)(MonoDefItfObject* pUnk, int *value);
3386 } MonoDefItf;
3387
3388 typedef struct
3389 {
3390         int (STDCALL *QueryInterface)(MonoComObject* pUnk, gpointer riid, gpointer* ppv);
3391         int (STDCALL *AddRef)(MonoComObject* pUnk);
3392         int (STDCALL *Release)(MonoComObject* pUnk);
3393         int (STDCALL *get_ITest)(MonoComObject* pUnk, MonoComObject* *ppUnk);
3394         int (STDCALL *SByteIn)(MonoComObject* pUnk, char a);
3395         int (STDCALL *ByteIn)(MonoComObject* pUnk, unsigned char a);
3396         int (STDCALL *ShortIn)(MonoComObject* pUnk, short a);
3397         int (STDCALL *UShortIn)(MonoComObject* pUnk, unsigned short a);
3398         int (STDCALL *IntIn)(MonoComObject* pUnk, int a);
3399         int (STDCALL *UIntIn)(MonoComObject* pUnk, unsigned int a);
3400         int (STDCALL *LongIn)(MonoComObject* pUnk, gint64 a);
3401         int (STDCALL *ULongIn)(MonoComObject* pUnk, guint64 a);
3402         int (STDCALL *FloatIn)(MonoComObject* pUnk, float a);
3403         int (STDCALL *DoubleIn)(MonoComObject* pUnk, double a);
3404         int (STDCALL *ITestIn)(MonoComObject* pUnk, MonoComObject* pUnk2);
3405         int (STDCALL *ITestOut)(MonoComObject* pUnk, MonoComObject* *ppUnk);
3406         int (STDCALL *Return22NoICall)(MonoComObject* pUnk);
3407         int (STDCALL *IntOut)(MonoComObject* pUnk, int *a);
3408         int (STDCALL *ArrayIn)(MonoComObject* pUnk, void *array);
3409         int (STDCALL *ArrayIn2)(MonoComObject* pUnk, void *array);
3410         int (STDCALL *ArrayIn3)(MonoComObject* pUnk, void *array);
3411         int (STDCALL *GetDefInterface1)(MonoComObject* pUnk, MonoDefItfObject **iface);
3412         int (STDCALL *GetDefInterface2)(MonoComObject* pUnk, MonoDefItfObject **iface);
3413 } MonoIUnknown;
3414
3415 struct MonoComObject
3416 {
3417         MonoIUnknown* vtbl;
3418         int m_ref;
3419 };
3420
3421 struct MonoDefItfObject
3422 {
3423         MonoDefItf* vtbl;
3424 };
3425
3426 static GUID IID_ITest = {0, 0, 0, {0,0,0,0,0,0,0,1}};
3427 static GUID IID_IMonoUnknown = {0, 0, 0, {0xc0,0,0,0,0,0,0,0x46}};
3428 static GUID IID_IMonoDispatch = {0x00020400, 0, 0, {0xc0,0,0,0,0,0,0,0x46}};
3429 static GUID IID_INotImplemented = {0x12345678, 0, 0, {0x9a, 0xbc, 0xde, 0xf0, 0, 0, 0, 0}};
3430
3431 LIBTEST_API int STDCALL
3432 MonoQueryInterface(MonoComObject* pUnk, gpointer riid, gpointer* ppv)
3433 {
3434
3435         *ppv = NULL;
3436         if (!memcmp(riid, &IID_IMonoUnknown, sizeof(GUID))) {
3437                 *ppv = pUnk;
3438                 return S_OK;
3439         }
3440         else if (!memcmp(riid, &IID_ITest, sizeof(GUID))) {
3441                 *ppv = pUnk;
3442                 return S_OK;
3443         }
3444         else if (!memcmp(riid, &IID_IMonoDispatch, sizeof(GUID))) {
3445                 *ppv = pUnk;
3446                 return S_OK;
3447         }
3448         return 0x80004002; //E_NOINTERFACE;
3449 }
3450
3451 LIBTEST_API int STDCALL
3452 MonoAddRef(MonoComObject* pUnk)
3453 {
3454         return ++(pUnk->m_ref);
3455 }
3456
3457 LIBTEST_API int STDCALL
3458 MonoRelease(MonoComObject* pUnk)
3459 {
3460         return --(pUnk->m_ref);
3461 }
3462
3463 LIBTEST_API int STDCALL
3464 SByteIn(MonoComObject* pUnk, char a)
3465 {
3466         return S_OK;
3467 }
3468
3469 LIBTEST_API int STDCALL
3470 ByteIn(MonoComObject* pUnk, unsigned char a)
3471 {
3472         return S_OK;
3473 }
3474
3475 LIBTEST_API int STDCALL
3476 ShortIn(MonoComObject* pUnk, short a)
3477 {
3478         return S_OK;
3479 }
3480
3481 LIBTEST_API int STDCALL
3482 UShortIn(MonoComObject* pUnk, unsigned short a)
3483 {
3484         return S_OK;
3485 }
3486
3487 LIBTEST_API int STDCALL
3488 IntIn(MonoComObject* pUnk, int a)
3489 {
3490         return S_OK;
3491 }
3492
3493 LIBTEST_API int STDCALL
3494 UIntIn(MonoComObject* pUnk, unsigned int a)
3495 {
3496         return S_OK;
3497 }
3498
3499 LIBTEST_API int STDCALL
3500 LongIn(MonoComObject* pUnk, gint64 a)
3501 {
3502         return S_OK;
3503 }
3504
3505 LIBTEST_API int STDCALL
3506 ULongIn(MonoComObject* pUnk, guint64 a)
3507 {
3508         return S_OK;
3509 }
3510
3511 LIBTEST_API int STDCALL
3512 FloatIn(MonoComObject* pUnk, float a)
3513 {
3514         return S_OK;
3515 }
3516
3517 LIBTEST_API int STDCALL
3518 DoubleIn(MonoComObject* pUnk, double a)
3519 {
3520         return S_OK;
3521 }
3522
3523 LIBTEST_API int STDCALL
3524 ITestIn(MonoComObject* pUnk, MonoComObject *pUnk2)
3525 {
3526         return S_OK;
3527 }
3528
3529 LIBTEST_API int STDCALL
3530 ITestOut(MonoComObject* pUnk, MonoComObject* *ppUnk)
3531 {
3532         return S_OK;
3533 }
3534
3535 LIBTEST_API int STDCALL
3536 Return22NoICall(MonoComObject* pUnk)
3537 {
3538         return 22;
3539 }
3540
3541 LIBTEST_API int STDCALL
3542 IntOut(MonoComObject* pUnk, int *a)
3543 {
3544         return S_OK;
3545 }
3546
3547 LIBTEST_API int STDCALL
3548 ArrayIn(MonoComObject* pUnk, void *array)
3549 {
3550         return S_OK;
3551 }
3552
3553 LIBTEST_API int STDCALL
3554 ArrayIn2(MonoComObject* pUnk, void *array)
3555 {
3556         return S_OK;
3557 }
3558
3559 LIBTEST_API int STDCALL
3560 ArrayIn3(MonoComObject* pUnk, void *array)
3561 {
3562         return S_OK;
3563 }
3564
3565 LIBTEST_API int STDCALL
3566 GetDefInterface1(MonoComObject* pUnk, MonoDefItfObject **obj)
3567 {
3568         return S_OK;
3569 }
3570
3571 LIBTEST_API int STDCALL
3572 GetDefInterface2(MonoComObject* pUnk, MonoDefItfObject **obj)
3573 {
3574         return S_OK;
3575 }
3576
3577 static void create_com_object (MonoComObject** pOut);
3578
3579 LIBTEST_API int STDCALL
3580 get_ITest(MonoComObject* pUnk, MonoComObject* *ppUnk)
3581 {
3582         create_com_object (ppUnk);
3583         return S_OK;
3584 }
3585
3586 static void create_com_object (MonoComObject** pOut)
3587 {
3588         *pOut = marshal_new0 (MonoComObject, 1);
3589         (*pOut)->vtbl = marshal_new0 (MonoIUnknown, 1);
3590
3591         (*pOut)->m_ref = 1;
3592         (*pOut)->vtbl->QueryInterface = MonoQueryInterface;
3593         (*pOut)->vtbl->AddRef = MonoAddRef;
3594         (*pOut)->vtbl->Release = MonoRelease;
3595         (*pOut)->vtbl->SByteIn = SByteIn;
3596         (*pOut)->vtbl->ByteIn = ByteIn;
3597         (*pOut)->vtbl->ShortIn = ShortIn;
3598         (*pOut)->vtbl->UShortIn = UShortIn;
3599         (*pOut)->vtbl->IntIn = IntIn;
3600         (*pOut)->vtbl->UIntIn = UIntIn;
3601         (*pOut)->vtbl->LongIn = LongIn;
3602         (*pOut)->vtbl->ULongIn = ULongIn;
3603         (*pOut)->vtbl->FloatIn = FloatIn;
3604         (*pOut)->vtbl->DoubleIn = DoubleIn;
3605         (*pOut)->vtbl->ITestIn = ITestIn;
3606         (*pOut)->vtbl->ITestOut = ITestOut;
3607         (*pOut)->vtbl->get_ITest = get_ITest;
3608         (*pOut)->vtbl->Return22NoICall = Return22NoICall;
3609         (*pOut)->vtbl->IntOut = IntOut;
3610         (*pOut)->vtbl->ArrayIn = ArrayIn;
3611         (*pOut)->vtbl->ArrayIn2 = ArrayIn2;
3612         (*pOut)->vtbl->ArrayIn3 = ArrayIn3;
3613         (*pOut)->vtbl->GetDefInterface1 = GetDefInterface1;
3614         (*pOut)->vtbl->GetDefInterface2 = GetDefInterface2;
3615 }
3616
3617 static MonoComObject* same_object = NULL;
3618
3619 LIBTEST_API int STDCALL
3620 mono_test_marshal_com_object_create(MonoComObject* *pUnk)
3621 {
3622         create_com_object (pUnk);
3623
3624         if (!same_object)
3625                 same_object = *pUnk;
3626
3627         return 0;
3628 }
3629
3630 LIBTEST_API int STDCALL
3631 mono_test_marshal_com_object_same(MonoComObject* *pUnk)
3632 {
3633         *pUnk = same_object;
3634
3635         return 0;
3636 }
3637
3638 LIBTEST_API int STDCALL
3639 mono_test_marshal_com_object_destroy(MonoComObject *pUnk)
3640 {
3641         int ref = --(pUnk->m_ref);
3642         g_free(pUnk->vtbl);
3643         g_free(pUnk);
3644
3645         return ref;
3646 }
3647
3648 LIBTEST_API int STDCALL
3649 mono_test_marshal_com_object_ref_count(MonoComObject *pUnk)
3650 {
3651         return pUnk->m_ref;
3652 }
3653
3654 LIBTEST_API int STDCALL
3655 mono_test_marshal_ccw_itest (MonoComObject *pUnk)
3656 {
3657         int hr = 0;
3658         MonoComObject* pTest;
3659
3660         if (!pUnk)
3661                 return 1;
3662
3663         hr = pUnk->vtbl->SByteIn (pUnk, -100);
3664         if (hr != 0)
3665                 return 2;
3666         hr = pUnk->vtbl->ByteIn (pUnk, 100);
3667         if (hr != 0)
3668                 return 3;
3669         hr = pUnk->vtbl->ShortIn (pUnk, -100);
3670         if (hr != 0)
3671                 return 4;
3672         hr = pUnk->vtbl->UShortIn (pUnk, 100);
3673         if (hr != 0)
3674                 return 5;
3675         hr = pUnk->vtbl->IntIn (pUnk, -100);
3676         if (hr != 0)
3677                 return 6;
3678         hr = pUnk->vtbl->UIntIn (pUnk, 100);
3679         if (hr != 0)
3680                 return 7;
3681         hr = pUnk->vtbl->LongIn (pUnk, -100);
3682         if (hr != 0)
3683                 return 8;
3684         hr = pUnk->vtbl->ULongIn (pUnk, 100);
3685         if (hr != 0)
3686                 return 9;
3687         hr = pUnk->vtbl->FloatIn (pUnk, 3.14f);
3688         if (hr != 0)
3689                 return 10;
3690         hr = pUnk->vtbl->DoubleIn (pUnk, 3.14);
3691         if (hr != 0)
3692                 return 11;
3693         hr = pUnk->vtbl->ITestIn (pUnk, pUnk);
3694         if (hr != 0)
3695                 return 12;
3696         hr = pUnk->vtbl->ITestOut (pUnk, &pTest);
3697         if (hr != 0)
3698                 return 13;
3699
3700         return 0;
3701 }
3702
3703 // Xamarin-47560
3704 LIBTEST_API int STDCALL
3705 mono_test_marshal_array_ccw_itest (int count, MonoComObject ** ppUnk)
3706 {
3707         int hr = 0;
3708
3709         if (!ppUnk)
3710                 return 1;
3711
3712         if (count < 1)
3713                 return 2;
3714
3715         if (!ppUnk[0])
3716                 return 3;
3717
3718         hr = ppUnk[0]->vtbl->SByteIn (ppUnk[0], -100);
3719         if (hr != 0)
3720                 return 4;
3721
3722         return 0;
3723 }
3724
3725 LIBTEST_API int STDCALL
3726 mono_test_marshal_retval_ccw_itest (MonoComObject *pUnk, int test_null)
3727 {
3728         int hr = 0, i = 0;
3729
3730         if (!pUnk)
3731                 return 1;
3732
3733         hr = pUnk->vtbl->IntOut (pUnk, &i);
3734         if (hr != 0)
3735                 return 2;
3736         if (i != 33)
3737                 return 3;
3738         if (test_null)
3739         {
3740                 hr = pUnk->vtbl->IntOut (pUnk, NULL);
3741                 if (hr != 0)
3742                         return 4;
3743         }
3744
3745         return 0;
3746 }
3747
3748 LIBTEST_API int STDCALL
3749 mono_test_default_interface_ccw (MonoComObject *pUnk)
3750 {
3751         MonoDefItfObject *obj;
3752         int ret, value;
3753
3754         ret = pUnk->vtbl->GetDefInterface1(pUnk, &obj);
3755         if (ret)
3756                 return 1;
3757         value = 0;
3758
3759         ret = obj->vtbl->Method(obj, &value);
3760         obj->vtbl->Release(obj);
3761         if (ret)
3762                 return 2;
3763         if (value != 1)
3764                 return 3;
3765
3766         ret = pUnk->vtbl->GetDefInterface2(pUnk, &obj);
3767         if (ret)
3768                 return 4;
3769         ret = obj->vtbl->Method(obj, &value);
3770         obj->vtbl->Release(obj);
3771         if (ret)
3772                 return 5;
3773         if (value != 2)
3774                 return 6;
3775
3776         return 0;
3777 }
3778
3779 /*
3780  * mono_method_get_unmanaged_thunk tests
3781  */
3782
3783 #if defined(__GNUC__) && ((defined(__i386__) && (defined(__linux__) || defined (__APPLE__)) || defined (__FreeBSD__) || defined(__OpenBSD__)) || (defined(__ppc__) && defined(__APPLE__)))
3784 #define ALIGN(size) __attribute__ ((__aligned__(size)))
3785 #else
3786 #define ALIGN(size)
3787 #endif
3788
3789
3790 /* thunks.cs:TestStruct */
3791 typedef struct _TestStruct {
3792         int A;
3793         double B;
3794 } TestStruct;
3795
3796 /* Searches for mono symbols in all loaded modules */
3797 static gpointer
3798 lookup_mono_symbol (const char *symbol_name)
3799 {
3800         gpointer symbol = NULL;
3801         const gboolean success = g_module_symbol (g_module_open (NULL, G_MODULE_BIND_LAZY), symbol_name, &symbol);
3802         g_assertf (success, "%s", symbol_name);
3803         return success ? symbol : NULL;
3804 }
3805
3806 LIBTEST_API gpointer STDCALL
3807 mono_test_marshal_lookup_symbol (const char *symbol_name)
3808 {
3809         return lookup_mono_symbol (symbol_name);
3810 }
3811
3812
3813 // FIXME use runtime headers
3814 #define MONO_BEGIN_EFRAME { void *__dummy; void *__region_cookie = mono_threads_enter_gc_unsafe_region ? mono_threads_enter_gc_unsafe_region (&__dummy) : NULL;
3815 #define MONO_END_EFRAME if (mono_threads_exit_gc_unsafe_region) mono_threads_exit_gc_unsafe_region (__region_cookie, &__dummy); }
3816
3817 /**
3818  * test_method_thunk:
3819  *
3820  * @test_id: the test number
3821  * @test_method_handle: MonoMethod* of the C# test method
3822  * @create_object_method_handle: MonoMethod* of thunks.cs:Test.CreateObject
3823  */
3824 LIBTEST_API int STDCALL
3825 test_method_thunk (int test_id, gpointer test_method_handle, gpointer create_object_method_handle)
3826 {
3827         int ret = 0;
3828
3829         // FIXME use runtime headers
3830         gpointer (*mono_method_get_unmanaged_thunk)(gpointer)
3831                 = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_method_get_unmanaged_thunk");
3832
3833         // FIXME use runtime headers
3834         gpointer (*mono_string_new_wrapper)(const char *)
3835                 = (gpointer (*)(const char *))lookup_mono_symbol ("mono_string_new_wrapper");
3836
3837         // FIXME use runtime headers
3838         char *(*mono_string_to_utf8)(gpointer)
3839                 = (char *(*)(gpointer))lookup_mono_symbol ("mono_string_to_utf8");
3840
3841         // FIXME use runtime headers
3842         gpointer (*mono_object_unbox)(gpointer)
3843                 = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_object_unbox");
3844
3845         // FIXME use runtime headers
3846         gpointer (*mono_threads_enter_gc_unsafe_region) (gpointer)
3847                 = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_threads_enter_gc_unsafe_region");
3848
3849         // FIXME use runtime headers
3850         void (*mono_threads_exit_gc_unsafe_region) (gpointer, gpointer)
3851                 = (void (*)(gpointer, gpointer))lookup_mono_symbol ("mono_threads_exit_gc_unsafe_region");
3852
3853
3854
3855         gpointer test_method, ex = NULL;
3856         gpointer (STDCALL *CreateObject)(gpointer*);
3857
3858         MONO_BEGIN_EFRAME;
3859
3860         if (!mono_method_get_unmanaged_thunk) {
3861                 ret = 1;
3862                 goto done;
3863         }
3864
3865         test_method =  mono_method_get_unmanaged_thunk (test_method_handle);
3866         if (!test_method) {
3867                 ret = 2;
3868                 goto done;
3869         }
3870
3871         CreateObject = (gpointer (STDCALL *)(gpointer *))mono_method_get_unmanaged_thunk (create_object_method_handle);
3872         if (!CreateObject) {
3873                 ret = 3;
3874                 goto done;
3875         }
3876
3877
3878         switch (test_id) {
3879
3880         case 0: {
3881                 /* thunks.cs:Test.Test0 */
3882                 void (STDCALL *F)(gpointer *) = (void (STDCALL *)(gpointer *))test_method;
3883                 F (&ex);
3884                 break;
3885         }
3886
3887         case 1: {
3888                 /* thunks.cs:Test.Test1 */
3889                 int (STDCALL *F)(gpointer *) = (int (STDCALL *)(gpointer *))test_method;
3890                 if (F (&ex) != 42) {
3891                         ret = 4;
3892                         goto done;
3893                 }
3894                 break;
3895         }
3896
3897         case 2: {
3898                 /* thunks.cs:Test.Test2 */
3899                 gpointer (STDCALL *F)(gpointer, gpointer*) = (gpointer (STDCALL *)(gpointer, gpointer *))test_method;
3900                 gpointer str = mono_string_new_wrapper ("foo");
3901                 if (str != F (str, &ex)) {
3902                         ret = 4;
3903                         goto done;
3904                 }
3905                 break;
3906         }
3907
3908         case 3: {
3909                 /* thunks.cs:Test.Test3 */
3910                 gpointer (STDCALL *F)(gpointer, gpointer, gpointer*);
3911                 gpointer obj;
3912                 gpointer str;
3913
3914                 F = (gpointer (STDCALL *)(gpointer, gpointer, gpointer *))test_method;
3915                 obj = CreateObject (&ex);
3916                 str = mono_string_new_wrapper ("bar");
3917
3918                 if (str != F (obj, str, &ex)) {
3919                         ret = 4;
3920                         goto done;
3921                 }
3922                 break;
3923         }
3924
3925         case 4: {
3926                 /* thunks.cs:Test.Test4 */
3927                 int (STDCALL *F)(gpointer, gpointer, int, gpointer*);
3928                 gpointer obj;
3929                 gpointer str;
3930
3931                 F = (int (STDCALL *)(gpointer, gpointer, int, gpointer *))test_method;
3932                 obj = CreateObject (&ex);
3933                 str = mono_string_new_wrapper ("bar");
3934
3935                 if (42 != F (obj, str, 42, &ex)) {
3936                         ret = 4;
3937                         goto done;
3938                 }
3939
3940                 break;
3941         }
3942
3943         case 5: {
3944                 /* thunks.cs:Test.Test5 */
3945                 int (STDCALL *F)(gpointer, gpointer, int, gpointer*);
3946                 gpointer obj;
3947                 gpointer str;
3948
3949                 F = (int (STDCALL *)(gpointer, gpointer, int, gpointer *))test_method;
3950                 obj = CreateObject (&ex);
3951                 str = mono_string_new_wrapper ("bar");
3952
3953                 F (obj, str, 42, &ex);
3954                 if (!ex) {
3955                         ret = 4;
3956                         goto done;
3957                 }
3958
3959                 break;
3960         }
3961
3962         case 6: {
3963                 /* thunks.cs:Test.Test6 */
3964                 int (STDCALL *F)(gpointer, guint8, gint16, gint32, gint64, float, double,
3965                                  gpointer, gpointer*);
3966                 gpointer obj;
3967                 gpointer str = mono_string_new_wrapper ("Test6");
3968                 int res;
3969
3970                 F = (int (STDCALL *)(gpointer, guint8, gint16, gint32, gint64, float, double, gpointer, gpointer *))test_method;
3971                 obj = CreateObject (&ex);
3972
3973                 res = F (obj, 254, 32700, -245378, 6789600, 3.1415, 3.1415, str, &ex);
3974                 if (ex) {
3975                         ret = 4;
3976                         goto done;
3977                 }
3978
3979                 if (!res) {
3980                         ret = 5;
3981                         goto done;
3982                 }
3983
3984                 break;
3985         }
3986
3987         case 7: {
3988                 /* thunks.cs:Test.Test7 */
3989                 gint64 (STDCALL *F)(gpointer*) = (gint64 (STDCALL *)(gpointer *))test_method;
3990                 if (F (&ex) != G_MAXINT64) {
3991                         ret = 4;
3992                         goto done;
3993                 }
3994                 break;
3995         }
3996
3997         case 8: {
3998                 /* thunks.cs:Test.Test8 */
3999                 void (STDCALL *F)(guint8*, gint16*, gint32*, gint64*, float*, double*,
4000                                  gpointer*, gpointer*);
4001
4002                 guint8 a1;
4003                 gint16 a2;
4004                 gint32 a3;
4005                 gint64 a4;
4006                 float a5;
4007                 double a6;
4008                 gpointer a7;
4009
4010                 F = (void (STDCALL *)(guint8 *, gint16 *, gint32 *, gint64 *, float *, double *,
4011                         gpointer *, gpointer *))test_method;
4012
4013                 F (&a1, &a2, &a3, &a4, &a5, &a6, &a7, &ex);
4014                 if (ex) {
4015                         ret = 4;
4016                         goto done;
4017                 }
4018
4019                 if (!(a1 == 254 &&
4020                       a2 == 32700 &&
4021                       a3 == -245378 &&
4022                       a4 == 6789600 &&
4023                       (fabs (a5 - 3.1415) < 0.001) &&
4024                       (fabs (a6 - 3.1415) < 0.001) &&
4025                       strcmp (mono_string_to_utf8 (a7), "Test8") == 0)){
4026                                 ret = 5;
4027                                 goto done;
4028                         }
4029
4030                 break;
4031         }
4032
4033         case 9: {
4034                 /* thunks.cs:Test.Test9 */
4035                 void (STDCALL *F)(guint8*, gint16*, gint32*, gint64*, float*, double*,
4036                         gpointer*, gpointer*);
4037
4038                 guint8 a1;
4039                 gint16 a2;
4040                 gint32 a3;
4041                 gint64 a4;
4042                 float a5;
4043                 double a6;
4044                 gpointer a7;
4045
4046                 F = (void (STDCALL *)(guint8 *, gint16 *, gint32 *, gint64 *, float *, double *,
4047                         gpointer *, gpointer *))test_method;
4048
4049                 F (&a1, &a2, &a3, &a4, &a5, &a6, &a7, &ex);
4050                 if (!ex) {
4051                         ret = 4;
4052                         goto done;
4053                 }
4054
4055                 break;
4056         }
4057
4058         case 10: {
4059                 /* thunks.cs:Test.Test10 */
4060                 void (STDCALL *F)(gpointer*, gpointer*);
4061
4062                 gpointer obj1, obj2;
4063
4064                 obj1 = obj2 = CreateObject (&ex);
4065                 if (ex) {
4066                         ret = 4;
4067                         goto done;
4068                 }
4069
4070                 F = (void (STDCALL *)(gpointer *, gpointer *))test_method;
4071
4072                 F (&obj1, &ex);
4073                 if (ex) {
4074                         ret = 5;
4075                         goto done;
4076                 }
4077
4078                 if (obj1 == obj2) {
4079                         ret = 6;
4080                         goto done;
4081                 }
4082
4083                 break;
4084         }
4085
4086         case 100: {
4087                 /* thunks.cs:TestStruct.Test0 */
4088                 int (STDCALL *F)(gpointer*, gpointer*);
4089
4090                 gpointer obj;
4091                 TestStruct *a1;
4092                 int res;
4093
4094                 obj = CreateObject (&ex);
4095                 if (ex) {
4096                         ret = 4;
4097                         goto done;
4098                 }
4099
4100                 if (!obj) {
4101                         ret = 5;
4102                         goto done;
4103                 }
4104
4105                 a1 = (TestStruct *)mono_object_unbox (obj);
4106                 if (!a1) {
4107                         ret = 6;
4108                         goto done;
4109                 }
4110
4111                 a1->A = 42;
4112                 a1->B = 3.1415;
4113
4114                 F = (int (STDCALL *)(gpointer *, gpointer *))test_method;
4115
4116                 res = F ((gpointer *)obj, &ex);
4117                 if (ex) {
4118                         ret = 7;
4119                         goto done;
4120                 }
4121
4122                 if (!res) {
4123                         ret = 8;
4124                         goto done;
4125                 }
4126
4127                 /* check whether the call was really by value */
4128                 if (a1->A != 42 || a1->B != 3.1415) {
4129                         ret = 9;
4130                         goto done;
4131                 }
4132
4133                 break;
4134         }
4135
4136         case 101: {
4137                 /* thunks.cs:TestStruct.Test1 */
4138                 void (STDCALL *F)(gpointer, gpointer*);
4139
4140                 TestStruct *a1;
4141                 gpointer obj;
4142
4143                 obj = CreateObject (&ex);
4144                 if (ex) {
4145                         ret = 4;
4146                         goto done;
4147                 }
4148
4149                 if (!obj) {
4150                         ret = 5;
4151                         goto done;
4152                 }
4153
4154                 a1 = (TestStruct *)mono_object_unbox (obj);
4155                 if (!a1) {
4156                         ret = 6;
4157                         goto done;
4158                 }
4159
4160                 F = (void (STDCALL *)(gpointer, gpointer *))test_method;
4161
4162                 F (obj, &ex);
4163                 if (ex) {
4164                         ret = 7;
4165                         goto done;
4166                 }
4167
4168                 if (a1->A != 42) {
4169                         ret = 8;
4170                         goto done;
4171                 }
4172
4173                 if (!(fabs (a1->B - 3.1415) < 0.001)) {
4174                         ret = 9;
4175                         goto done;
4176                 }
4177
4178                 break;
4179         }
4180
4181         case 102: {
4182                 /* thunks.cs:TestStruct.Test2 */
4183                 gpointer (STDCALL *F)(gpointer*);
4184
4185                 TestStruct *a1;
4186                 gpointer obj;
4187
4188                 F = (gpointer (STDCALL *)(gpointer *))test_method;
4189
4190                 obj = F (&ex);
4191                 if (ex) {
4192                         ret = 4;
4193                         goto done;
4194                 }
4195
4196                 if (!obj) {
4197                         ret = 5;
4198                         goto done;
4199                 }
4200
4201                 a1 = (TestStruct *)mono_object_unbox (obj);
4202
4203                 if (a1->A != 42) {
4204                         ret = 5;
4205                         goto done;
4206                 }
4207
4208                 if (!(fabs (a1->B - 3.1415) < 0.001)) {
4209                         ret = 6;
4210                         goto done;
4211                 }
4212
4213                 break;
4214         }
4215
4216         case 103: {
4217                 /* thunks.cs:TestStruct.Test3 */
4218                 void (STDCALL *F)(gpointer, gpointer*);
4219
4220                 TestStruct *a1;
4221                 gpointer obj;
4222
4223                 obj = CreateObject (&ex);
4224                 if (ex) {
4225                         ret = 4;
4226                         goto done;
4227                 }
4228
4229                 if (!obj) {
4230                         ret = 5;
4231                         goto done;
4232                 }
4233
4234                 a1 = (TestStruct *)mono_object_unbox (obj);
4235
4236                 if (!a1) {
4237                         ret = 6;
4238                         goto done;
4239                 }
4240
4241                 a1->A = 42;
4242                 a1->B = 3.1415;
4243
4244                 F = (void (STDCALL *)(gpointer, gpointer *))test_method;
4245
4246                 F (obj, &ex);
4247                 if (ex) {
4248                         ret = 4;
4249                         goto done;
4250                 }
4251
4252                 if (a1->A != 1) {
4253                         ret = 5;
4254                         goto done;
4255                 }
4256
4257                 if (a1->B != 17) {
4258                         ret = 6;
4259                         goto done;
4260                 }
4261
4262                 break;
4263         }
4264
4265         default:
4266                 ret = 9;
4267
4268         }
4269 done:
4270         MONO_END_EFRAME;
4271
4272         return ret;
4273 }
4274
4275 typedef struct
4276 {
4277         char a;
4278 } winx64_struct1;
4279
4280 LIBTEST_API int STDCALL
4281 mono_test_Winx64_struct1_in (winx64_struct1 var)
4282 {
4283         if (var.a != 123)
4284                 return 1;
4285         return 0;
4286 }
4287
4288 typedef struct
4289 {
4290         char a;
4291         char b;
4292 } winx64_struct2;
4293
4294 LIBTEST_API int STDCALL
4295 mono_test_Winx64_struct2_in (winx64_struct2 var)
4296 {
4297         if (var.a != 4)
4298                 return 1;
4299         if (var.b != 5)
4300                 return 2;
4301         return 0;
4302 }
4303
4304
4305 typedef struct
4306 {
4307         char a;
4308         char b;
4309         short c;
4310 } winx64_struct3;
4311
4312 LIBTEST_API int STDCALL
4313 mono_test_Winx64_struct3_in (winx64_struct3 var)
4314 {
4315         if (var.a != 4)
4316                 return 1;
4317         if (var.b != 5)
4318                 return 2;
4319         if (var.c != 0x1234)
4320                 return 3;
4321         return 0;
4322 }
4323
4324 typedef struct
4325 {
4326         char a;
4327         char b;
4328         short c;
4329         unsigned int d;
4330 } winx64_struct4;
4331
4332 LIBTEST_API int STDCALL
4333 mono_test_Winx64_struct4_in (winx64_struct4 var)
4334 {
4335         if (var.a != 4)
4336                 return 1;
4337         if (var.b != 5)
4338                 return 2;
4339         if (var.c != 0x1234)
4340                 return 3;
4341         if (var.d != 0x87654321)
4342                 return 4;
4343         return 0;
4344 }
4345
4346 typedef struct
4347 {
4348         char a;
4349         char b;
4350         char c;
4351 } winx64_struct5;
4352
4353 LIBTEST_API int STDCALL
4354 mono_test_Winx64_struct5_in (winx64_struct5 var)
4355 {
4356         if (var.a != 4)
4357                 return 1;
4358         if (var.b != 5)
4359                 return 2;
4360         if (var.c != 6)
4361                 return 3;
4362         return 0;
4363 }
4364
4365 typedef struct
4366 {
4367         winx64_struct1 a;
4368         short b;
4369         char c;
4370 } winx64_struct6;
4371
4372 LIBTEST_API int STDCALL
4373 mono_test_Winx64_struct6_in (winx64_struct6 var)
4374 {
4375         if (var.a.a != 4)
4376                 return 1;
4377         if (var.b != 5)
4378                 return 2;
4379         if (var.c != 6)
4380                 return 3;
4381         return 0;
4382 }
4383
4384 LIBTEST_API int STDCALL
4385 mono_test_Winx64_structs_in1 (winx64_struct1 var1,
4386                          winx64_struct2 var2,
4387                          winx64_struct3 var3,
4388                          winx64_struct4 var4)
4389 {
4390         if (var1.a != 123)
4391                 return 1;
4392
4393         if (var2.a != 4)
4394                 return 2;
4395         if (var2.b != 5)
4396                 return 3;
4397
4398         if (var3.a != 4)
4399                 return 4;
4400         if (var3.b != 5)
4401                 return 2;
4402         if (var3.c != 0x1234)
4403                 return 5;
4404
4405         if (var4.a != 4)
4406                 return 6;
4407         if (var4.b != 5)
4408                 return 7;
4409         if (var4.c != 0x1234)
4410                 return 8;
4411         if (var4.d != 0x87654321)
4412                 return 9;
4413         return 0;
4414 }
4415
4416 LIBTEST_API int STDCALL
4417 mono_test_Winx64_structs_in2 (winx64_struct1 var1,
4418                          winx64_struct1 var2,
4419                          winx64_struct1 var3,
4420                          winx64_struct1 var4,
4421                          winx64_struct1 var5)
4422 {
4423         if (var1.a != 1)
4424                 return 1;
4425         if (var2.a != 2)
4426                 return 2;
4427         if (var3.a != 3)
4428                 return 3;
4429         if (var4.a != 4)
4430                 return 4;
4431         if (var5.a != 5)
4432                 return 5;
4433
4434         return 0;
4435 }
4436
4437 LIBTEST_API int STDCALL
4438 mono_test_Winx64_structs_in3 (winx64_struct1 var1,
4439                          winx64_struct5 var2,
4440                          winx64_struct1 var3,
4441                          winx64_struct5 var4,
4442                          winx64_struct1 var5,
4443                          winx64_struct5 var6)
4444 {
4445         if (var1.a != 1)
4446                 return 1;
4447
4448         if (var2.a != 2)
4449                 return 2;
4450         if (var2.b != 3)
4451                 return 2;
4452         if (var2.c != 4)
4453                 return 4;
4454
4455         if (var3.a != 5)
4456                 return 5;
4457
4458         if (var4.a != 6)
4459                 return 6;
4460         if (var4.b != 7)
4461                 return 7;
4462         if (var4.c != 8)
4463                 return 8;
4464
4465         if (var5.a != 9)
4466                 return 9;
4467
4468         if (var6.a != 10)
4469                 return 10;
4470         if (var6.b != 11)
4471                 return 11;
4472         if (var6.c != 12)
4473                 return 12;
4474
4475         return 0;
4476 }
4477
4478 LIBTEST_API winx64_struct1 STDCALL
4479 mono_test_Winx64_struct1_ret (void)
4480 {
4481         winx64_struct1 ret;
4482         ret.a = 123;
4483         return ret;
4484 }
4485
4486 LIBTEST_API winx64_struct2 STDCALL
4487 mono_test_Winx64_struct2_ret (void)
4488 {
4489         winx64_struct2 ret;
4490         ret.a = 4;
4491         ret.b = 5;
4492         return ret;
4493 }
4494
4495 LIBTEST_API winx64_struct3 STDCALL
4496 mono_test_Winx64_struct3_ret (void)
4497 {
4498         winx64_struct3 ret;
4499         ret.a = 4;
4500         ret.b = 5;
4501         ret.c = 0x1234;
4502         return ret;
4503 }
4504
4505 LIBTEST_API winx64_struct4 STDCALL
4506 mono_test_Winx64_struct4_ret (void)
4507 {
4508         winx64_struct4 ret;
4509         ret.a = 4;
4510         ret.b = 5;
4511         ret.c = 0x1234;
4512         ret.d = 0x87654321;
4513         return ret;
4514 }
4515
4516 LIBTEST_API winx64_struct5 STDCALL
4517 mono_test_Winx64_struct5_ret (void)
4518 {
4519         winx64_struct5 ret;
4520         ret.a = 4;
4521         ret.b = 5;
4522         ret.c = 6;
4523         return ret;
4524 }
4525
4526 LIBTEST_API winx64_struct1 STDCALL
4527 mono_test_Winx64_struct1_ret_5_args (char a, char b, char c, char d, char e)
4528 {
4529         winx64_struct1 ret;
4530         ret.a = a + b + c + d + e;
4531         return ret;
4532 }
4533
4534 LIBTEST_API winx64_struct5 STDCALL
4535 mono_test_Winx64_struct5_ret6_args (char a, char b, char c, char d, char e)
4536 {
4537         winx64_struct5 ret;
4538         ret.a = a + b;
4539         ret.b = c + d;
4540         ret.c = e;
4541         return ret;
4542 }
4543
4544 typedef struct
4545 {
4546         float a;
4547         float b;
4548 } winx64_floatStruct;
4549
4550 LIBTEST_API int STDCALL
4551 mono_test_Winx64_floatStruct (winx64_floatStruct a)
4552 {
4553         if (a.a > 5.6 || a.a < 5.4)
4554                 return 1;
4555
4556         if (a.b > 9.6 || a.b < 9.4)
4557                 return 2;
4558
4559         return 0;
4560 }
4561
4562 typedef struct
4563 {
4564         double a;
4565 } winx64_doubleStruct;
4566
4567 LIBTEST_API int STDCALL
4568 mono_test_Winx64_doubleStruct (winx64_doubleStruct a)
4569 {
4570         if (a.a > 5.6 || a.a < 5.4)
4571                 return 1;
4572
4573         return 0;
4574 }
4575
4576 typedef int (STDCALL *managed_struct1_delegate) (winx64_struct1 a);
4577
4578 LIBTEST_API int STDCALL
4579 mono_test_managed_Winx64_struct1_in(managed_struct1_delegate func)
4580 {
4581         winx64_struct1 val;
4582         val.a = 5;
4583         return func (val);
4584 }
4585
4586 typedef int (STDCALL *managed_struct5_delegate) (winx64_struct5 a);
4587
4588 LIBTEST_API int STDCALL
4589 mono_test_managed_Winx64_struct5_in(managed_struct5_delegate func)
4590 {
4591         winx64_struct5 val;
4592         val.a = 5;
4593         val.b = 0x10;
4594         val.c = (char)0x99;
4595         return func (val);
4596 }
4597
4598 typedef int (STDCALL *managed_struct1_struct5_delegate) (winx64_struct1 a, winx64_struct5 b,
4599                                                          winx64_struct1 c, winx64_struct5 d,
4600                                                          winx64_struct1 e, winx64_struct5 f);
4601
4602 LIBTEST_API int STDCALL
4603 mono_test_managed_Winx64_struct1_struct5_in(managed_struct1_struct5_delegate func)
4604 {
4605         winx64_struct1 a, c, e;
4606         winx64_struct5 b, d, f;
4607         a.a = 1;
4608         b.a = 2; b.b = 3; b.c = 4;
4609         c.a = 5;
4610         d.a = 6; d.b = 7; d.c = 8;
4611         e.a = 9;
4612         f.a = 10; f.b = 11; f.c = 12;
4613
4614         return func (a, b, c, d, e, f);
4615 }
4616
4617 typedef winx64_struct1 (STDCALL *managed_struct1_ret_delegate) (void);
4618
4619 LIBTEST_API int STDCALL
4620 mono_test_Winx64_struct1_ret_managed (managed_struct1_ret_delegate func)
4621 {
4622         winx64_struct1 ret;
4623
4624         ret = func ();
4625
4626         if (ret.a != 0x45)
4627                 return 1;
4628
4629         return 0;
4630 }
4631
4632 typedef winx64_struct5 (STDCALL *managed_struct5_ret_delegate) (void);
4633
4634 LIBTEST_API int STDCALL
4635 mono_test_Winx64_struct5_ret_managed (managed_struct5_ret_delegate func)
4636 {
4637         winx64_struct5 ret;
4638
4639         ret = func ();
4640
4641         if (ret.a != 0x12)
4642                 return 1;
4643         if (ret.b != 0x34)
4644                 return 2;
4645         if (ret.c != 0x56)
4646                 return 3;
4647
4648         return 0;
4649 }
4650
4651 LIBTEST_API int STDCALL
4652 mono_test_marshal_bool_in (int arg, unsigned int expected, unsigned int bDefaultMarsh, unsigned int bBoolCustMarsh,
4653                            char bI1CustMarsh, unsigned char bU1CustMarsh, short bVBCustMarsh)
4654 {
4655         switch (arg) {
4656         case 1:
4657                 if (bDefaultMarsh != expected)
4658                         return 1;
4659                 break;
4660         case 2:
4661                 if (bBoolCustMarsh != expected)
4662                         return 2;
4663                 break;
4664         case 3:
4665                 if (bI1CustMarsh != expected)
4666                         return 3;
4667                 break;
4668         case 4:
4669                 if (bU1CustMarsh != expected)
4670                         return 4;
4671                 break;
4672         case 5:
4673                 if (bVBCustMarsh != expected)
4674                         return 5;
4675                 break;
4676         default:
4677                 return 999;
4678         }
4679         return 0;
4680 }
4681
4682 LIBTEST_API int STDCALL
4683 mono_test_marshal_bool_out (int arg, unsigned int testVal, unsigned int* bDefaultMarsh, unsigned int* bBoolCustMarsh,
4684                            char* bI1CustMarsh, unsigned char* bU1CustMarsh, unsigned short* bVBCustMarsh)
4685 {
4686         switch (arg) {
4687         case 1:
4688                 if (!bDefaultMarsh)
4689                         return 1;
4690                 *bDefaultMarsh = testVal;
4691                 break;
4692         case 2:
4693                 if (!bBoolCustMarsh)
4694                         return 2;
4695                 *bBoolCustMarsh = testVal;
4696                 break;
4697         case 3:
4698                 if (!bI1CustMarsh)
4699                         return 3;
4700                 *bI1CustMarsh = (char)testVal;
4701                 break;
4702         case 4:
4703                 if (!bU1CustMarsh)
4704                         return 4;
4705                 *bU1CustMarsh = (unsigned char)testVal;
4706                 break;
4707         case 5:
4708                 if (!bVBCustMarsh)
4709                         return 5;
4710                 *bVBCustMarsh = (unsigned short)testVal;
4711                 break;
4712         default:
4713                 return 999;
4714         }
4715         return 0;
4716 }
4717
4718 LIBTEST_API int STDCALL
4719 mono_test_marshal_bool_ref (int arg, unsigned int expected, unsigned int testVal, unsigned int* bDefaultMarsh,
4720                             unsigned int* bBoolCustMarsh, char* bI1CustMarsh, unsigned char* bU1CustMarsh,
4721                             unsigned short* bVBCustMarsh)
4722 {
4723         switch (arg) {
4724         case 1:
4725                 if (!bDefaultMarsh)
4726                         return 1;
4727                 if (*bDefaultMarsh != expected)
4728                         return 2;
4729                 *bDefaultMarsh = testVal;
4730                 break;
4731         case 2:
4732                 if (!bBoolCustMarsh)
4733                         return 3;
4734                 if (*bBoolCustMarsh != expected)
4735                         return 4;
4736                 *bBoolCustMarsh = testVal;
4737                 break;
4738         case 3:
4739                 if (!bI1CustMarsh)
4740                         return 5;
4741                 if (*bI1CustMarsh != expected)
4742                         return 6;
4743                 *bI1CustMarsh = (char)testVal;
4744                 break;
4745         case 4:
4746                 if (!bU1CustMarsh)
4747                         return 7;
4748                 if (*bU1CustMarsh != expected)
4749                         return 8;
4750                 *bU1CustMarsh = (unsigned char)testVal;
4751                 break;
4752         case 5:
4753                 if (!bVBCustMarsh)
4754                         return 9;
4755                 if (*bVBCustMarsh != expected)
4756                         return 10;
4757                 *bVBCustMarsh = (unsigned short)testVal;
4758                 break;
4759         default:
4760                 return 999;
4761         }
4762         return 0;
4763 }
4764
4765
4766 typedef int (STDCALL *MarshalBoolInDelegate) (int arg, unsigned int expected, unsigned int bDefaultMarsh,
4767         unsigned int bBoolCustMarsh, char bI1CustMarsh, unsigned char bU1CustMarsh, unsigned short bVBCustMarsh);
4768
4769 LIBTEST_API int STDCALL
4770 mono_test_managed_marshal_bool_in (int arg, unsigned int expected, unsigned int testVal, MarshalBoolInDelegate pfcn)
4771 {
4772         if (!pfcn)
4773                 return 0x9900;
4774
4775         switch (arg) {
4776         case 1:
4777                 return pfcn (arg, expected, testVal, 0, 0, 0, 0);
4778         case 2:
4779                 return pfcn (arg, expected, 0, testVal,  0, 0, 0);
4780         case 3:
4781                 return pfcn (arg, expected, 0, 0, testVal, 0, 0);
4782         case 4:
4783                 return pfcn (arg, expected, 0, 0, 0, testVal, 0);
4784         case 5:
4785                 return pfcn (arg, expected, 0, 0, 0, 0, testVal);
4786         default:
4787                 return 0x9800;
4788         }
4789
4790         return 0;
4791 }
4792
4793 typedef int (STDCALL *MarshalBoolOutDelegate) (int arg, unsigned int expected, unsigned int* bDefaultMarsh,
4794         unsigned int* bBoolCustMarsh, char* bI1CustMarsh, unsigned char* bU1CustMarsh, unsigned short* bVBCustMarsh);
4795
4796 LIBTEST_API int STDCALL
4797 mono_test_managed_marshal_bool_out (int arg, unsigned int expected, unsigned int testVal, MarshalBoolOutDelegate pfcn)
4798 {
4799         int ret;
4800         unsigned int lDefaultMarsh, lBoolCustMarsh;
4801         char lI1CustMarsh = 0;
4802         unsigned char lU1CustMarsh = 0;
4803         unsigned short lVBCustMarsh = 0;
4804         lDefaultMarsh = lBoolCustMarsh = 0;
4805
4806         if (!pfcn)
4807                 return 0x9900;
4808
4809         switch (arg) {
4810         case 1: {
4811                 unsigned int ltVal = 0;
4812                 ret = pfcn (arg, testVal, &ltVal, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4813                 if (ret)
4814                         return 0x0100 + ret;
4815                 if (expected != ltVal)
4816                         return 0x0200;
4817                 break;
4818         }
4819         case 2: {
4820                 unsigned int ltVal = 0;
4821                 ret = pfcn (arg, testVal, &lDefaultMarsh, &ltVal, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4822                 if (ret)
4823                         return 0x0300 + ret;
4824                 if (expected != ltVal)
4825                         return 0x0400;
4826                 break;
4827         }
4828         case 3: {
4829                 char ltVal = 0;
4830                 ret = pfcn (arg, testVal, &lDefaultMarsh, &lBoolCustMarsh, &ltVal, &lU1CustMarsh, &lVBCustMarsh);
4831                 if (ret)
4832                         return 0x0500 + ret;
4833                 if (expected != ltVal)
4834                         return 0x0600;
4835                 break;
4836         }
4837         case 4: {
4838                 unsigned char ltVal = 0;
4839                 ret = pfcn (arg, testVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &ltVal, &lVBCustMarsh);
4840                 if (ret)
4841                         return 0x0700 + ret;
4842                 if (expected != ltVal)
4843                         return 0x0800;
4844                 break;
4845         }
4846         case 5: {
4847                 unsigned short ltVal = 0;
4848                 ret = pfcn (arg, testVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &ltVal);
4849                 if (ret)
4850                         return 0x0900 + ret;
4851                 if (expected != ltVal)
4852                         return 0x1000;
4853                 break;
4854         }
4855         default:
4856                 return 0x9800;
4857         }
4858
4859         return 0;
4860 }
4861
4862 typedef int (STDCALL *MarshalBoolRefDelegate) (int arg, unsigned int expected, unsigned int testVal, unsigned int* bDefaultMarsh,
4863         unsigned int* bBoolCustMarsh, char* bI1CustMarsh, unsigned char* bU1CustMarsh, unsigned short* bVBCustMarsh);
4864
4865 LIBTEST_API int STDCALL
4866 mono_test_managed_marshal_bool_ref (int arg, unsigned int expected, unsigned int testVal, unsigned int outExpected,
4867                                     unsigned int outTestVal, MarshalBoolRefDelegate pfcn)
4868 {
4869         int ret;
4870         unsigned int lDefaultMarsh, lBoolCustMarsh;
4871         char lI1CustMarsh = 0;
4872         unsigned char lU1CustMarsh = 0;
4873         unsigned short lVBCustMarsh = 0;
4874         lDefaultMarsh = lBoolCustMarsh = 0;
4875
4876         if (!pfcn)
4877                 return 0x9900;
4878
4879         switch (arg) {
4880         case 1:
4881         {
4882                 unsigned int ltestVal = testVal;
4883                 ret = pfcn (arg, expected, outTestVal, &ltestVal, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4884                 if (ret)
4885                         return 0x0100 + ret;
4886                 if (outExpected != ltestVal)
4887                         return 0x0200;
4888                 break;
4889         }
4890         case 2:
4891         {
4892                 unsigned int ltestVal = testVal;
4893                 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &ltestVal, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4894                 if (ret)
4895                         return 0x0300 + ret;
4896                 if (outExpected != ltestVal)
4897                         return 0x0400;
4898                 break;
4899         }
4900         case 3:
4901         {
4902                 char ltestVal = testVal;
4903                 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &lBoolCustMarsh, &ltestVal, &lU1CustMarsh, &lVBCustMarsh);
4904                 if (ret)
4905                         return 0x0500 + ret;
4906                 if (outExpected != ltestVal)
4907                         return 0x0600;
4908                 break;
4909         }
4910         case 4:
4911         {
4912                 unsigned char ltestVal = testVal;
4913                 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &ltestVal, &lVBCustMarsh);
4914                 if (ret)
4915                         return 0x0700 + ret;
4916                 if (outExpected != ltestVal)
4917                         return 0x0800;
4918                 break;
4919         }
4920         case 5:
4921         {
4922                 unsigned short ltestVal = testVal;
4923                 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &ltestVal);
4924                 if (ret)
4925                         return 0x0900 + ret;
4926                 if (outExpected != ltestVal)
4927                         return 0x1000;
4928                 break;
4929         }
4930         default:
4931                 return 0x9800;
4932         }
4933
4934         return 0;
4935 }
4936
4937 #ifdef WIN32
4938
4939 LIBTEST_API int STDCALL
4940 mono_test_marshal_safearray_out_1dim_vt_bstr_empty (SAFEARRAY** safearray)
4941 {
4942         /* Create an empty one-dimensional array of variants */
4943         SAFEARRAY *pSA;
4944         SAFEARRAYBOUND dimensions [1];
4945
4946         dimensions [0].lLbound = 0;
4947         dimensions [0].cElements = 0;
4948
4949         pSA = SafeArrayCreate (VT_VARIANT, 1, dimensions);
4950         *safearray = pSA;
4951         return S_OK;
4952 }
4953
4954 LIBTEST_API int STDCALL
4955 mono_test_marshal_safearray_out_1dim_vt_bstr (SAFEARRAY** safearray)
4956 {
4957         /* Create a one-dimensional array of 10 variants filled with "0" to "9" */
4958         SAFEARRAY *pSA;
4959         SAFEARRAYBOUND dimensions [1];
4960         long i;
4961         gchar buffer [20];
4962         HRESULT hr = S_OK;
4963         long indices [1];
4964
4965         dimensions [0].lLbound = 0;
4966         dimensions [0].cElements = 10;
4967
4968         pSA= SafeArrayCreate (VT_VARIANT, 1, dimensions);
4969         for (i= dimensions [0].lLbound; i< (dimensions [0].cElements + dimensions [0].lLbound); i++) {
4970                 VARIANT vOut;
4971                 VariantInit (&vOut);
4972                 vOut.vt = VT_BSTR;
4973                 _ltoa (i,buffer,10);
4974                 vOut.bstrVal= marshal_bstr_alloc (buffer);
4975                 indices [0] = i;
4976                 if ((hr = SafeArrayPutElement (pSA, indices, &vOut)) != S_OK) {
4977                         VariantClear (&vOut);
4978                         SafeArrayDestroy (pSA);
4979                         return hr;
4980                 }
4981                 VariantClear (&vOut);
4982         }
4983         *safearray = pSA;
4984         return hr;
4985 }
4986
4987 LIBTEST_API int STDCALL
4988 mono_test_marshal_safearray_out_2dim_vt_i4 (SAFEARRAY** safearray)
4989 {
4990         /* Create a two-dimensional array of 4x3 variants filled with 11, 12, 13, etc. */
4991         SAFEARRAY *pSA;
4992         SAFEARRAYBOUND dimensions [2];
4993         long i, j;
4994         HRESULT hr = S_OK;
4995         long indices [2];
4996
4997         dimensions [0].lLbound = 0;
4998         dimensions [0].cElements = 4;
4999         dimensions [1].lLbound = 0;
5000         dimensions [1].cElements = 3;
5001
5002         pSA= SafeArrayCreate(VT_VARIANT, 2, dimensions);
5003         for (i= dimensions [0].lLbound; i< (dimensions [0].cElements + dimensions [0].lLbound); i++) {
5004                 for (j= dimensions [1].lLbound; j< (dimensions [1].cElements + dimensions [1].lLbound); j++) {
5005                         VARIANT vOut;
5006                         VariantInit (&vOut);
5007                         vOut.vt = VT_I4;
5008                         vOut.lVal = (i+1)*10+(j+1);
5009                         indices [0] = i;
5010                         indices [1] = j;
5011                         if ((hr = SafeArrayPutElement (pSA, indices, &vOut)) != S_OK) {
5012                                 VariantClear (&vOut);
5013                                 SafeArrayDestroy (pSA);
5014                                 return hr;
5015                         }
5016                         VariantClear (&vOut);  // does a deep destroy of source VARIANT
5017                 }
5018         }
5019         *safearray = pSA;
5020         return hr;
5021 }
5022
5023 LIBTEST_API int STDCALL
5024 mono_test_marshal_safearray_out_4dim_vt_i4 (SAFEARRAY** safearray)
5025 {
5026         /* Create a four-dimensional array of 10x3x6x7 variants filled with their indices */
5027         /* Also use non zero lower bounds                                                 */
5028         SAFEARRAY *pSA;
5029         SAFEARRAYBOUND dimensions [4];
5030         long i;
5031         HRESULT hr = S_OK;
5032         VARIANT *pData;
5033
5034         dimensions [0].lLbound = 15;
5035         dimensions [0].cElements = 10;
5036         dimensions [1].lLbound = 20;
5037         dimensions [1].cElements = 3;
5038         dimensions [2].lLbound = 5;
5039         dimensions [2].cElements = 6;
5040         dimensions [3].lLbound = 12;
5041         dimensions [3].cElements = 7;
5042
5043         pSA= SafeArrayCreate (VT_VARIANT, 4, dimensions);
5044
5045         SafeArrayAccessData (pSA, (void **)&pData);
5046
5047         for (i= 0; i< 10*3*6*7; i++) {
5048                 VariantInit(&pData [i]);
5049                 pData [i].vt = VT_I4;
5050                 pData [i].lVal = i;
5051         }
5052         SafeArrayUnaccessData (pSA);
5053         *safearray = pSA;
5054         return hr;
5055 }
5056
5057 LIBTEST_API int STDCALL
5058 mono_test_marshal_safearray_in_byval_1dim_empty (SAFEARRAY* safearray)
5059 {
5060         /* Check that array is one dimensional and empty */
5061
5062         UINT dim;
5063         long lbound, ubound;
5064
5065         dim = SafeArrayGetDim (safearray);
5066         if (dim != 1)
5067                 return 1;
5068
5069         SafeArrayGetLBound (safearray, 1, &lbound);
5070         SafeArrayGetUBound (safearray, 1, &ubound);
5071
5072         if ((lbound > 0) || (ubound > 0))
5073                 return 1;
5074
5075         return 0;
5076 }
5077
5078 LIBTEST_API int STDCALL
5079 mono_test_marshal_safearray_in_byval_1dim_vt_i4 (SAFEARRAY* safearray)
5080 {
5081         /* Check that array is one dimensional containing integers from 1 to 10 */
5082
5083         UINT dim;
5084         long lbound, ubound;
5085         VARIANT *pData;
5086         long i;
5087         int result=0;
5088
5089         dim = SafeArrayGetDim (safearray);
5090         if (dim != 1)
5091                 return 1;
5092
5093         SafeArrayGetLBound (safearray, 1, &lbound);
5094         SafeArrayGetUBound (safearray, 1, &ubound);
5095
5096         if ((lbound != 0) || (ubound != 9))
5097                 return 1;
5098
5099         SafeArrayAccessData (safearray, (void **)&pData);
5100         for (i= lbound; i <= ubound; i++) {
5101                 if ((VariantChangeType (&pData [i], &pData [i], VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK) || (pData [i].lVal != i + 1))
5102                         result = 1;
5103         }
5104         SafeArrayUnaccessData (safearray);
5105
5106         return result;
5107 }
5108
5109 LIBTEST_API int STDCALL
5110 mono_test_marshal_safearray_in_byval_1dim_vt_mixed (SAFEARRAY* safearray)
5111 {
5112         /* Check that array is one dimensional containing integers mixed with strings from 0 to 12 */
5113
5114         UINT dim;
5115         long lbound, ubound;
5116         VARIANT *pData;
5117         long i;
5118         long indices [1];
5119         VARIANT element;
5120         int result=0;
5121
5122         VariantInit (&element);
5123
5124         dim = SafeArrayGetDim (safearray);
5125         if (dim != 1)
5126                 return 1;
5127
5128         SafeArrayGetLBound (safearray, 1, &lbound);
5129         SafeArrayGetUBound (safearray, 1, &ubound);
5130
5131         if ((lbound != 0) || (ubound != 12))
5132                 return 1;
5133
5134         SafeArrayAccessData (safearray, (void **)&pData);
5135         for (i= lbound; i <= ubound; i++) {
5136                 if ((i%2 == 0) && (pData [i].vt != VT_I4))
5137                         result = 1;
5138                 if ((i%2 == 1) && (pData [i].vt != VT_BSTR))
5139                         result = 1;
5140                 if ((VariantChangeType (&pData [i], &pData [i], VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK) || (pData [i].lVal != i))
5141                         result = 1;
5142         }
5143         SafeArrayUnaccessData (safearray);
5144
5145         /* Change the first element of the array to verify that [in] parameters are not marshalled back to the managed side */
5146
5147         indices [0] = 0;
5148         element.vt = VT_I4;
5149         element.lVal = 333;
5150         SafeArrayPutElement (safearray, indices, &element);
5151         VariantClear (&element);
5152
5153         return result;
5154 }
5155
5156 LIBTEST_API int STDCALL
5157 mono_test_marshal_safearray_in_byval_2dim_vt_i4 (SAFEARRAY* safearray)
5158 {
5159         /* Check that array is one dimensional containing integers mixed with strings from 0 to 12 */
5160
5161         UINT dim;
5162         long lbound1, ubound1, lbound2, ubound2;
5163         long i, j, failed;
5164         long indices [2];
5165         VARIANT element;
5166
5167         VariantInit (&element);
5168
5169         dim = SafeArrayGetDim (safearray);
5170         if (dim != 2)
5171                 return 1;
5172
5173         SafeArrayGetLBound (safearray, 1, &lbound1);
5174         SafeArrayGetUBound (safearray, 1, &ubound1);
5175
5176         if ((lbound1 != 0) || (ubound1 != 1))
5177                 return 1;
5178
5179         SafeArrayGetLBound (safearray, 2, &lbound2);
5180         SafeArrayGetUBound (safearray, 2, &ubound2);
5181
5182         if ((lbound2 != 0) || (ubound2 != 3)) {
5183                 return 1;
5184         }
5185
5186         for (i= lbound1; i <= ubound1; i++) {
5187                 indices [0] = i;
5188                 for (j= lbound2; j <= ubound2; j++) {
5189                         indices [1] = j;
5190                         if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5191                                 return 1;
5192                         failed = ((element.vt != VT_I4) || (element.lVal != 10*(i+1)+(j+1)));
5193                         VariantClear (&element);
5194                         if (failed)
5195                                 return 1;
5196                 }
5197         }
5198
5199         /* Change the first element of the array to verify that [in] parameters are not marshalled back to the managed side */
5200
5201         indices [0] = 0;
5202         indices [1] = 0;
5203         element.vt = VT_I4;
5204         element.lVal = 333;
5205         SafeArrayPutElement (safearray, indices, &element);
5206         VariantClear (&element);
5207
5208         return 0;
5209 }
5210
5211 LIBTEST_API int STDCALL
5212 mono_test_marshal_safearray_in_byval_3dim_vt_bstr (SAFEARRAY* safearray)
5213 {
5214         /* Check that array is one dimensional containing integers mixed with strings from 0 to 12 */
5215
5216         UINT dim;
5217         long lbound1, ubound1, lbound2, ubound2, lbound3, ubound3;
5218         long i, j, k, failed;
5219         long indices [3];
5220         VARIANT element;
5221
5222         VariantInit (&element);
5223
5224         dim = SafeArrayGetDim (safearray);
5225         if (dim != 3)
5226                 return 1;
5227
5228         SafeArrayGetLBound (safearray, 1, &lbound1);
5229         SafeArrayGetUBound (safearray, 1, &ubound1);
5230
5231         if ((lbound1 != 0) || (ubound1 != 1))
5232                 return 1;
5233
5234         SafeArrayGetLBound (safearray, 2, &lbound2);
5235         SafeArrayGetUBound (safearray, 2, &ubound2);
5236
5237         if ((lbound2 != 0) || (ubound2 != 1))
5238                 return 1;
5239
5240         SafeArrayGetLBound (safearray, 3, &lbound3);
5241         SafeArrayGetUBound (safearray, 3, &ubound3);
5242
5243         if ((lbound3 != 0) || (ubound3 != 2))
5244                 return 1;
5245
5246         for (i= lbound1; i <= ubound1; i++) {
5247                 indices [0] = i;
5248                 for (j= lbound2; j <= ubound2; j++) {
5249                         indices [1] = j;
5250                 for (k= lbound3; k <= ubound3; k++) {
5251                                 indices [2] = k;
5252                                 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5253                                         return 1;
5254                                 failed = ((element.vt != VT_BSTR)
5255                                         || (VariantChangeType (&element, &element, VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK)
5256                                         || (element.lVal != 100*(i+1)+10*(j+1)+(k+1)));
5257                                 VariantClear (&element);
5258                                 if (failed)
5259                                         return 1;
5260                         }
5261                 }
5262         }
5263
5264         /* Change the first element of the array to verify that [in] parameters are not marshalled back to the managed side */
5265
5266         indices [0] = 0;
5267         indices [1] = 0;
5268         indices [2] = 0;
5269         element.vt = VT_BSTR;
5270         element.bstrVal = SysAllocString(L"Should not be copied");
5271         SafeArrayPutElement (safearray, indices, &element);
5272         VariantClear (&element);
5273
5274         return 0;
5275 }
5276
5277 LIBTEST_API int STDCALL
5278 mono_test_marshal_safearray_in_byref_3dim_vt_bstr (SAFEARRAY** safearray)
5279 {
5280         return mono_test_marshal_safearray_in_byval_3dim_vt_bstr (*safearray);
5281 }
5282
5283 LIBTEST_API int STDCALL
5284 mono_test_marshal_safearray_in_out_byref_1dim_empty (SAFEARRAY** safearray)
5285 {
5286         /* Check that the input array is what is expected and change it so the caller can check */
5287         /* correct marshalling back to managed code                                             */
5288
5289         UINT dim;
5290         long lbound, ubound;
5291         SAFEARRAYBOUND dimensions [1];
5292         long i;
5293         wchar_t buffer [20];
5294         HRESULT hr = S_OK;
5295         long indices [1];
5296
5297         /* Check that in array is one dimensional and empty */
5298
5299         dim = SafeArrayGetDim (*safearray);
5300         if (dim != 1) {
5301                 return 1;
5302         }
5303
5304         SafeArrayGetLBound (*safearray, 1, &lbound);
5305         SafeArrayGetUBound (*safearray, 1, &ubound);
5306
5307         if ((lbound > 0) || (ubound > 0)) {
5308                 return 1;
5309         }
5310
5311         /* Re-dimension the array and return a one-dimensional array of 8 variants filled with "0" to "7" */
5312
5313         dimensions [0].lLbound = 0;
5314         dimensions [0].cElements = 8;
5315
5316         hr = SafeArrayRedim (*safearray, dimensions);
5317         if (hr != S_OK)
5318                 return 1;
5319
5320         for (i= dimensions [0].lLbound; i< (dimensions [0].lLbound + dimensions [0].cElements); i++) {
5321                 VARIANT vOut;
5322                 VariantInit (&vOut);
5323                 vOut.vt = VT_BSTR;
5324                 _ltow (i,buffer,10);
5325                 vOut.bstrVal = SysAllocString (buffer);
5326                 indices [0] = i;
5327                 if ((hr = SafeArrayPutElement (*safearray, indices, &vOut)) != S_OK) {
5328                         VariantClear (&vOut);
5329                         SafeArrayDestroy (*safearray);
5330                         return hr;
5331                 }
5332                 VariantClear (&vOut);
5333         }
5334         return hr;
5335 }
5336
5337 LIBTEST_API int STDCALL
5338 mono_test_marshal_safearray_in_out_byref_3dim_vt_bstr (SAFEARRAY** safearray)
5339 {
5340         /* Check that the input array is what is expected and change it so the caller can check */
5341         /* correct marshalling back to managed code                                             */
5342
5343         UINT dim;
5344         long lbound1, ubound1, lbound2, ubound2, lbound3, ubound3;
5345         SAFEARRAYBOUND dimensions [1];
5346         long i, j, k, failed;
5347         wchar_t buffer [20];
5348         HRESULT hr = S_OK;
5349         long indices [3];
5350         VARIANT element;
5351
5352         VariantInit (&element);
5353
5354         /* Check that in array is three dimensional and contains the expected values */
5355
5356         dim = SafeArrayGetDim (*safearray);
5357         if (dim != 3)
5358                 return 1;
5359
5360         SafeArrayGetLBound (*safearray, 1, &lbound1);
5361         SafeArrayGetUBound (*safearray, 1, &ubound1);
5362
5363         if ((lbound1 != 0) || (ubound1 != 1))
5364                 return 1;
5365
5366         SafeArrayGetLBound (*safearray, 2, &lbound2);
5367         SafeArrayGetUBound (*safearray, 2, &ubound2);
5368
5369         if ((lbound2 != 0) || (ubound2 != 1))
5370                 return 1;
5371
5372         SafeArrayGetLBound (*safearray, 3, &lbound3);
5373         SafeArrayGetUBound (*safearray, 3, &ubound3);
5374
5375         if ((lbound3 != 0) || (ubound3 != 2))
5376                 return 1;
5377
5378         for (i= lbound1; i <= ubound1; i++) {
5379                 indices [0] = i;
5380                 for (j= lbound2; j <= ubound2; j++) {
5381                         indices [1] = j;
5382                         for (k= lbound3; k <= ubound3; k++) {
5383                                 indices [2] = k;
5384                                 if (SafeArrayGetElement (*safearray, indices, &element) != S_OK)
5385                                         return 1;
5386                                 failed = ((element.vt != VT_BSTR)
5387                                         || (VariantChangeType (&element, &element, VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK)
5388                                         || (element.lVal != 100*(i+1)+10*(j+1)+(k+1)));
5389                                 VariantClear (&element);
5390                                 if (failed)
5391                                         return 1;
5392                         }
5393                 }
5394         }
5395
5396         hr = SafeArrayDestroy (*safearray);
5397         if (hr != S_OK)
5398                 return 1;
5399
5400         /* Return a new one-dimensional array of 8 variants filled with "0" to "7" */
5401
5402         dimensions [0].lLbound = 0;
5403         dimensions [0].cElements = 8;
5404
5405         *safearray = SafeArrayCreate (VT_VARIANT, 1, dimensions);
5406
5407         for (i= dimensions [0].lLbound; i< (dimensions [0].lLbound + dimensions [0].cElements); i++) {
5408                 VARIANT vOut;
5409                 VariantInit (&vOut);
5410                 vOut.vt = VT_BSTR;
5411                 _ltow (i,buffer,10);
5412                 vOut.bstrVal = SysAllocString (buffer);
5413                 indices [0] = i;
5414                 if ((hr = SafeArrayPutElement (*safearray, indices, &vOut)) != S_OK) {
5415                         VariantClear (&vOut);
5416                         SafeArrayDestroy (*safearray);
5417                         return hr;
5418                 }
5419                 VariantClear (&vOut);
5420         }
5421         return hr;
5422 }
5423
5424 LIBTEST_API int STDCALL
5425 mono_test_marshal_safearray_in_out_byref_1dim_vt_i4 (SAFEARRAY** safearray)
5426 {
5427         /* Check that the input array is what is expected and change it so the caller can check */
5428         /* correct marshalling back to managed code                                             */
5429
5430         UINT dim;
5431         long lbound1, ubound1;
5432         long i, failed;
5433         HRESULT hr = S_OK;
5434         long indices [1];
5435         VARIANT element;
5436
5437         VariantInit (&element);
5438
5439         /* Check that in array is one dimensional and contains the expected value */
5440
5441         dim = SafeArrayGetDim (*safearray);
5442         if (dim != 1)
5443                 return 1;
5444
5445         SafeArrayGetLBound (*safearray, 1, &lbound1);
5446         SafeArrayGetUBound (*safearray, 1, &ubound1);
5447
5448         ubound1 = 1;
5449         if ((lbound1 != 0) || (ubound1 != 1))
5450                 return 1;
5451         ubound1 = 0;
5452
5453         for (i= lbound1; i <= ubound1; i++) {
5454                 indices [0] = i;
5455                 if (SafeArrayGetElement (*safearray, indices, &element) != S_OK)
5456                         return 1;
5457                 failed = (element.vt != VT_I4) || (element.lVal != i+1);
5458                 VariantClear (&element);
5459                 if (failed)
5460                         return 1;
5461         }
5462
5463         /* Change one of the elements of the array to verify that [out] parameter is marshalled back to the managed side */
5464
5465         indices [0] = 0;
5466         element.vt = VT_I4;
5467         element.lVal = -1;
5468         SafeArrayPutElement (*safearray, indices, &element);
5469         VariantClear (&element);
5470
5471         return hr;
5472 }
5473
5474 LIBTEST_API int STDCALL
5475 mono_test_marshal_safearray_in_out_byval_1dim_vt_i4 (SAFEARRAY* safearray)
5476 {
5477         /* Check that the input array is what is expected and change it so the caller can check */
5478         /* correct marshalling back to managed code                                             */
5479
5480         UINT dim;
5481         long lbound1, ubound1;
5482         SAFEARRAYBOUND dimensions [1];
5483         long i, failed;
5484         HRESULT hr = S_OK;
5485         long indices [1];
5486         VARIANT element;
5487
5488         VariantInit (&element);
5489
5490         /* Check that in array is one dimensional and contains the expected value */
5491
5492         dim = SafeArrayGetDim (safearray);
5493         if (dim != 1)
5494                 return 1;
5495
5496         SafeArrayGetLBound (safearray, 1, &lbound1);
5497         SafeArrayGetUBound (safearray, 1, &ubound1);
5498
5499         if ((lbound1 != 0) || (ubound1 != 0))
5500                 return 1;
5501
5502         for (i= lbound1; i <= ubound1; i++) {
5503                 indices [0] = i;
5504                 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5505                         return 1;
5506                 failed = (element.vt != VT_I4) || (element.lVal != i+1);
5507                 VariantClear (&element);
5508                 if (failed)
5509                         return 1;
5510         }
5511
5512         /* Change the array to verify how [out] parameter is marshalled back to the managed side */
5513
5514         /* Redimension the array */
5515         dimensions [0].lLbound = lbound1;
5516         dimensions [0].cElements = 2;
5517         hr = SafeArrayRedim(safearray, dimensions);
5518
5519         indices [0] = 0;
5520         element.vt = VT_I4;
5521         element.lVal = 12345;
5522         SafeArrayPutElement (safearray, indices, &element);
5523         VariantClear (&element);
5524
5525         indices [0] = 1;
5526         element.vt = VT_I4;
5527         element.lVal = -12345;
5528         SafeArrayPutElement (safearray, indices, &element);
5529         VariantClear (&element);
5530
5531         return hr;
5532 }
5533
5534 LIBTEST_API int STDCALL
5535 mono_test_marshal_safearray_in_out_byval_3dim_vt_bstr (SAFEARRAY* safearray)
5536 {
5537         /* Check that the input array is what is expected and change it so the caller can check */
5538         /* correct marshalling back to managed code                                             */
5539
5540         UINT dim;
5541         long lbound1, ubound1, lbound2, ubound2, lbound3, ubound3;
5542         long i, j, k, failed;
5543         HRESULT hr = S_OK;
5544         long indices [3];
5545         VARIANT element;
5546
5547         VariantInit (&element);
5548
5549         /* Check that in array is three dimensional and contains the expected values */
5550
5551         dim = SafeArrayGetDim (safearray);
5552         if (dim != 3)
5553                 return 1;
5554
5555         SafeArrayGetLBound (safearray, 1, &lbound1);
5556         SafeArrayGetUBound (safearray, 1, &ubound1);
5557
5558         if ((lbound1 != 0) || (ubound1 != 1))
5559                 return 1;
5560
5561         SafeArrayGetLBound (safearray, 2, &lbound2);
5562         SafeArrayGetUBound (safearray, 2, &ubound2);
5563
5564         if ((lbound2 != 0) || (ubound2 != 1))
5565                 return 1;
5566
5567         SafeArrayGetLBound (safearray, 3, &lbound3);
5568         SafeArrayGetUBound (safearray, 3, &ubound3);
5569
5570         if ((lbound3 != 0) || (ubound3 != 2))
5571                 return 1;
5572
5573         for (i= lbound1; i <= ubound1; i++) {
5574                 indices [0] = i;
5575                 for (j= lbound2; j <= ubound2; j++) {
5576                         indices [1] = j;
5577                         for (k= lbound3; k <= ubound3; k++) {
5578                                 indices [2] = k;
5579                                 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5580                                         return 1;
5581                                 failed = ((element.vt != VT_BSTR)
5582                                         || (VariantChangeType (&element, &element, VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK)
5583                                         || (element.lVal != 100*(i+1)+10*(j+1)+(k+1)));
5584                                 VariantClear (&element);
5585                                 if (failed)
5586                                         return 1;
5587                         }
5588                 }
5589         }
5590
5591         /* Change the elements of the array to verify that [out] parameter is marshalled back to the managed side */
5592
5593         indices [0] = 1;
5594         indices [1] = 1;
5595         indices [2] = 2;
5596         element.vt = VT_I4;
5597         element.lVal = 333;
5598         SafeArrayPutElement (safearray, indices, &element);
5599         VariantClear (&element);
5600
5601         indices [0] = 1;
5602         indices [1] = 1;
5603         indices [2] = 1;
5604         element.vt = VT_I4;
5605         element.lVal = 111;
5606         SafeArrayPutElement (safearray, indices, &element);
5607         VariantClear (&element);
5608
5609         indices [0] = 0;
5610         indices [1] = 1;
5611         indices [2] = 0;
5612         element.vt = VT_BSTR;
5613         element.bstrVal = marshal_bstr_alloc("ABCDEFG");
5614         SafeArrayPutElement (safearray, indices, &element);
5615         VariantClear (&element);
5616
5617         return hr;
5618 }
5619
5620 LIBTEST_API int STDCALL
5621 mono_test_marshal_safearray_mixed(
5622                 SAFEARRAY  *safearray1,
5623                 SAFEARRAY **safearray2,
5624                 SAFEARRAY  *safearray3,
5625                 SAFEARRAY **safearray4
5626                 )
5627 {
5628         HRESULT hr = S_OK;
5629
5630         /* Initialize out parameters */
5631         *safearray2 = NULL;
5632
5633         /* array1: Check that in array is one dimensional and contains the expected value */
5634         hr = mono_test_marshal_safearray_in_out_byval_1dim_vt_i4 (safearray1);
5635
5636         /* array2: Fill in with some values to check on the managed side */
5637         if (hr == S_OK)
5638                 hr = mono_test_marshal_safearray_out_1dim_vt_bstr (safearray2);
5639
5640         /* array3: Check that in array is one dimensional and contains the expected value */
5641         if (hr == S_OK)
5642                 hr = mono_test_marshal_safearray_in_byval_1dim_vt_mixed(safearray3);
5643
5644         /* array4: Check input values and fill in with some values to check on the managed side */
5645         if (hr == S_OK)
5646                 hr = mono_test_marshal_safearray_in_out_byref_3dim_vt_bstr(safearray4);
5647
5648         return hr;
5649 }
5650
5651 LIBTEST_API int STDCALL
5652 mono_test_marshal_safearray_in_ccw(MonoComObject *pUnk)
5653 {
5654         SAFEARRAY *array;
5655         VARIANT var;
5656         long index;
5657         int ret;
5658
5659         array = SafeArrayCreateVector(VT_VARIANT, 0, 2);
5660
5661         var.vt = VT_BSTR;
5662         var.bstrVal = marshal_bstr_alloc("Test");
5663         index = 0;
5664         SafeArrayPutElement(array, &index, &var);
5665
5666         var.vt = VT_I4;
5667         var.intVal = 2345;
5668         index = 1;
5669         SafeArrayPutElement(array, &index, &var);
5670
5671         ret = pUnk->vtbl->ArrayIn (pUnk, (void *)array);
5672         if (!ret)
5673                 ret = pUnk->vtbl->ArrayIn2 (pUnk, (void *)array);
5674         if (!ret)
5675                 ret = pUnk->vtbl->ArrayIn3 (pUnk, (void *)array);
5676
5677         SafeArrayDestroy(array);
5678
5679         return ret;
5680 }
5681
5682 #endif
5683
5684 static int call_managed_res;
5685
5686 static void
5687 call_managed (gpointer arg)
5688 {
5689         SimpleDelegate del = (SimpleDelegate)arg;
5690
5691         call_managed_res = del (42);
5692 }
5693
5694 LIBTEST_API int STDCALL
5695 mono_test_marshal_thread_attach (SimpleDelegate del)
5696 {
5697 #ifdef WIN32
5698         return 43;
5699 #else
5700         int res;
5701         pthread_t t;
5702
5703         res = pthread_create (&t, NULL, (gpointer (*)(gpointer))call_managed, (gpointer)del);
5704         g_assert (res == 0);
5705         pthread_join (t, NULL);
5706
5707         return call_managed_res;
5708 #endif
5709 }
5710
5711 typedef struct {
5712         char arr [4 * 1024];
5713 } LargeStruct;
5714
5715 typedef int (STDCALL *LargeStructDelegate) (LargeStruct *s);
5716
5717 static void
5718 call_managed_large_vt (gpointer arg)
5719 {
5720         LargeStructDelegate del = (LargeStructDelegate)arg;
5721         LargeStruct s;
5722
5723         call_managed_res = del (&s);
5724 }
5725
5726 LIBTEST_API int STDCALL
5727 mono_test_marshal_thread_attach_large_vt (SimpleDelegate del)
5728 {
5729 #ifdef WIN32
5730         return 43;
5731 #else
5732         int res;
5733         pthread_t t;
5734
5735         res = pthread_create (&t, NULL, (gpointer (*)(gpointer))call_managed_large_vt, (gpointer)del);
5736         g_assert (res == 0);
5737         pthread_join (t, NULL);
5738
5739         return call_managed_res;
5740 #endif
5741 }
5742
5743 typedef int (STDCALL *Callback) (void);
5744
5745 static Callback callback;
5746
5747 LIBTEST_API void STDCALL
5748 mono_test_marshal_set_callback (Callback cb)
5749 {
5750         callback = cb;
5751 }
5752
5753 LIBTEST_API int STDCALL
5754 mono_test_marshal_call_callback (void)
5755 {
5756         return callback ();
5757 }
5758
5759 LIBTEST_API int STDCALL
5760 mono_test_marshal_lpstr (char *str)
5761 {
5762         return strcmp ("ABC", str);
5763 }
5764
5765 LIBTEST_API int STDCALL
5766 mono_test_marshal_lpwstr (gunichar2 *str)
5767 {
5768         char *s;
5769         int res;
5770
5771         s = g_utf16_to_utf8 (str, -1, NULL, NULL, NULL);
5772         res = strcmp ("ABC", s);
5773         g_free (s);
5774
5775         return res;
5776 }
5777
5778 LIBTEST_API char* STDCALL
5779 mono_test_marshal_return_lpstr (void)
5780 {
5781         char *res = (char *)marshal_alloc (4);
5782         strcpy (res, "XYZ");
5783         return res;
5784 }
5785
5786 LIBTEST_API gunichar2* STDCALL
5787 mono_test_marshal_return_lpwstr (void)
5788 {
5789         gunichar2 *res = (gunichar2 *)marshal_alloc (8);
5790         gunichar2* tmp = g_utf8_to_utf16 ("XYZ", -1, NULL, NULL, NULL);
5791
5792         memcpy (res, tmp, 8);
5793         g_free (tmp);
5794
5795         return res;
5796 }
5797
5798 typedef
5799 #if defined (HOST_WIN32) && defined (HOST_X86) && defined (__GNUC__)
5800 // Workaround gcc ABI bug. It returns the struct in ST0 instead of edx:eax.
5801 // Mono and Visual C++ agree.
5802 union
5803 #else
5804 struct
5805 #endif
5806 {
5807         double d;
5808 } SingleDoubleStruct;
5809
5810 LIBTEST_API SingleDoubleStruct STDCALL
5811 mono_test_marshal_return_single_double_struct (void)
5812 {
5813         SingleDoubleStruct res = {3.0};
5814         return res;
5815 }
5816
5817 LIBTEST_API int STDCALL
5818 mono_test_has_thiscall_globals (void)
5819 {
5820 // Visual C++ does not accept __thiscall on global functions, only
5821 // member function and function pointers. Gcc accepts it also on global functions.
5822 #if defined (HOST_X86) && defined (HOST_WIN32) && !defined (_MSC_VER)
5823         return 1;
5824 #else
5825         return 0;
5826 #endif
5827 }
5828
5829 LIBTEST_API int STDCALL
5830 mono_test_has_thiscall_pointers (void)
5831 {
5832 #if defined (HOST_X86) && defined (HOST_WIN32)
5833         return 1;
5834 #else
5835         return 0;
5836 #endif
5837 }
5838
5839 LIBTEST_API int
5840 #ifndef _MSC_VER
5841 __thiscall
5842 #endif
5843 _mono_test_native_thiscall1 (int arg)
5844 {
5845         return arg;
5846 }
5847
5848 LIBTEST_API int
5849 #ifndef _MSC_VER
5850 __thiscall
5851 #endif
5852 _mono_test_native_thiscall2 (int arg, int arg2)
5853 {
5854         return arg + (arg2^1);
5855 }
5856
5857 LIBTEST_API int
5858 #ifndef _MSC_VER
5859 __thiscall
5860 #endif
5861 _mono_test_native_thiscall3 (int arg, int arg2, int arg3)
5862 {
5863         return arg + (arg2^1) + (arg3^2);
5864 }
5865
5866 typedef int (
5867 #ifndef _MSC_VER
5868 __thiscall
5869 #endif
5870 *ThiscallFunction)(int arg, int arg2);
5871
5872 LIBTEST_API ThiscallFunction STDCALL
5873 mono_test_get_native_thiscall2 (void)
5874 {
5875         return _mono_test_native_thiscall2;
5876 }
5877
5878 LIBTEST_API int STDCALL
5879 _mono_test_managed_thiscall1 (int (__thiscall*fn)(int), int arg)
5880 {
5881         return fn(arg);
5882 }
5883
5884 LIBTEST_API int STDCALL
5885 _mono_test_managed_thiscall2 (int (__thiscall*fn)(int,int), int arg, int arg2)
5886 {
5887         return fn(arg, arg2);
5888 }
5889
5890 LIBTEST_API int STDCALL
5891 _mono_test_managed_thiscall3 (int (__thiscall*fn)(int,int,int), int arg, int arg2, int arg3)
5892 {
5893         return fn(arg, arg2, arg3);
5894 }
5895
5896 typedef struct {
5897         char f1;
5898 } sbyte1;
5899
5900 LIBTEST_API sbyte1 STDCALL
5901 mono_return_sbyte1 (sbyte1 s1, int addend) {
5902         if (s1.f1 != 1) {
5903                 fprintf(stderr, "mono_return_sbyte1 s1.f1: got %d but expected %d\n", s1.f1, 1);
5904         }
5905         s1.f1+=addend;
5906         return s1;
5907 }
5908
5909 typedef struct {
5910         char f1,f2;
5911 } sbyte2;
5912
5913 LIBTEST_API sbyte2 STDCALL
5914 mono_return_sbyte2 (sbyte2 s2, int addend) {
5915         if (s2.f1 != 1) {
5916                 fprintf(stderr, "mono_return_sbyte2 s2.f1: got %d but expected %d\n", s2.f1, 1);
5917         }
5918         if (s2.f2 != 2) {
5919                 fprintf(stderr, "mono_return_sbyte2 s2.f2: got %d but expected %d\n", s2.f2, 2);
5920         }
5921         s2.f1+=addend; s2.f2+=addend;
5922         return s2;
5923 }
5924
5925 typedef struct {
5926         char f1,f2,f3;
5927 } sbyte3;
5928
5929 LIBTEST_API sbyte3 STDCALL
5930 mono_return_sbyte3 (sbyte3 s3, int addend) {
5931         if (s3.f1 != 1) {
5932                 fprintf(stderr, "mono_return_sbyte3 s3.f1: got %d but expected %d\n", s3.f1, 1);
5933         }
5934         if (s3.f2 != 2) {
5935                 fprintf(stderr, "mono_return_sbyte3 s3.f2: got %d but expected %d\n", s3.f2, 2);
5936         }
5937         if (s3.f3 != 3) {
5938                 fprintf(stderr, "mono_return_sbyte3 s3.f3: got %d but expected %d\n", s3.f3, 3);
5939         }
5940         s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
5941         return s3;
5942 }
5943
5944 typedef struct {
5945         char f1,f2,f3,f4;
5946 } sbyte4;
5947
5948 LIBTEST_API sbyte4 STDCALL
5949 mono_return_sbyte4 (sbyte4 s4, int addend) {
5950         if (s4.f1 != 1) {
5951                 fprintf(stderr, "mono_return_sbyte4 s4.f1: got %d but expected %d\n", s4.f1, 1);
5952         }
5953         if (s4.f2 != 2) {
5954                 fprintf(stderr, "mono_return_sbyte4 s4.f2: got %d but expected %d\n", s4.f2, 2);
5955         }
5956         if (s4.f3 != 3) {
5957                 fprintf(stderr, "mono_return_sbyte4 s4.f3: got %d but expected %d\n", s4.f3, 3);
5958         }
5959         if (s4.f4 != 4) {
5960                 fprintf(stderr, "mono_return_sbyte4 s4.f4: got %d but expected %d\n", s4.f4, 4);
5961         }
5962         s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
5963         return s4;
5964 }
5965
5966 typedef struct {
5967         char f1,f2,f3,f4,f5;
5968 } sbyte5;
5969
5970 LIBTEST_API sbyte5 STDCALL
5971 mono_return_sbyte5 (sbyte5 s5, int addend) {
5972         if (s5.f1 != 1) {
5973                 fprintf(stderr, "mono_return_sbyte5 s5.f1: got %d but expected %d\n", s5.f1, 1);
5974         }
5975         if (s5.f2 != 2) {
5976                 fprintf(stderr, "mono_return_sbyte5 s5.f2: got %d but expected %d\n", s5.f2, 2);
5977         }
5978         if (s5.f3 != 3) {
5979                 fprintf(stderr, "mono_return_sbyte5 s5.f3: got %d but expected %d\n", s5.f3, 3);
5980         }
5981         if (s5.f4 != 4) {
5982                 fprintf(stderr, "mono_return_sbyte5 s5.f4: got %d but expected %d\n", s5.f4, 4);
5983         }
5984         if (s5.f5 != 5) {
5985                 fprintf(stderr, "mono_return_sbyte5 s5.f5: got %d but expected %d\n", s5.f5, 5);
5986         }
5987         s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
5988         return s5;
5989 }
5990
5991 typedef struct {
5992         char f1,f2,f3,f4,f5,f6;
5993 } sbyte6;
5994
5995 LIBTEST_API sbyte6 STDCALL
5996 mono_return_sbyte6 (sbyte6 s6, int addend) {
5997         if (s6.f1 != 1) {
5998                 fprintf(stderr, "mono_return_sbyte6 s6.f1: got %d but expected %d\n", s6.f1, 1);
5999         }
6000         if (s6.f2 != 2) {
6001                 fprintf(stderr, "mono_return_sbyte6 s6.f2: got %d but expected %d\n", s6.f2, 2);
6002         }
6003         if (s6.f3 != 3) {
6004                 fprintf(stderr, "mono_return_sbyte6 s6.f3: got %d but expected %d\n", s6.f3, 3);
6005         }
6006         if (s6.f4 != 4) {
6007                 fprintf(stderr, "mono_return_sbyte6 s6.f4: got %d but expected %d\n", s6.f4, 4);
6008         }
6009         if (s6.f5 != 5) {
6010                 fprintf(stderr, "mono_return_sbyte6 s6.f5: got %d but expected %d\n", s6.f5, 5);
6011         }
6012         if (s6.f6 != 6) {
6013                 fprintf(stderr, "mono_return_sbyte6 s6.f6: got %d but expected %d\n", s6.f6, 6);
6014         }
6015         s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
6016         return s6;
6017 }
6018
6019 typedef struct {
6020         char f1,f2,f3,f4,f5,f6,f7;
6021 } sbyte7;
6022
6023 LIBTEST_API sbyte7 STDCALL
6024 mono_return_sbyte7 (sbyte7 s7, int addend) {
6025         if (s7.f1 != 1) {
6026                 fprintf(stderr, "mono_return_sbyte7 s7.f1: got %d but expected %d\n", s7.f1, 1);
6027         }
6028         if (s7.f2 != 2) {
6029                 fprintf(stderr, "mono_return_sbyte7 s7.f2: got %d but expected %d\n", s7.f2, 2);
6030         }
6031         if (s7.f3 != 3) {
6032                 fprintf(stderr, "mono_return_sbyte7 s7.f3: got %d but expected %d\n", s7.f3, 3);
6033         }
6034         if (s7.f4 != 4) {
6035                 fprintf(stderr, "mono_return_sbyte7 s7.f4: got %d but expected %d\n", s7.f4, 4);
6036         }
6037         if (s7.f5 != 5) {
6038                 fprintf(stderr, "mono_return_sbyte7 s7.f5: got %d but expected %d\n", s7.f5, 5);
6039         }
6040         if (s7.f6 != 6) {
6041                 fprintf(stderr, "mono_return_sbyte7 s7.f6: got %d but expected %d\n", s7.f6, 6);
6042         }
6043         if (s7.f7 != 7) {
6044                 fprintf(stderr, "mono_return_sbyte7 s7.f7: got %d but expected %d\n", s7.f7, 7);
6045         }
6046         s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
6047         return s7;
6048 }
6049
6050 typedef struct {
6051         char f1,f2,f3,f4,f5,f6,f7,f8;
6052 } sbyte8;
6053
6054 LIBTEST_API sbyte8 STDCALL
6055 mono_return_sbyte8 (sbyte8 s8, int addend) {
6056         if (s8.f1 != 1) {
6057                 fprintf(stderr, "mono_return_sbyte8 s8.f1: got %d but expected %d\n", s8.f1, 1);
6058         }
6059         if (s8.f2 != 2) {
6060                 fprintf(stderr, "mono_return_sbyte8 s8.f2: got %d but expected %d\n", s8.f2, 2);
6061         }
6062         if (s8.f3 != 3) {
6063                 fprintf(stderr, "mono_return_sbyte8 s8.f3: got %d but expected %d\n", s8.f3, 3);
6064         }
6065         if (s8.f4 != 4) {
6066                 fprintf(stderr, "mono_return_sbyte8 s8.f4: got %d but expected %d\n", s8.f4, 4);
6067         }
6068         if (s8.f5 != 5) {
6069                 fprintf(stderr, "mono_return_sbyte8 s8.f5: got %d but expected %d\n", s8.f5, 5);
6070         }
6071         if (s8.f6 != 6) {
6072                 fprintf(stderr, "mono_return_sbyte8 s8.f6: got %d but expected %d\n", s8.f6, 6);
6073         }
6074         if (s8.f7 != 7) {
6075                 fprintf(stderr, "mono_return_sbyte8 s8.f7: got %d but expected %d\n", s8.f7, 7);
6076         }
6077         if (s8.f8 != 8) {
6078                 fprintf(stderr, "mono_return_sbyte8 s8.f8: got %d but expected %d\n", s8.f8, 8);
6079         }
6080         s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
6081         return s8;
6082 }
6083
6084 typedef struct {
6085         char f1,f2,f3,f4,f5,f6,f7,f8,f9;
6086 } sbyte9;
6087
6088 LIBTEST_API sbyte9 STDCALL
6089 mono_return_sbyte9 (sbyte9 s9, int addend) {
6090         if (s9.f1 != 1) {
6091                 fprintf(stderr, "mono_return_sbyte9 s9.f1: got %d but expected %d\n", s9.f1, 1);
6092         }
6093         if (s9.f2 != 2) {
6094                 fprintf(stderr, "mono_return_sbyte9 s9.f2: got %d but expected %d\n", s9.f2, 2);
6095         }
6096         if (s9.f3 != 3) {
6097                 fprintf(stderr, "mono_return_sbyte9 s9.f3: got %d but expected %d\n", s9.f3, 3);
6098         }
6099         if (s9.f4 != 4) {
6100                 fprintf(stderr, "mono_return_sbyte9 s9.f4: got %d but expected %d\n", s9.f4, 4);
6101         }
6102         if (s9.f5 != 5) {
6103                 fprintf(stderr, "mono_return_sbyte9 s9.f5: got %d but expected %d\n", s9.f5, 5);
6104         }
6105         if (s9.f6 != 6) {
6106                 fprintf(stderr, "mono_return_sbyte9 s9.f6: got %d but expected %d\n", s9.f6, 6);
6107         }
6108         if (s9.f7 != 7) {
6109                 fprintf(stderr, "mono_return_sbyte9 s9.f7: got %d but expected %d\n", s9.f7, 7);
6110         }
6111         if (s9.f8 != 8) {
6112                 fprintf(stderr, "mono_return_sbyte9 s9.f8: got %d but expected %d\n", s9.f8, 8);
6113         }
6114         if (s9.f9 != 9) {
6115                 fprintf(stderr, "mono_return_sbyte9 s9.f9: got %d but expected %d\n", s9.f9, 9);
6116         }
6117         s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
6118         return s9;
6119 }
6120
6121 typedef struct {
6122         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10;
6123 } sbyte10;
6124
6125 LIBTEST_API sbyte10 STDCALL
6126 mono_return_sbyte10 (sbyte10 s10, int addend) {
6127         if (s10.f1 != 1) {
6128                 fprintf(stderr, "mono_return_sbyte10 s10.f1: got %d but expected %d\n", s10.f1, 1);
6129         }
6130         if (s10.f2 != 2) {
6131                 fprintf(stderr, "mono_return_sbyte10 s10.f2: got %d but expected %d\n", s10.f2, 2);
6132         }
6133         if (s10.f3 != 3) {
6134                 fprintf(stderr, "mono_return_sbyte10 s10.f3: got %d but expected %d\n", s10.f3, 3);
6135         }
6136         if (s10.f4 != 4) {
6137                 fprintf(stderr, "mono_return_sbyte10 s10.f4: got %d but expected %d\n", s10.f4, 4);
6138         }
6139         if (s10.f5 != 5) {
6140                 fprintf(stderr, "mono_return_sbyte10 s10.f5: got %d but expected %d\n", s10.f5, 5);
6141         }
6142         if (s10.f6 != 6) {
6143                 fprintf(stderr, "mono_return_sbyte10 s10.f6: got %d but expected %d\n", s10.f6, 6);
6144         }
6145         if (s10.f7 != 7) {
6146                 fprintf(stderr, "mono_return_sbyte10 s10.f7: got %d but expected %d\n", s10.f7, 7);
6147         }
6148         if (s10.f8 != 8) {
6149                 fprintf(stderr, "mono_return_sbyte10 s10.f8: got %d but expected %d\n", s10.f8, 8);
6150         }
6151         if (s10.f9 != 9) {
6152                 fprintf(stderr, "mono_return_sbyte10 s10.f9: got %d but expected %d\n", s10.f9, 9);
6153         }
6154         if (s10.f10 != 10) {
6155                 fprintf(stderr, "mono_return_sbyte10 s10.f10: got %d but expected %d\n", s10.f10, 10);
6156         }
6157         s10.f1+=addend; s10.f2+=addend; s10.f3+=addend; s10.f4+=addend; s10.f5+=addend; s10.f6+=addend; s10.f7+=addend; s10.f8+=addend; s10.f9+=addend; s10.f10+=addend;
6158         return s10;
6159 }
6160
6161 typedef struct {
6162         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11;
6163 } sbyte11;
6164
6165 LIBTEST_API sbyte11 STDCALL
6166 mono_return_sbyte11 (sbyte11 s11, int addend) {
6167         if (s11.f1 != 1) {
6168                 fprintf(stderr, "mono_return_sbyte11 s11.f1: got %d but expected %d\n", s11.f1, 1);
6169         }
6170         if (s11.f2 != 2) {
6171                 fprintf(stderr, "mono_return_sbyte11 s11.f2: got %d but expected %d\n", s11.f2, 2);
6172         }
6173         if (s11.f3 != 3) {
6174                 fprintf(stderr, "mono_return_sbyte11 s11.f3: got %d but expected %d\n", s11.f3, 3);
6175         }
6176         if (s11.f4 != 4) {
6177                 fprintf(stderr, "mono_return_sbyte11 s11.f4: got %d but expected %d\n", s11.f4, 4);
6178         }
6179         if (s11.f5 != 5) {
6180                 fprintf(stderr, "mono_return_sbyte11 s11.f5: got %d but expected %d\n", s11.f5, 5);
6181         }
6182         if (s11.f6 != 6) {
6183                 fprintf(stderr, "mono_return_sbyte11 s11.f6: got %d but expected %d\n", s11.f6, 6);
6184         }
6185         if (s11.f7 != 7) {
6186                 fprintf(stderr, "mono_return_sbyte11 s11.f7: got %d but expected %d\n", s11.f7, 7);
6187         }
6188         if (s11.f8 != 8) {
6189                 fprintf(stderr, "mono_return_sbyte11 s11.f8: got %d but expected %d\n", s11.f8, 8);
6190         }
6191         if (s11.f9 != 9) {
6192                 fprintf(stderr, "mono_return_sbyte11 s11.f9: got %d but expected %d\n", s11.f9, 9);
6193         }
6194         if (s11.f10 != 10) {
6195                 fprintf(stderr, "mono_return_sbyte11 s11.f10: got %d but expected %d\n", s11.f10, 10);
6196         }
6197         if (s11.f11 != 11) {
6198                 fprintf(stderr, "mono_return_sbyte11 s11.f11: got %d but expected %d\n", s11.f11, 11);
6199         }
6200         s11.f1+=addend; s11.f2+=addend; s11.f3+=addend; s11.f4+=addend; s11.f5+=addend; s11.f6+=addend; s11.f7+=addend; s11.f8+=addend; s11.f9+=addend; s11.f10+=addend; s11.f11+=addend;
6201         return s11;
6202 }
6203
6204 typedef struct {
6205         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12;
6206 } sbyte12;
6207
6208 LIBTEST_API sbyte12 STDCALL
6209 mono_return_sbyte12 (sbyte12 s12, int addend) {
6210         if (s12.f1 != 1) {
6211                 fprintf(stderr, "mono_return_sbyte12 s12.f1: got %d but expected %d\n", s12.f1, 1);
6212         }
6213         if (s12.f2 != 2) {
6214                 fprintf(stderr, "mono_return_sbyte12 s12.f2: got %d but expected %d\n", s12.f2, 2);
6215         }
6216         if (s12.f3 != 3) {
6217                 fprintf(stderr, "mono_return_sbyte12 s12.f3: got %d but expected %d\n", s12.f3, 3);
6218         }
6219         if (s12.f4 != 4) {
6220                 fprintf(stderr, "mono_return_sbyte12 s12.f4: got %d but expected %d\n", s12.f4, 4);
6221         }
6222         if (s12.f5 != 5) {
6223                 fprintf(stderr, "mono_return_sbyte12 s12.f5: got %d but expected %d\n", s12.f5, 5);
6224         }
6225         if (s12.f6 != 6) {
6226                 fprintf(stderr, "mono_return_sbyte12 s12.f6: got %d but expected %d\n", s12.f6, 6);
6227         }
6228         if (s12.f7 != 7) {
6229                 fprintf(stderr, "mono_return_sbyte12 s12.f7: got %d but expected %d\n", s12.f7, 7);
6230         }
6231         if (s12.f8 != 8) {
6232                 fprintf(stderr, "mono_return_sbyte12 s12.f8: got %d but expected %d\n", s12.f8, 8);
6233         }
6234         if (s12.f9 != 9) {
6235                 fprintf(stderr, "mono_return_sbyte12 s12.f9: got %d but expected %d\n", s12.f9, 9);
6236         }
6237         if (s12.f10 != 10) {
6238                 fprintf(stderr, "mono_return_sbyte12 s12.f10: got %d but expected %d\n", s12.f10, 10);
6239         }
6240         if (s12.f11 != 11) {
6241                 fprintf(stderr, "mono_return_sbyte12 s12.f11: got %d but expected %d\n", s12.f11, 11);
6242         }
6243         if (s12.f12 != 12) {
6244                 fprintf(stderr, "mono_return_sbyte12 s12.f12: got %d but expected %d\n", s12.f12, 12);
6245         }
6246         s12.f1+=addend; s12.f2+=addend; s12.f3+=addend; s12.f4+=addend; s12.f5+=addend; s12.f6+=addend; s12.f7+=addend; s12.f8+=addend; s12.f9+=addend; s12.f10+=addend; s12.f11+=addend; s12.f12+=addend;
6247         return s12;
6248 }
6249
6250 typedef struct {
6251         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13;
6252 } sbyte13;
6253
6254 LIBTEST_API sbyte13 STDCALL
6255 mono_return_sbyte13 (sbyte13 s13, int addend) {
6256         if (s13.f1 != 1) {
6257                 fprintf(stderr, "mono_return_sbyte13 s13.f1: got %d but expected %d\n", s13.f1, 1);
6258         }
6259         if (s13.f2 != 2) {
6260                 fprintf(stderr, "mono_return_sbyte13 s13.f2: got %d but expected %d\n", s13.f2, 2);
6261         }
6262         if (s13.f3 != 3) {
6263                 fprintf(stderr, "mono_return_sbyte13 s13.f3: got %d but expected %d\n", s13.f3, 3);
6264         }
6265         if (s13.f4 != 4) {
6266                 fprintf(stderr, "mono_return_sbyte13 s13.f4: got %d but expected %d\n", s13.f4, 4);
6267         }
6268         if (s13.f5 != 5) {
6269                 fprintf(stderr, "mono_return_sbyte13 s13.f5: got %d but expected %d\n", s13.f5, 5);
6270         }
6271         if (s13.f6 != 6) {
6272                 fprintf(stderr, "mono_return_sbyte13 s13.f6: got %d but expected %d\n", s13.f6, 6);
6273         }
6274         if (s13.f7 != 7) {
6275                 fprintf(stderr, "mono_return_sbyte13 s13.f7: got %d but expected %d\n", s13.f7, 7);
6276         }
6277         if (s13.f8 != 8) {
6278                 fprintf(stderr, "mono_return_sbyte13 s13.f8: got %d but expected %d\n", s13.f8, 8);
6279         }
6280         if (s13.f9 != 9) {
6281                 fprintf(stderr, "mono_return_sbyte13 s13.f9: got %d but expected %d\n", s13.f9, 9);
6282         }
6283         if (s13.f10 != 10) {
6284                 fprintf(stderr, "mono_return_sbyte13 s13.f10: got %d but expected %d\n", s13.f10, 10);
6285         }
6286         if (s13.f11 != 11) {
6287                 fprintf(stderr, "mono_return_sbyte13 s13.f11: got %d but expected %d\n", s13.f11, 11);
6288         }
6289         if (s13.f12 != 12) {
6290                 fprintf(stderr, "mono_return_sbyte13 s13.f12: got %d but expected %d\n", s13.f12, 12);
6291         }
6292         if (s13.f13 != 13) {
6293                 fprintf(stderr, "mono_return_sbyte13 s13.f13: got %d but expected %d\n", s13.f13, 13);
6294         }
6295         s13.f1+=addend; s13.f2+=addend; s13.f3+=addend; s13.f4+=addend; s13.f5+=addend; s13.f6+=addend; s13.f7+=addend; s13.f8+=addend; s13.f9+=addend; s13.f10+=addend; s13.f11+=addend; s13.f12+=addend; s13.f13+=addend;
6296         return s13;
6297 }
6298
6299 typedef struct {
6300         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14;
6301 } sbyte14;
6302
6303 LIBTEST_API sbyte14 STDCALL
6304 mono_return_sbyte14 (sbyte14 s14, int addend) {
6305         if (s14.f1 != 1) {
6306                 fprintf(stderr, "mono_return_sbyte14 s14.f1: got %d but expected %d\n", s14.f1, 1);
6307         }
6308         if (s14.f2 != 2) {
6309                 fprintf(stderr, "mono_return_sbyte14 s14.f2: got %d but expected %d\n", s14.f2, 2);
6310         }
6311         if (s14.f3 != 3) {
6312                 fprintf(stderr, "mono_return_sbyte14 s14.f3: got %d but expected %d\n", s14.f3, 3);
6313         }
6314         if (s14.f4 != 4) {
6315                 fprintf(stderr, "mono_return_sbyte14 s14.f4: got %d but expected %d\n", s14.f4, 4);
6316         }
6317         if (s14.f5 != 5) {
6318                 fprintf(stderr, "mono_return_sbyte14 s14.f5: got %d but expected %d\n", s14.f5, 5);
6319         }
6320         if (s14.f6 != 6) {
6321                 fprintf(stderr, "mono_return_sbyte14 s14.f6: got %d but expected %d\n", s14.f6, 6);
6322         }
6323         if (s14.f7 != 7) {
6324                 fprintf(stderr, "mono_return_sbyte14 s14.f7: got %d but expected %d\n", s14.f7, 7);
6325         }
6326         if (s14.f8 != 8) {
6327                 fprintf(stderr, "mono_return_sbyte14 s14.f8: got %d but expected %d\n", s14.f8, 8);
6328         }
6329         if (s14.f9 != 9) {
6330                 fprintf(stderr, "mono_return_sbyte14 s14.f9: got %d but expected %d\n", s14.f9, 9);
6331         }
6332         if (s14.f10 != 10) {
6333                 fprintf(stderr, "mono_return_sbyte14 s14.f10: got %d but expected %d\n", s14.f10, 10);
6334         }
6335         if (s14.f11 != 11) {
6336                 fprintf(stderr, "mono_return_sbyte14 s14.f11: got %d but expected %d\n", s14.f11, 11);
6337         }
6338         if (s14.f12 != 12) {
6339                 fprintf(stderr, "mono_return_sbyte14 s14.f12: got %d but expected %d\n", s14.f12, 12);
6340         }
6341         if (s14.f13 != 13) {
6342                 fprintf(stderr, "mono_return_sbyte14 s14.f13: got %d but expected %d\n", s14.f13, 13);
6343         }
6344         if (s14.f14 != 14) {
6345                 fprintf(stderr, "mono_return_sbyte14 s14.f14: got %d but expected %d\n", s14.f14, 14);
6346         }
6347         s14.f1+=addend; s14.f2+=addend; s14.f3+=addend; s14.f4+=addend; s14.f5+=addend; s14.f6+=addend; s14.f7+=addend; s14.f8+=addend; s14.f9+=addend; s14.f10+=addend; s14.f11+=addend; s14.f12+=addend; s14.f13+=addend; s14.f14+=addend;
6348         return s14;
6349 }
6350
6351 typedef struct {
6352         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15;
6353 } sbyte15;
6354
6355 LIBTEST_API sbyte15 STDCALL
6356 mono_return_sbyte15 (sbyte15 s15, int addend) {
6357         if (s15.f1 != 1) {
6358                 fprintf(stderr, "mono_return_sbyte15 s15.f1: got %d but expected %d\n", s15.f1, 1);
6359         }
6360         if (s15.f2 != 2) {
6361                 fprintf(stderr, "mono_return_sbyte15 s15.f2: got %d but expected %d\n", s15.f2, 2);
6362         }
6363         if (s15.f3 != 3) {
6364                 fprintf(stderr, "mono_return_sbyte15 s15.f3: got %d but expected %d\n", s15.f3, 3);
6365         }
6366         if (s15.f4 != 4) {
6367                 fprintf(stderr, "mono_return_sbyte15 s15.f4: got %d but expected %d\n", s15.f4, 4);
6368         }
6369         if (s15.f5 != 5) {
6370                 fprintf(stderr, "mono_return_sbyte15 s15.f5: got %d but expected %d\n", s15.f5, 5);
6371         }
6372         if (s15.f6 != 6) {
6373                 fprintf(stderr, "mono_return_sbyte15 s15.f6: got %d but expected %d\n", s15.f6, 6);
6374         }
6375         if (s15.f7 != 7) {
6376                 fprintf(stderr, "mono_return_sbyte15 s15.f7: got %d but expected %d\n", s15.f7, 7);
6377         }
6378         if (s15.f8 != 8) {
6379                 fprintf(stderr, "mono_return_sbyte15 s15.f8: got %d but expected %d\n", s15.f8, 8);
6380         }
6381         if (s15.f9 != 9) {
6382                 fprintf(stderr, "mono_return_sbyte15 s15.f9: got %d but expected %d\n", s15.f9, 9);
6383         }
6384         if (s15.f10 != 10) {
6385                 fprintf(stderr, "mono_return_sbyte15 s15.f10: got %d but expected %d\n", s15.f10, 10);
6386         }
6387         if (s15.f11 != 11) {
6388                 fprintf(stderr, "mono_return_sbyte15 s15.f11: got %d but expected %d\n", s15.f11, 11);
6389         }
6390         if (s15.f12 != 12) {
6391                 fprintf(stderr, "mono_return_sbyte15 s15.f12: got %d but expected %d\n", s15.f12, 12);
6392         }
6393         if (s15.f13 != 13) {
6394                 fprintf(stderr, "mono_return_sbyte15 s15.f13: got %d but expected %d\n", s15.f13, 13);
6395         }
6396         if (s15.f14 != 14) {
6397                 fprintf(stderr, "mono_return_sbyte15 s15.f14: got %d but expected %d\n", s15.f14, 14);
6398         }
6399         if (s15.f15 != 15) {
6400                 fprintf(stderr, "mono_return_sbyte15 s15.f15: got %d but expected %d\n", s15.f15, 15);
6401         }
6402         s15.f1+=addend; s15.f2+=addend; s15.f3+=addend; s15.f4+=addend; s15.f5+=addend; s15.f6+=addend; s15.f7+=addend; s15.f8+=addend; s15.f9+=addend; s15.f10+=addend; s15.f11+=addend; s15.f12+=addend; s15.f13+=addend; s15.f14+=addend; s15.f15+=addend;
6403         return s15;
6404 }
6405
6406 typedef struct {
6407         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16;
6408 } sbyte16;
6409
6410 LIBTEST_API sbyte16 STDCALL
6411 mono_return_sbyte16 (sbyte16 s16, int addend) {
6412         if (s16.f1 != 1) {
6413                 fprintf(stderr, "mono_return_sbyte16 s16.f1: got %d but expected %d\n", s16.f1, 1);
6414         }
6415         if (s16.f2 != 2) {
6416                 fprintf(stderr, "mono_return_sbyte16 s16.f2: got %d but expected %d\n", s16.f2, 2);
6417         }
6418         if (s16.f3 != 3) {
6419                 fprintf(stderr, "mono_return_sbyte16 s16.f3: got %d but expected %d\n", s16.f3, 3);
6420         }
6421         if (s16.f4 != 4) {
6422                 fprintf(stderr, "mono_return_sbyte16 s16.f4: got %d but expected %d\n", s16.f4, 4);
6423         }
6424         if (s16.f5 != 5) {
6425                 fprintf(stderr, "mono_return_sbyte16 s16.f5: got %d but expected %d\n", s16.f5, 5);
6426         }
6427         if (s16.f6 != 6) {
6428                 fprintf(stderr, "mono_return_sbyte16 s16.f6: got %d but expected %d\n", s16.f6, 6);
6429         }
6430         if (s16.f7 != 7) {
6431                 fprintf(stderr, "mono_return_sbyte16 s16.f7: got %d but expected %d\n", s16.f7, 7);
6432         }
6433         if (s16.f8 != 8) {
6434                 fprintf(stderr, "mono_return_sbyte16 s16.f8: got %d but expected %d\n", s16.f8, 8);
6435         }
6436         if (s16.f9 != 9) {
6437                 fprintf(stderr, "mono_return_sbyte16 s16.f9: got %d but expected %d\n", s16.f9, 9);
6438         }
6439         if (s16.f10 != 10) {
6440                 fprintf(stderr, "mono_return_sbyte16 s16.f10: got %d but expected %d\n", s16.f10, 10);
6441         }
6442         if (s16.f11 != 11) {
6443                 fprintf(stderr, "mono_return_sbyte16 s16.f11: got %d but expected %d\n", s16.f11, 11);
6444         }
6445         if (s16.f12 != 12) {
6446                 fprintf(stderr, "mono_return_sbyte16 s16.f12: got %d but expected %d\n", s16.f12, 12);
6447         }
6448         if (s16.f13 != 13) {
6449                 fprintf(stderr, "mono_return_sbyte16 s16.f13: got %d but expected %d\n", s16.f13, 13);
6450         }
6451         if (s16.f14 != 14) {
6452                 fprintf(stderr, "mono_return_sbyte16 s16.f14: got %d but expected %d\n", s16.f14, 14);
6453         }
6454         if (s16.f15 != 15) {
6455                 fprintf(stderr, "mono_return_sbyte16 s16.f15: got %d but expected %d\n", s16.f15, 15);
6456         }
6457         if (s16.f16 != 16) {
6458                 fprintf(stderr, "mono_return_sbyte16 s16.f16: got %d but expected %d\n", s16.f16, 16);
6459         }
6460         s16.f1+=addend; s16.f2+=addend; s16.f3+=addend; s16.f4+=addend; s16.f5+=addend; s16.f6+=addend; s16.f7+=addend; s16.f8+=addend; s16.f9+=addend; s16.f10+=addend; s16.f11+=addend; s16.f12+=addend; s16.f13+=addend; s16.f14+=addend; s16.f15+=addend; s16.f16+=addend;
6461         return s16;
6462 }
6463
6464 typedef struct {
6465         char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17;
6466 } sbyte17;
6467
6468 LIBTEST_API sbyte17 STDCALL
6469 mono_return_sbyte17 (sbyte17 s17, int addend) {
6470         if (s17.f1 != 1) {
6471                 fprintf(stderr, "mono_return_sbyte17 s17.f1: got %d but expected %d\n", s17.f1, 1);
6472         }
6473         if (s17.f2 != 2) {
6474                 fprintf(stderr, "mono_return_sbyte17 s17.f2: got %d but expected %d\n", s17.f2, 2);
6475         }
6476         if (s17.f3 != 3) {
6477                 fprintf(stderr, "mono_return_sbyte17 s17.f3: got %d but expected %d\n", s17.f3, 3);
6478         }
6479         if (s17.f4 != 4) {
6480                 fprintf(stderr, "mono_return_sbyte17 s17.f4: got %d but expected %d\n", s17.f4, 4);
6481         }
6482         if (s17.f5 != 5) {
6483                 fprintf(stderr, "mono_return_sbyte17 s17.f5: got %d but expected %d\n", s17.f5, 5);
6484         }
6485         if (s17.f6 != 6) {
6486                 fprintf(stderr, "mono_return_sbyte17 s17.f6: got %d but expected %d\n", s17.f6, 6);
6487         }
6488         if (s17.f7 != 7) {
6489                 fprintf(stderr, "mono_return_sbyte17 s17.f7: got %d but expected %d\n", s17.f7, 7);
6490         }
6491         if (s17.f8 != 8) {
6492                 fprintf(stderr, "mono_return_sbyte17 s17.f8: got %d but expected %d\n", s17.f8, 8);
6493         }
6494         if (s17.f9 != 9) {
6495                 fprintf(stderr, "mono_return_sbyte17 s17.f9: got %d but expected %d\n", s17.f9, 9);
6496         }
6497         if (s17.f10 != 10) {
6498                 fprintf(stderr, "mono_return_sbyte17 s17.f10: got %d but expected %d\n", s17.f10, 10);
6499         }
6500         if (s17.f11 != 11) {
6501                 fprintf(stderr, "mono_return_sbyte17 s17.f11: got %d but expected %d\n", s17.f11, 11);
6502         }
6503         if (s17.f12 != 12) {
6504                 fprintf(stderr, "mono_return_sbyte17 s17.f12: got %d but expected %d\n", s17.f12, 12);
6505         }
6506         if (s17.f13 != 13) {
6507                 fprintf(stderr, "mono_return_sbyte17 s17.f13: got %d but expected %d\n", s17.f13, 13);
6508         }
6509         if (s17.f14 != 14) {
6510                 fprintf(stderr, "mono_return_sbyte17 s17.f14: got %d but expected %d\n", s17.f14, 14);
6511         }
6512         if (s17.f15 != 15) {
6513                 fprintf(stderr, "mono_return_sbyte17 s17.f15: got %d but expected %d\n", s17.f15, 15);
6514         }
6515         if (s17.f16 != 16) {
6516                 fprintf(stderr, "mono_return_sbyte17 s17.f16: got %d but expected %d\n", s17.f16, 16);
6517         }
6518         if (s17.f17 != 17) {
6519                 fprintf(stderr, "mono_return_sbyte17 s17.f17: got %d but expected %d\n", s17.f17, 17);
6520         }
6521         s17.f1+=addend; s17.f2+=addend; s17.f3+=addend; s17.f4+=addend; s17.f5+=addend; s17.f6+=addend; s17.f7+=addend; s17.f8+=addend; s17.f9+=addend; s17.f10+=addend; s17.f11+=addend; s17.f12+=addend; s17.f13+=addend; s17.f14+=addend; s17.f15+=addend; s17.f16+=addend; s17.f17+=addend;
6522         return s17;
6523 }
6524
6525 typedef struct {
6526         struct {
6527                 char f1;
6528         } nested1;
6529         char f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15;
6530         struct {
6531                 char f16;
6532         } nested2;
6533 } sbyte16_nested;
6534
6535 LIBTEST_API sbyte16_nested STDCALL
6536 mono_return_sbyte16_nested (sbyte16_nested sn16, int addend) {
6537         if (sn16.nested1.f1 != 1) {
6538                 fprintf(stderr, "mono_return_sbyte16_nested sn16.nested1.f1: got %d but expected %d\n", sn16.nested1.f1, 1);
6539         }
6540         if (sn16.f2 != 2) {
6541                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f2: got %d but expected %d\n", sn16.f2, 2);
6542         }
6543         if (sn16.f3 != 3) {
6544                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f3: got %d but expected %d\n", sn16.f3, 3);
6545         }
6546         if (sn16.f4 != 4) {
6547                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f4: got %d but expected %d\n", sn16.f4, 4);
6548         }
6549         if (sn16.f5 != 5) {
6550                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f5: got %d but expected %d\n", sn16.f5, 5);
6551         }
6552         if (sn16.f6 != 6) {
6553                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f6: got %d but expected %d\n", sn16.f6, 6);
6554         }
6555         if (sn16.f7 != 7) {
6556                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f7: got %d but expected %d\n", sn16.f7, 7);
6557         }
6558         if (sn16.f8 != 8) {
6559                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f8: got %d but expected %d\n", sn16.f8, 8);
6560         }
6561         if (sn16.f9 != 9) {
6562                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f9: got %d but expected %d\n", sn16.f9, 9);
6563         }
6564         if (sn16.f10 != 10) {
6565                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f10: got %d but expected %d\n", sn16.f10, 10);
6566         }
6567         if (sn16.f11 != 11) {
6568                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f11: got %d but expected %d\n", sn16.f11, 11);
6569         }
6570         if (sn16.f12 != 12) {
6571                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f12: got %d but expected %d\n", sn16.f12, 12);
6572         }
6573         if (sn16.f13 != 13) {
6574                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f13: got %d but expected %d\n", sn16.f13, 13);
6575         }
6576         if (sn16.f14 != 14) {
6577                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f14: got %d but expected %d\n", sn16.f14, 14);
6578         }
6579         if (sn16.f15 != 15) {
6580                 fprintf(stderr, "mono_return_sbyte16_nested sn16.f15: got %d but expected %d\n", sn16.f15, 15);
6581         }
6582         if (sn16.nested2.f16 != 16) {
6583                 fprintf(stderr, "mono_return_sbyte16_nested sn16.nested2.f16: got %d but expected %d\n", sn16.nested2.f16, 16);
6584         }
6585         sn16.nested1.f1+=addend; sn16.f2+=addend; sn16.f3+=addend; sn16.f4+=addend; sn16.f5+=addend; sn16.f6+=addend; sn16.f7+=addend; sn16.f8+=addend; sn16.f9+=addend; sn16.f10+=addend; sn16.f11+=addend; sn16.f12+=addend; sn16.f13+=addend; sn16.f14+=addend; sn16.f15+=addend; sn16.nested2.f16+=addend;
6586         return sn16;
6587 }
6588
6589
6590 typedef struct {
6591         short f1;
6592 } short1;
6593
6594 LIBTEST_API short1 STDCALL
6595 mono_return_short1 (short1 s1, int addend) {
6596         if (s1.f1 != 1) {
6597                 fprintf(stderr, "mono_return_short1 s1.f1: got %d but expected %d\n", s1.f1, 1);
6598         }
6599         s1.f1+=addend;
6600         return s1;
6601 }
6602
6603 typedef struct {
6604         short f1,f2;
6605 } short2;
6606
6607 LIBTEST_API short2 STDCALL
6608 mono_return_short2 (short2 s2, int addend) {
6609         if (s2.f1 != 1) {
6610                 fprintf(stderr, "mono_return_short2 s2.f1: got %d but expected %d\n", s2.f1, 1);
6611         }
6612         if (s2.f2 != 2) {
6613                 fprintf(stderr, "mono_return_short2 s2.f2: got %d but expected %d\n", s2.f2, 2);
6614         }
6615         s2.f1+=addend; s2.f2+=addend;
6616         return s2;
6617 }
6618
6619 typedef struct {
6620         short f1,f2,f3;
6621 } short3;
6622
6623 LIBTEST_API short3 STDCALL
6624 mono_return_short3 (short3 s3, int addend) {
6625         if (s3.f1 != 1) {
6626                 fprintf(stderr, "mono_return_short3 s3.f1: got %d but expected %d\n", s3.f1, 1);
6627         }
6628         if (s3.f2 != 2) {
6629                 fprintf(stderr, "mono_return_short3 s3.f2: got %d but expected %d\n", s3.f2, 2);
6630         }
6631         if (s3.f3 != 3) {
6632                 fprintf(stderr, "mono_return_short3 s3.f3: got %d but expected %d\n", s3.f3, 3);
6633         }
6634         s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
6635         return s3;
6636 }
6637
6638 typedef struct {
6639         short f1,f2,f3,f4;
6640 } short4;
6641
6642 LIBTEST_API short4 STDCALL
6643 mono_return_short4 (short4 s4, int addend) {
6644         if (s4.f1 != 1) {
6645                 fprintf(stderr, "mono_return_short4 s4.f1: got %d but expected %d\n", s4.f1, 1);
6646         }
6647         if (s4.f2 != 2) {
6648                 fprintf(stderr, "mono_return_short4 s4.f2: got %d but expected %d\n", s4.f2, 2);
6649         }
6650         if (s4.f3 != 3) {
6651                 fprintf(stderr, "mono_return_short4 s4.f3: got %d but expected %d\n", s4.f3, 3);
6652         }
6653         if (s4.f4 != 4) {
6654                 fprintf(stderr, "mono_return_short4 s4.f4: got %d but expected %d\n", s4.f4, 4);
6655         }
6656         s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
6657         return s4;
6658 }
6659
6660 typedef struct {
6661         short f1,f2,f3,f4,f5;
6662 } short5;
6663
6664 LIBTEST_API short5 STDCALL
6665 mono_return_short5 (short5 s5, int addend) {
6666         if (s5.f1 != 1) {
6667                 fprintf(stderr, "mono_return_short5 s5.f1: got %d but expected %d\n", s5.f1, 1);
6668         }
6669         if (s5.f2 != 2) {
6670                 fprintf(stderr, "mono_return_short5 s5.f2: got %d but expected %d\n", s5.f2, 2);
6671         }
6672         if (s5.f3 != 3) {
6673                 fprintf(stderr, "mono_return_short5 s5.f3: got %d but expected %d\n", s5.f3, 3);
6674         }
6675         if (s5.f4 != 4) {
6676                 fprintf(stderr, "mono_return_short5 s5.f4: got %d but expected %d\n", s5.f4, 4);
6677         }
6678         if (s5.f5 != 5) {
6679                 fprintf(stderr, "mono_return_short5 s5.f5: got %d but expected %d\n", s5.f5, 5);
6680         }
6681         s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
6682         return s5;
6683 }
6684
6685 typedef struct {
6686         short f1,f2,f3,f4,f5,f6;
6687 } short6;
6688
6689 LIBTEST_API short6 STDCALL
6690 mono_return_short6 (short6 s6, int addend) {
6691         if (s6.f1 != 1) {
6692                 fprintf(stderr, "mono_return_short6 s6.f1: got %d but expected %d\n", s6.f1, 1);
6693         }
6694         if (s6.f2 != 2) {
6695                 fprintf(stderr, "mono_return_short6 s6.f2: got %d but expected %d\n", s6.f2, 2);
6696         }
6697         if (s6.f3 != 3) {
6698                 fprintf(stderr, "mono_return_short6 s6.f3: got %d but expected %d\n", s6.f3, 3);
6699         }
6700         if (s6.f4 != 4) {
6701                 fprintf(stderr, "mono_return_short6 s6.f4: got %d but expected %d\n", s6.f4, 4);
6702         }
6703         if (s6.f5 != 5) {
6704                 fprintf(stderr, "mono_return_short6 s6.f5: got %d but expected %d\n", s6.f5, 5);
6705         }
6706         if (s6.f6 != 6) {
6707                 fprintf(stderr, "mono_return_short6 s6.f6: got %d but expected %d\n", s6.f6, 6);
6708         }
6709         s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
6710         return s6;
6711 }
6712
6713 typedef struct {
6714         short f1,f2,f3,f4,f5,f6,f7;
6715 } short7;
6716
6717 LIBTEST_API short7 STDCALL
6718 mono_return_short7 (short7 s7, int addend) {
6719         if (s7.f1 != 1) {
6720                 fprintf(stderr, "mono_return_short7 s7.f1: got %d but expected %d\n", s7.f1, 1);
6721         }
6722         if (s7.f2 != 2) {
6723                 fprintf(stderr, "mono_return_short7 s7.f2: got %d but expected %d\n", s7.f2, 2);
6724         }
6725         if (s7.f3 != 3) {
6726                 fprintf(stderr, "mono_return_short7 s7.f3: got %d but expected %d\n", s7.f3, 3);
6727         }
6728         if (s7.f4 != 4) {
6729                 fprintf(stderr, "mono_return_short7 s7.f4: got %d but expected %d\n", s7.f4, 4);
6730         }
6731         if (s7.f5 != 5) {
6732                 fprintf(stderr, "mono_return_short7 s7.f5: got %d but expected %d\n", s7.f5, 5);
6733         }
6734         if (s7.f6 != 6) {
6735                 fprintf(stderr, "mono_return_short7 s7.f6: got %d but expected %d\n", s7.f6, 6);
6736         }
6737         if (s7.f7 != 7) {
6738                 fprintf(stderr, "mono_return_short7 s7.f7: got %d but expected %d\n", s7.f7, 7);
6739         }
6740         s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
6741         return s7;
6742 }
6743
6744 typedef struct {
6745         short f1,f2,f3,f4,f5,f6,f7,f8;
6746 } short8;
6747
6748 LIBTEST_API short8 STDCALL
6749 mono_return_short8 (short8 s8, int addend) {
6750         if (s8.f1 != 1) {
6751                 fprintf(stderr, "mono_return_short8 s8.f1: got %d but expected %d\n", s8.f1, 1);
6752         }
6753         if (s8.f2 != 2) {
6754                 fprintf(stderr, "mono_return_short8 s8.f2: got %d but expected %d\n", s8.f2, 2);
6755         }
6756         if (s8.f3 != 3) {
6757                 fprintf(stderr, "mono_return_short8 s8.f3: got %d but expected %d\n", s8.f3, 3);
6758         }
6759         if (s8.f4 != 4) {
6760                 fprintf(stderr, "mono_return_short8 s8.f4: got %d but expected %d\n", s8.f4, 4);
6761         }
6762         if (s8.f5 != 5) {
6763                 fprintf(stderr, "mono_return_short8 s8.f5: got %d but expected %d\n", s8.f5, 5);
6764         }
6765         if (s8.f6 != 6) {
6766                 fprintf(stderr, "mono_return_short8 s8.f6: got %d but expected %d\n", s8.f6, 6);
6767         }
6768         if (s8.f7 != 7) {
6769                 fprintf(stderr, "mono_return_short8 s8.f7: got %d but expected %d\n", s8.f7, 7);
6770         }
6771         if (s8.f8 != 8) {
6772                 fprintf(stderr, "mono_return_short8 s8.f8: got %d but expected %d\n", s8.f8, 8);
6773         }
6774         s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
6775         return s8;
6776 }
6777
6778 typedef struct {
6779         short f1,f2,f3,f4,f5,f6,f7,f8,f9;
6780 } short9;
6781
6782 LIBTEST_API short9 STDCALL
6783 mono_return_short9 (short9 s9, int addend) {
6784         if (s9.f1 != 1) {
6785                 fprintf(stderr, "mono_return_short9 s9.f1: got %d but expected %d\n", s9.f1, 1);
6786         }
6787         if (s9.f2 != 2) {
6788                 fprintf(stderr, "mono_return_short9 s9.f2: got %d but expected %d\n", s9.f2, 2);
6789         }
6790         if (s9.f3 != 3) {
6791                 fprintf(stderr, "mono_return_short9 s9.f3: got %d but expected %d\n", s9.f3, 3);
6792         }
6793         if (s9.f4 != 4) {
6794                 fprintf(stderr, "mono_return_short9 s9.f4: got %d but expected %d\n", s9.f4, 4);
6795         }
6796         if (s9.f5 != 5) {
6797                 fprintf(stderr, "mono_return_short9 s9.f5: got %d but expected %d\n", s9.f5, 5);
6798         }
6799         if (s9.f6 != 6) {
6800                 fprintf(stderr, "mono_return_short9 s9.f6: got %d but expected %d\n", s9.f6, 6);
6801         }
6802         if (s9.f7 != 7) {
6803                 fprintf(stderr, "mono_return_short9 s9.f7: got %d but expected %d\n", s9.f7, 7);
6804         }
6805         if (s9.f8 != 8) {
6806                 fprintf(stderr, "mono_return_short9 s9.f8: got %d but expected %d\n", s9.f8, 8);
6807         }
6808         if (s9.f9 != 9) {
6809                 fprintf(stderr, "mono_return_short9 s9.f9: got %d but expected %d\n", s9.f9, 9);
6810         }
6811         s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
6812         return s9;
6813 }
6814
6815 typedef struct {
6816         struct {
6817                 short f1;
6818         } nested1;
6819         short f2,f3,f4,f5,f6,f7;
6820         struct {
6821                 short f8;
6822         } nested2;
6823 } short8_nested;
6824
6825 LIBTEST_API short8_nested STDCALL
6826 mono_return_short8_nested (short8_nested sn8, int addend) {
6827         if (sn8.nested1.f1 != 1) {
6828                 fprintf(stderr, "mono_return_short8_nested sn8.nested1.f1: got %d but expected %d\n", sn8.nested1.f1, 1);
6829         }
6830         if (sn8.f2 != 2) {
6831                 fprintf(stderr, "mono_return_short8_nested sn8.f2: got %d but expected %d\n", sn8.f2, 2);
6832         }
6833         if (sn8.f3 != 3) {
6834                 fprintf(stderr, "mono_return_short8_nested sn8.f3: got %d but expected %d\n", sn8.f3, 3);
6835         }
6836         if (sn8.f4 != 4) {
6837                 fprintf(stderr, "mono_return_short8_nested sn8.f4: got %d but expected %d\n", sn8.f4, 4);
6838         }
6839         if (sn8.f5 != 5) {
6840                 fprintf(stderr, "mono_return_short8_nested sn8.f5: got %d but expected %d\n", sn8.f5, 5);
6841         }
6842         if (sn8.f6 != 6) {
6843                 fprintf(stderr, "mono_return_short8_nested sn8.f6: got %d but expected %d\n", sn8.f6, 6);
6844         }
6845         if (sn8.f7 != 7) {
6846                 fprintf(stderr, "mono_return_short8_nested sn8.f7: got %d but expected %d\n", sn8.f7, 7);
6847         }
6848         if (sn8.nested2.f8 != 8) {
6849                 fprintf(stderr, "mono_return_short8_nested sn8.nested2.f8: got %d but expected %d\n", sn8.nested2.f8, 8);
6850         }
6851         sn8.nested1.f1+=addend; sn8.f2+=addend; sn8.f3+=addend; sn8.f4+=addend; sn8.f5+=addend; sn8.f6+=addend; sn8.f7+=addend; sn8.nested2.f8+=addend;
6852         return sn8;
6853 }
6854
6855
6856 typedef struct {
6857         int f1;
6858 } int1;
6859
6860 LIBTEST_API int1 STDCALL
6861 mono_return_int1 (int1 s1, int addend) {
6862         if (s1.f1 != 1) {
6863                 fprintf(stderr, "mono_return_int1 s1.f1: got %d but expected %d\n", s1.f1, 1);
6864         }
6865         s1.f1+=addend;
6866         return s1;
6867 }
6868
6869 typedef struct {
6870         int f1,f2;
6871 } int2;
6872
6873 LIBTEST_API int2 STDCALL
6874 mono_return_int2 (int2 s2, int addend) {
6875         if (s2.f1 != 1) {
6876                 fprintf(stderr, "mono_return_int2 s2.f1: got %d but expected %d\n", s2.f1, 1);
6877         }
6878         if (s2.f2 != 2) {
6879                 fprintf(stderr, "mono_return_int2 s2.f2: got %d but expected %d\n", s2.f2, 2);
6880         }
6881         s2.f1+=addend; s2.f2+=addend;
6882         return s2;
6883 }
6884
6885 typedef struct {
6886         int f1,f2,f3;
6887 } int3;
6888
6889 LIBTEST_API int3 STDCALL
6890 mono_return_int3 (int3 s3, int addend) {
6891         if (s3.f1 != 1) {
6892                 fprintf(stderr, "mono_return_int3 s3.f1: got %d but expected %d\n", s3.f1, 1);
6893         }
6894         if (s3.f2 != 2) {
6895                 fprintf(stderr, "mono_return_int3 s3.f2: got %d but expected %d\n", s3.f2, 2);
6896         }
6897         if (s3.f3 != 3) {
6898                 fprintf(stderr, "mono_return_int3 s3.f3: got %d but expected %d\n", s3.f3, 3);
6899         }
6900         s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
6901         return s3;
6902 }
6903
6904 typedef struct {
6905         int f1,f2,f3,f4;
6906 } int4;
6907
6908 LIBTEST_API int4 STDCALL
6909 mono_return_int4 (int4 s4, int addend) {
6910         if (s4.f1 != 1) {
6911                 fprintf(stderr, "mono_return_int4 s4.f1: got %d but expected %d\n", s4.f1, 1);
6912         }
6913         if (s4.f2 != 2) {
6914                 fprintf(stderr, "mono_return_int4 s4.f2: got %d but expected %d\n", s4.f2, 2);
6915         }
6916         if (s4.f3 != 3) {
6917                 fprintf(stderr, "mono_return_int4 s4.f3: got %d but expected %d\n", s4.f3, 3);
6918         }
6919         if (s4.f4 != 4) {
6920                 fprintf(stderr, "mono_return_int4 s4.f4: got %d but expected %d\n", s4.f4, 4);
6921         }
6922         s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
6923         return s4;
6924 }
6925
6926 typedef struct {
6927         int f1,f2,f3,f4,f5;
6928 } int5;
6929
6930 LIBTEST_API int5 STDCALL
6931 mono_return_int5 (int5 s5, int addend) {
6932         if (s5.f1 != 1) {
6933                 fprintf(stderr, "mono_return_int5 s5.f1: got %d but expected %d\n", s5.f1, 1);
6934         }
6935         if (s5.f2 != 2) {
6936                 fprintf(stderr, "mono_return_int5 s5.f2: got %d but expected %d\n", s5.f2, 2);
6937         }
6938         if (s5.f3 != 3) {
6939                 fprintf(stderr, "mono_return_int5 s5.f3: got %d but expected %d\n", s5.f3, 3);
6940         }
6941         if (s5.f4 != 4) {
6942                 fprintf(stderr, "mono_return_int5 s5.f4: got %d but expected %d\n", s5.f4, 4);
6943         }
6944         if (s5.f5 != 5) {
6945                 fprintf(stderr, "mono_return_int5 s5.f5: got %d but expected %d\n", s5.f5, 5);
6946         }
6947         s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
6948         return s5;
6949 }
6950
6951 typedef struct {
6952         struct {
6953                 int f1;
6954         } nested1;
6955         int f2,f3;
6956         struct {
6957                 int f4;
6958         } nested2;
6959 } int4_nested;
6960
6961 LIBTEST_API int4_nested STDCALL
6962 mono_return_int4_nested (int4_nested sn4, int addend) {
6963         if (sn4.nested1.f1 != 1) {
6964                 fprintf(stderr, "mono_return_int4_nested sn4.nested1.f1: got %d but expected %d\n", sn4.nested1.f1, 1);
6965         }
6966         if (sn4.f2 != 2) {
6967                 fprintf(stderr, "mono_return_int4_nested sn4.f2: got %d but expected %d\n", sn4.f2, 2);
6968         }
6969         if (sn4.f3 != 3) {
6970                 fprintf(stderr, "mono_return_int4_nested sn4.f3: got %d but expected %d\n", sn4.f3, 3);
6971         }
6972         if (sn4.nested2.f4 != 4) {
6973                 fprintf(stderr, "mono_return_int4_nested sn4.nested2.f4: got %d but expected %d\n", sn4.nested2.f4, 4);
6974         }
6975         sn4.nested1.f1+=addend; sn4.f2+=addend; sn4.f3+=addend; sn4.nested2.f4+=addend;
6976         return sn4;
6977 }
6978
6979 typedef struct {
6980         float f1;
6981 } float1;
6982
6983 LIBTEST_API float1 STDCALL
6984 mono_return_float1 (float1 s1, int addend) {
6985         if (s1.f1 != 1) {
6986                 fprintf(stderr, "mono_return_float1 s1.f1: got %f but expected %d\n", s1.f1, 1);
6987         }
6988         s1.f1+=addend;
6989         return s1;
6990 }
6991
6992 typedef struct {
6993         float f1,f2;
6994 } float2;
6995
6996 LIBTEST_API float2 STDCALL
6997 mono_return_float2 (float2 s2, int addend) {
6998         if (s2.f1 != 1) {
6999                 fprintf(stderr, "mono_return_float2 s2.f1: got %f but expected %d\n", s2.f1, 1);
7000         }
7001         if (s2.f2 != 2) {
7002                 fprintf(stderr, "mono_return_float2 s2.f2: got %f but expected %d\n", s2.f2, 2);
7003         }
7004         s2.f1+=addend; s2.f2+=addend;
7005         return s2;
7006 }
7007
7008 typedef struct {
7009         float f1,f2,f3;
7010 } float3;
7011
7012 LIBTEST_API float3 STDCALL
7013 mono_return_float3 (float3 s3, int addend) {
7014         if (s3.f1 != 1) {
7015                 fprintf(stderr, "mono_return_float3 s3.f1: got %f but expected %d\n", s3.f1, 1);
7016         }
7017         if (s3.f2 != 2) {
7018                 fprintf(stderr, "mono_return_float3 s3.f2: got %f but expected %d\n", s3.f2, 2);
7019         }
7020         if (s3.f3 != 3) {
7021                 fprintf(stderr, "mono_return_float3 s3.f3: got %f but expected %d\n", s3.f3, 3);
7022         }
7023         s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
7024         return s3;
7025 }
7026
7027 typedef struct {
7028         float f1,f2,f3,f4;
7029 } float4;
7030
7031 LIBTEST_API float4 STDCALL
7032 mono_return_float4 (float4 s4, int addend) {
7033         if (s4.f1 != 1) {
7034                 fprintf(stderr, "mono_return_float4 s4.f1: got %f but expected %d\n", s4.f1, 1);
7035         }
7036         if (s4.f2 != 2) {
7037                 fprintf(stderr, "mono_return_float4 s4.f2: got %f but expected %d\n", s4.f2, 2);
7038         }
7039         if (s4.f3 != 3) {
7040                 fprintf(stderr, "mono_return_float4 s4.f3: got %f but expected %d\n", s4.f3, 3);
7041         }
7042         if (s4.f4 != 4) {
7043                 fprintf(stderr, "mono_return_float4 s4.f4: got %f but expected %d\n", s4.f4, 4);
7044         }
7045         s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
7046         return s4;
7047 }
7048
7049 typedef struct {
7050         float f1,f2,f3,f4,f5;
7051 } float5;
7052
7053 LIBTEST_API float5 STDCALL
7054 mono_return_float5 (float5 s5, int addend) {
7055         if (s5.f1 != 1) {
7056                 fprintf(stderr, "mono_return_float5 s5.f1: got %f but expected %d\n", s5.f1, 1);
7057         }
7058         if (s5.f2 != 2) {
7059                 fprintf(stderr, "mono_return_float5 s5.f2: got %f but expected %d\n", s5.f2, 2);
7060         }
7061         if (s5.f3 != 3) {
7062                 fprintf(stderr, "mono_return_float5 s5.f3: got %f but expected %d\n", s5.f3, 3);
7063         }
7064         if (s5.f4 != 4) {
7065                 fprintf(stderr, "mono_return_float5 s5.f4: got %f but expected %d\n", s5.f4, 4);
7066         }
7067         if (s5.f5 != 5) {
7068                 fprintf(stderr, "mono_return_float5 s5.f5: got %f but expected %d\n", s5.f5, 5);
7069         }
7070         s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
7071         return s5;
7072 }
7073
7074 typedef struct {
7075         float f1,f2,f3,f4,f5,f6;
7076 } float6;
7077
7078 LIBTEST_API float6 STDCALL
7079 mono_return_float6 (float6 s6, int addend) {
7080         if (s6.f1 != 1) {
7081                 fprintf(stderr, "mono_return_float6 s6.f1: got %f but expected %d\n", s6.f1, 1);
7082         }
7083         if (s6.f2 != 2) {
7084                 fprintf(stderr, "mono_return_float6 s6.f2: got %f but expected %d\n", s6.f2, 2);
7085         }
7086         if (s6.f3 != 3) {
7087                 fprintf(stderr, "mono_return_float6 s6.f3: got %f but expected %d\n", s6.f3, 3);
7088         }
7089         if (s6.f4 != 4) {
7090                 fprintf(stderr, "mono_return_float6 s6.f4: got %f but expected %d\n", s6.f4, 4);
7091         }
7092         if (s6.f5 != 5) {
7093                 fprintf(stderr, "mono_return_float6 s6.f5: got %f but expected %d\n", s6.f5, 5);
7094         }
7095         if (s6.f6 != 6) {
7096                 fprintf(stderr, "mono_return_float6 s6.f6: got %f but expected %d\n", s6.f6, 6);
7097         }
7098         s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
7099         return s6;
7100 }
7101
7102 typedef struct {
7103         float f1,f2,f3,f4,f5,f6,f7;
7104 } float7;
7105
7106 LIBTEST_API float7 STDCALL
7107 mono_return_float7 (float7 s7, int addend) {
7108         if (s7.f1 != 1) {
7109                 fprintf(stderr, "mono_return_float7 s7.f1: got %f but expected %d\n", s7.f1, 1);
7110         }
7111         if (s7.f2 != 2) {
7112                 fprintf(stderr, "mono_return_float7 s7.f2: got %f but expected %d\n", s7.f2, 2);
7113         }
7114         if (s7.f3 != 3) {
7115                 fprintf(stderr, "mono_return_float7 s7.f3: got %f but expected %d\n", s7.f3, 3);
7116         }
7117         if (s7.f4 != 4) {
7118                 fprintf(stderr, "mono_return_float7 s7.f4: got %f but expected %d\n", s7.f4, 4);
7119         }
7120         if (s7.f5 != 5) {
7121                 fprintf(stderr, "mono_return_float7 s7.f5: got %f but expected %d\n", s7.f5, 5);
7122         }
7123         if (s7.f6 != 6) {
7124                 fprintf(stderr, "mono_return_float7 s7.f6: got %f but expected %d\n", s7.f6, 6);
7125         }
7126         if (s7.f7 != 7) {
7127                 fprintf(stderr, "mono_return_float7 s7.f7: got %f but expected %d\n", s7.f7, 7);
7128         }
7129         s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
7130         return s7;
7131 }
7132
7133 typedef struct {
7134         float f1,f2,f3,f4,f5,f6,f7,f8;
7135 } float8;
7136
7137 LIBTEST_API float8 STDCALL
7138 mono_return_float8 (float8 s8, int addend) {
7139         if (s8.f1 != 1) {
7140                 fprintf(stderr, "mono_return_float8 s8.f1: got %f but expected %d\n", s8.f1, 1);
7141         }
7142         if (s8.f2 != 2) {
7143                 fprintf(stderr, "mono_return_float8 s8.f2: got %f but expected %d\n", s8.f2, 2);
7144         }
7145         if (s8.f3 != 3) {
7146                 fprintf(stderr, "mono_return_float8 s8.f3: got %f but expected %d\n", s8.f3, 3);
7147         }
7148         if (s8.f4 != 4) {
7149                 fprintf(stderr, "mono_return_float8 s8.f4: got %f but expected %d\n", s8.f4, 4);
7150         }
7151         if (s8.f5 != 5) {
7152                 fprintf(stderr, "mono_return_float8 s8.f5: got %f but expected %d\n", s8.f5, 5);
7153         }
7154         if (s8.f6 != 6) {
7155                 fprintf(stderr, "mono_return_float8 s8.f6: got %f but expected %d\n", s8.f6, 6);
7156         }
7157         if (s8.f7 != 7) {
7158                 fprintf(stderr, "mono_return_float8 s8.f7: got %f but expected %d\n", s8.f7, 7);
7159         }
7160         if (s8.f8 != 8) {
7161                 fprintf(stderr, "mono_return_float8 s8.f8: got %f but expected %d\n", s8.f8, 8);
7162         }
7163         s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
7164         return s8;
7165 }
7166
7167 typedef struct {
7168         float f1,f2,f3,f4,f5,f6,f7,f8,f9;
7169 } float9;
7170
7171 LIBTEST_API float9 STDCALL
7172 mono_return_float9 (float9 s9, int addend) {
7173         if (s9.f1 != 1) {
7174                 fprintf(stderr, "mono_return_float9 s9.f1: got %f but expected %d\n", s9.f1, 1);
7175         }
7176         if (s9.f2 != 2) {
7177                 fprintf(stderr, "mono_return_float9 s9.f2: got %f but expected %d\n", s9.f2, 2);
7178         }
7179         if (s9.f3 != 3) {
7180                 fprintf(stderr, "mono_return_float9 s9.f3: got %f but expected %d\n", s9.f3, 3);
7181         }
7182         if (s9.f4 != 4) {
7183                 fprintf(stderr, "mono_return_float9 s9.f4: got %f but expected %d\n", s9.f4, 4);
7184         }
7185         if (s9.f5 != 5) {
7186                 fprintf(stderr, "mono_return_float9 s9.f5: got %f but expected %d\n", s9.f5, 5);
7187         }
7188         if (s9.f6 != 6) {
7189                 fprintf(stderr, "mono_return_float9 s9.f6: got %f but expected %d\n", s9.f6, 6);
7190         }
7191         if (s9.f7 != 7) {
7192                 fprintf(stderr, "mono_return_float9 s9.f7: got %f but expected %d\n", s9.f7, 7);
7193         }
7194         if (s9.f8 != 8) {
7195                 fprintf(stderr, "mono_return_float9 s9.f8: got %f but expected %d\n", s9.f8, 8);
7196         }
7197         if (s9.f9 != 9) {
7198                 fprintf(stderr, "mono_return_float9 s9.f9: got %f but expected %d\n", s9.f9, 9);
7199         }
7200         s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
7201         return s9;
7202 }
7203
7204 typedef struct {
7205         struct {
7206                 float f1;
7207         } nested1;
7208         float f2,f3;
7209         struct {
7210                 float f4;
7211         } nested2;
7212 } float4_nested;
7213
7214 LIBTEST_API float4_nested STDCALL
7215 mono_return_float4_nested (float4_nested sn4, int addend) {
7216         if (sn4.nested1.f1 != 1) {
7217                 fprintf(stderr, "mono_return_float4_nested sn4.nested1.f1: got %f but expected %d\n", sn4.nested1.f1, 1);
7218         }
7219         if (sn4.f2 != 2) {
7220                 fprintf(stderr, "mono_return_float4_nested sn4.f2: got %f but expected %d\n", sn4.f2, 2);
7221         }
7222         if (sn4.f3 != 3) {
7223                 fprintf(stderr, "mono_return_float4_nested sn4.f3: got %f but expected %d\n", sn4.f3, 3);
7224         }
7225         if (sn4.nested2.f4 != 4) {
7226                 fprintf(stderr, "mono_return_float4_nested sn4.nested2.f4: got %f but expected %d\n", sn4.nested2.f4, 4);
7227         }
7228         sn4.nested1.f1+=addend; sn4.f2+=addend; sn4.f3+=addend; sn4.nested2.f4+=addend;
7229         return sn4;
7230 }
7231
7232 typedef struct {
7233         double f1;
7234 } double1;
7235
7236 LIBTEST_API double1 STDCALL
7237 mono_return_double1 (double1 s1, int addend) {
7238         if (s1.f1 != 1) {
7239                 fprintf(stderr, "mono_return_double1 s1.f1: got %f but expected %d\n", s1.f1, 1);
7240         }
7241         s1.f1+=addend;
7242         return s1;
7243 }
7244
7245 typedef struct {
7246         double f1,f2;
7247 } double2;
7248
7249 LIBTEST_API double2 STDCALL
7250 mono_return_double2 (double2 s2, int addend) {
7251         if (s2.f1 != 1) {
7252                 fprintf(stderr, "mono_return_double2 s2.f1: got %f but expected %d\n", s2.f1, 1);
7253         }
7254         if (s2.f2 != 2) {
7255                 fprintf(stderr, "mono_return_double2 s2.f2: got %f but expected %d\n", s2.f2, 2);
7256         }
7257         s2.f1+=addend; s2.f2+=addend;
7258         return s2;
7259 }
7260
7261 typedef struct {
7262         double f1,f2,f3;
7263 } double3;
7264
7265 LIBTEST_API double3 STDCALL
7266 mono_return_double3 (double3 s3, int addend) {
7267         if (s3.f1 != 1) {
7268                 fprintf(stderr, "mono_return_double3 s3.f1: got %f but expected %d\n", s3.f1, 1);
7269         }
7270         if (s3.f2 != 2) {
7271                 fprintf(stderr, "mono_return_double3 s3.f2: got %f but expected %d\n", s3.f2, 2);
7272         }
7273         if (s3.f3 != 3) {
7274                 fprintf(stderr, "mono_return_double3 s3.f3: got %f but expected %d\n", s3.f3, 3);
7275         }
7276         s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
7277         return s3;
7278 }
7279
7280 typedef struct {
7281         double f1,f2,f3,f4;
7282 } double4;
7283
7284 LIBTEST_API double4 STDCALL
7285 mono_return_double4 (double4 s4, int addend) {
7286         if (s4.f1 != 1) {
7287                 fprintf(stderr, "mono_return_double4 s4.f1: got %f but expected %d\n", s4.f1, 1);
7288         }
7289         if (s4.f2 != 2) {
7290                 fprintf(stderr, "mono_return_double4 s4.f2: got %f but expected %d\n", s4.f2, 2);
7291         }
7292         if (s4.f3 != 3) {
7293                 fprintf(stderr, "mono_return_double4 s4.f3: got %f but expected %d\n", s4.f3, 3);
7294         }
7295         if (s4.f4 != 4) {
7296                 fprintf(stderr, "mono_return_double4 s4.f4: got %f but expected %d\n", s4.f4, 4);
7297         }
7298         s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
7299         return s4;
7300 }
7301
7302 typedef struct {
7303         double f1,f2,f3,f4,f5;
7304 } double5;
7305
7306 LIBTEST_API double5 STDCALL
7307 mono_return_double5 (double5 s5, int addend) {
7308         if (s5.f1 != 1) {
7309                 fprintf(stderr, "mono_return_double5 s5.f1: got %f but expected %d\n", s5.f1, 1);
7310         }
7311         if (s5.f2 != 2) {
7312                 fprintf(stderr, "mono_return_double5 s5.f2: got %f but expected %d\n", s5.f2, 2);
7313         }
7314         if (s5.f3 != 3) {
7315                 fprintf(stderr, "mono_return_double5 s5.f3: got %f but expected %d\n", s5.f3, 3);
7316         }
7317         if (s5.f4 != 4) {
7318                 fprintf(stderr, "mono_return_double5 s5.f4: got %f but expected %d\n", s5.f4, 4);
7319         }
7320         if (s5.f5 != 5) {
7321                 fprintf(stderr, "mono_return_double5 s5.f5: got %f but expected %d\n", s5.f5, 5);
7322         }
7323         s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
7324         return s5;
7325 }
7326
7327 typedef struct {
7328         double f1,f2,f3,f4,f5,f6;
7329 } double6;
7330
7331 LIBTEST_API double6 STDCALL
7332 mono_return_double6 (double6 s6, int addend) {
7333         if (s6.f1 != 1) {
7334                 fprintf(stderr, "mono_return_double6 s6.f1: got %f but expected %d\n", s6.f1, 1);
7335         }
7336         if (s6.f2 != 2) {
7337                 fprintf(stderr, "mono_return_double6 s6.f2: got %f but expected %d\n", s6.f2, 2);
7338         }
7339         if (s6.f3 != 3) {
7340                 fprintf(stderr, "mono_return_double6 s6.f3: got %f but expected %d\n", s6.f3, 3);
7341         }
7342         if (s6.f4 != 4) {
7343                 fprintf(stderr, "mono_return_double6 s6.f4: got %f but expected %d\n", s6.f4, 4);
7344         }
7345         if (s6.f5 != 5) {
7346                 fprintf(stderr, "mono_return_double6 s6.f5: got %f but expected %d\n", s6.f5, 5);
7347         }
7348         if (s6.f6 != 6) {
7349                 fprintf(stderr, "mono_return_double6 s6.f6: got %f but expected %d\n", s6.f6, 6);
7350         }
7351         s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
7352         return s6;
7353 }
7354
7355 typedef struct {
7356         double f1,f2,f3,f4,f5,f6,f7;
7357 } double7;
7358
7359 LIBTEST_API double7 STDCALL
7360 mono_return_double7 (double7 s7, int addend) {
7361         if (s7.f1 != 1) {
7362                 fprintf(stderr, "mono_return_double7 s7.f1: got %f but expected %d\n", s7.f1, 1);
7363         }
7364         if (s7.f2 != 2) {
7365                 fprintf(stderr, "mono_return_double7 s7.f2: got %f but expected %d\n", s7.f2, 2);
7366         }
7367         if (s7.f3 != 3) {
7368                 fprintf(stderr, "mono_return_double7 s7.f3: got %f but expected %d\n", s7.f3, 3);
7369         }
7370         if (s7.f4 != 4) {
7371                 fprintf(stderr, "mono_return_double7 s7.f4: got %f but expected %d\n", s7.f4, 4);
7372         }
7373         if (s7.f5 != 5) {
7374                 fprintf(stderr, "mono_return_double7 s7.f5: got %f but expected %d\n", s7.f5, 5);
7375         }
7376         if (s7.f6 != 6) {
7377                 fprintf(stderr, "mono_return_double7 s7.f6: got %f but expected %d\n", s7.f6, 6);
7378         }
7379         if (s7.f7 != 7) {
7380                 fprintf(stderr, "mono_return_double7 s7.f7: got %f but expected %d\n", s7.f7, 7);
7381         }
7382         s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
7383         return s7;
7384 }
7385
7386 typedef struct {
7387         double f1,f2,f3,f4,f5,f6,f7,f8;
7388 } double8;
7389
7390 LIBTEST_API double8 STDCALL
7391 mono_return_double8 (double8 s8, int addend) {
7392         if (s8.f1 != 1) {
7393                 fprintf(stderr, "mono_return_double8 s8.f1: got %f but expected %d\n", s8.f1, 1);
7394         }
7395         if (s8.f2 != 2) {
7396                 fprintf(stderr, "mono_return_double8 s8.f2: got %f but expected %d\n", s8.f2, 2);
7397         }
7398         if (s8.f3 != 3) {
7399                 fprintf(stderr, "mono_return_double8 s8.f3: got %f but expected %d\n", s8.f3, 3);
7400         }
7401         if (s8.f4 != 4) {
7402                 fprintf(stderr, "mono_return_double8 s8.f4: got %f but expected %d\n", s8.f4, 4);
7403         }
7404         if (s8.f5 != 5) {
7405                 fprintf(stderr, "mono_return_double8 s8.f5: got %f but expected %d\n", s8.f5, 5);
7406         }
7407         if (s8.f6 != 6) {
7408                 fprintf(stderr, "mono_return_double8 s8.f6: got %f but expected %d\n", s8.f6, 6);
7409         }
7410         if (s8.f7 != 7) {
7411                 fprintf(stderr, "mono_return_double8 s8.f7: got %f but expected %d\n", s8.f7, 7);
7412         }
7413         if (s8.f8 != 8) {
7414                 fprintf(stderr, "mono_return_double8 s8.f8: got %f but expected %d\n", s8.f8, 8);
7415         }
7416         s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
7417         return s8;
7418 }
7419
7420 typedef struct {
7421         double f1,f2,f3,f4,f5,f6,f7,f8,f9;
7422 } double9;
7423
7424 LIBTEST_API double9 STDCALL
7425 mono_return_double9 (double9 s9, int addend) {
7426         if (s9.f1 != 1) {
7427                 fprintf(stderr, "mono_return_double9 s9.f1: got %f but expected %d\n", s9.f1, 1);
7428         }
7429         if (s9.f2 != 2) {
7430                 fprintf(stderr, "mono_return_double9 s9.f2: got %f but expected %d\n", s9.f2, 2);
7431         }
7432         if (s9.f3 != 3) {
7433                 fprintf(stderr, "mono_return_double9 s9.f3: got %f but expected %d\n", s9.f3, 3);
7434         }
7435         if (s9.f4 != 4) {
7436                 fprintf(stderr, "mono_return_double9 s9.f4: got %f but expected %d\n", s9.f4, 4);
7437         }
7438         if (s9.f5 != 5) {
7439                 fprintf(stderr, "mono_return_double9 s9.f5: got %f but expected %d\n", s9.f5, 5);
7440         }
7441         if (s9.f6 != 6) {
7442                 fprintf(stderr, "mono_return_double9 s9.f6: got %f but expected %d\n", s9.f6, 6);
7443         }
7444         if (s9.f7 != 7) {
7445                 fprintf(stderr, "mono_return_double9 s9.f7: got %f but expected %d\n", s9.f7, 7);
7446         }
7447         if (s9.f8 != 8) {
7448                 fprintf(stderr, "mono_return_double9 s9.f8: got %f but expected %d\n", s9.f8, 8);
7449         }
7450         if (s9.f9 != 9) {
7451                 fprintf(stderr, "mono_return_double9 s9.f9: got %f but expected %d\n", s9.f9, 9);
7452         }
7453         s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
7454         return s9;
7455 }
7456
7457 typedef struct {
7458         struct {
7459                 double f1;
7460         } nested1;
7461         struct {
7462                 double f2;
7463         } nested2;
7464 } double2_nested;
7465
7466 LIBTEST_API double2_nested STDCALL
7467 mono_return_double2_nested (double2_nested sn2, int addend) {
7468         if (sn2.nested1.f1 != 1) {
7469                 fprintf(stderr, "mono_return_double2_nested sn2.nested1.f1: got %f but expected %d\n", sn2.nested1.f1, 1);
7470         }
7471         if (sn2.nested2.f2 != 2) {
7472                 fprintf(stderr, "mono_return_double2_nested sn2.nested2.f2: got %f but expected %d\n", sn2.nested2.f2, 2);
7473         }
7474         sn2.nested1.f1+=addend; sn2.nested2.f2+=addend;
7475         return sn2;
7476 }
7477
7478
7479
7480 typedef struct {
7481         double f1[4];
7482 } double_array4;
7483
7484 LIBTEST_API double_array4 STDCALL
7485 mono_return_double_array4 (double_array4 sa4, int addend) {
7486         if (sa4.f1[0] != 1) {
7487                 fprintf(stderr, "mono_return_double_array4 sa4.f1[0]: got %f but expected %d\n", sa4.f1[0], 1);
7488         }
7489         if (sa4.f1[1] != 2) {
7490                 fprintf(stderr, "mono_return_double_array4 sa4.f1[1]: got %f but expected %d\n", sa4.f1[1], 2);
7491         }
7492         if (sa4.f1[2] != 3) {
7493                 fprintf(stderr, "mono_return_double_array4 sa4.f1[2]: got %f but expected %d\n", sa4.f1[2], 3);
7494         }
7495         if (sa4.f1[3] != 4) {
7496                 fprintf(stderr, "mono_return_double_array4 sa4.f1[3]: got %f but expected %d\n", sa4.f1[3], 4);
7497         }
7498         sa4.f1[0]+=addend; sa4.f1[1]+=addend; sa4.f1[2]+=addend; sa4.f1[3]+=addend;
7499         return sa4;
7500 }
7501
7502 typedef struct {
7503         int array [3];
7504 } FixedArrayStruct;
7505
7506 LIBTEST_API int STDCALL
7507 mono_test_marshal_fixed_array (FixedArrayStruct s)
7508 {
7509         return s.array [0] + s.array [1] + s.array [2];
7510 }
7511
7512 typedef struct {
7513         char array [16];
7514         char c;
7515 } FixedBufferChar;
7516
7517 LIBTEST_API int STDCALL
7518 mono_test_marshal_fixed_buffer_char (FixedBufferChar *s)
7519 {
7520         if (!(s->array [0] == 'A' && s->array [1] == 'B' && s->array [2] == 'C' && s->c == 'D'))
7521                 return 1;
7522         s->array [0] = 'E';
7523         s->array [1] = 'F';
7524         s->c = 'G';
7525         return 0;
7526 }
7527
7528 typedef struct {
7529         short array [16];
7530         short c;
7531 } FixedBufferUnicode;
7532
7533 LIBTEST_API int STDCALL
7534 mono_test_marshal_fixed_buffer_unicode (FixedBufferUnicode *s)
7535 {
7536         if (!(s->array [0] == 'A' && s->array [1] == 'B' && s->array [2] == 'C' && s->c == 'D'))
7537                 return 1;
7538         s->array [0] = 'E';
7539         s->array [1] = 'F';
7540         s->c = 'G';
7541         return 0;
7542 }
7543
7544 const int NSTRINGS = 6;
7545 //test strings
7546 const char  *utf8Strings[] = {
7547                                 "Managed",
7548                                  "Sîne klâwen durh die wolken sint geslagen" ,
7549                                  "काचं शक्नोम्यत्तुम् । नोपहिनस्ति माम्",
7550                                  "我能吞下玻璃而不伤身体",
7551                                  "ღმერთსი შემვედრე,შემვედრე, ნუთუ კვლა დამხსნას შემვედრე,სოფლისა შემვედრე, შემვედრე,შემვედრე,შემვედრე,შრომასა, ცეცხლს, წყალსა და მიწასა, ჰაერთა თანა მრომასა; მომცნეს ფრთენი და აღვფრინდე, მივჰხვდე მას ჩემსა ნდომასა, დღისით და ღამით ვჰხედვიდე მზისა ელვათა კრთომაასაშემვედრე,შემვედრე,",
7552                                  "Τη γλώσσα μου έδωσαν ελληνική",
7553 "\0"
7554 };
7555
7556 LIBTEST_API char *
7557 build_return_string(const char* pReturn)
7558 {
7559         char *ret = 0;
7560         if (pReturn == 0 || *pReturn == 0)
7561                 return ret;
7562
7563         size_t strLength = strlen(pReturn);
7564         ret = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7565         memcpy(ret, pReturn, strLength);
7566         ret [strLength] = '\0';
7567         return ret;
7568 }
7569
7570 LIBTEST_API char *
7571 StringParameterInOut(/*[In,Out]*/ char *s, int index)
7572 {
7573         // return a copy
7574         return build_return_string(s);
7575 }
7576
7577 LIBTEST_API void
7578 StringParameterRefOut(/*out*/ char **s, int index)
7579 {
7580         char *pszTextutf8 = (char*)utf8Strings[index];
7581         size_t strLength = strlen(pszTextutf8);
7582         *s = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7583         memcpy(*s, pszTextutf8, strLength);
7584         (*s)[strLength] = '\0';
7585 }
7586
7587 LIBTEST_API void
7588 StringParameterRef(/*ref*/ char **s, int index)
7589 {
7590     char *pszTextutf8 = (char*)utf8Strings[index];
7591     size_t strLength = strlen(pszTextutf8);
7592     // do byte by byte validation of in string
7593     size_t szLen = strlen(*s);
7594     for (size_t i = 0; i < szLen; i++)
7595     {
7596         if ((*s)[i] != pszTextutf8[i])
7597         {
7598             printf("[in] managed string do not match native string\n");
7599             abort ();
7600         }
7601     }
7602
7603     if (*s)
7604     {
7605        marshal_free (*s);
7606     }
7607     // overwrite the orginal
7608     *s = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7609     memcpy(*s, pszTextutf8, strLength);
7610     (*s)[strLength] = '\0';
7611 }
7612
7613 LIBTEST_API void
7614 StringBuilderParameterInOut(/*[In,Out] StringBuilder*/ char *s, int index)
7615 {
7616     // if string.empty
7617     if (s == 0 || *s == 0)
7618         return;
7619
7620     char *pszTextutf8 = (char*)utf8Strings[index];
7621
7622     // do byte by byte validation of in string
7623     size_t szLen = strlen(s);
7624     for (size_t i = 0; i < szLen; i++)
7625     {
7626         if (s[i] != pszTextutf8[i])
7627         {
7628             printf("[in] managed string do not match native string\n");
7629             abort ();
7630         }
7631     }
7632
7633     // modify the string inplace
7634     size_t outLen = strlen(pszTextutf8);
7635     for (size_t i = 0; i < outLen; i++) {
7636         s[i] = pszTextutf8[i];
7637     }
7638     s[outLen] = '\0';
7639 }
7640
7641 //out string builder
7642 LIBTEST_API void
7643 StringBuilderParameterOut(/*[Out] StringBuilder*/ char *s, int index)
7644 {
7645     char *pszTextutf8 = (char*)utf8Strings[index];
7646
7647     printf ("SBPO: Receiving %s\n", s);
7648     // modify the string inplace
7649     size_t outLen = strlen(pszTextutf8);
7650     for (size_t i = 0; i < outLen; i++) {
7651         s[i] = pszTextutf8[i];
7652     }
7653     s[outLen] = '\0';
7654 }
7655
7656 LIBTEST_API char *
7657 StringParameterOut(/*[Out]*/ char *s, int index)
7658 {
7659     // return a copy
7660     return build_return_string(s);
7661 }
7662
7663 // Utf8 field
7664 typedef struct FieldWithUtf8
7665 {
7666     char *pFirst;
7667     int index;
7668 }FieldWithUtf8;
7669
7670 //utf8 struct field
7671 LIBTEST_API void
7672 TestStructWithUtf8Field(struct FieldWithUtf8 fieldStruct)
7673 {
7674     char *pszManagedutf8 = fieldStruct.pFirst;
7675     int stringIndex = fieldStruct.index;
7676     char *pszNative = 0;
7677     size_t outLen = 0;
7678
7679     if (pszManagedutf8 == 0 || *pszManagedutf8 == 0)
7680         return;
7681
7682     pszNative = (char*)utf8Strings[stringIndex];
7683
7684     outLen = strlen(pszNative);
7685     // do byte by byte comparision
7686     for (size_t i = 0; i < outLen; i++)
7687     {
7688         if (pszNative[i] != pszManagedutf8[i])
7689         {
7690             printf("Native and managed string do not match.\n");
7691             abort ();
7692         }
7693     }
7694 }
7695
7696 typedef void (* Callback2)(char *text, int index);
7697
7698 LIBTEST_API void
7699 Utf8DelegateAsParameter(Callback2 managedCallback)
7700 {
7701     for (int i = 0; i < NSTRINGS; ++i)
7702     {
7703         char *pszNative = 0;
7704         pszNative = (char*)utf8Strings[i];
7705         managedCallback(pszNative, i);
7706     }
7707 }
7708
7709
7710 LIBTEST_API char*
7711 StringBuilderParameterReturn(int index)
7712 {
7713     char *pszTextutf8 = (char*)utf8Strings[index];
7714     size_t strLength = strlen(pszTextutf8);
7715     char * ret = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7716     memcpy(ret, pszTextutf8, strLength);
7717     ret[strLength] = '\0';
7718
7719     return  ret;
7720 }
7721
7722 LIBTEST_API int STDCALL
7723 mono_test_marshal_pointer_array (int *arr[])
7724 {
7725         int i;
7726
7727         for (i = 0; i < 10; ++i) {
7728                 if (*arr [i] != -1)
7729                         return 1;
7730         }
7731         return 0;
7732 }
7733
7734 #ifndef WIN32
7735
7736 typedef void (*NativeToManagedExceptionRethrowFunc) (void);
7737
7738 void *mono_test_native_to_managed_exception_rethrow_thread (void *arg)
7739 {
7740         NativeToManagedExceptionRethrowFunc func = (NativeToManagedExceptionRethrowFunc) arg;
7741         func ();
7742         return NULL;
7743 }
7744
7745 LIBTEST_API void STDCALL
7746 mono_test_native_to_managed_exception_rethrow (NativeToManagedExceptionRethrowFunc func)
7747 {
7748         pthread_t t;
7749         pthread_create (&t, NULL, mono_test_native_to_managed_exception_rethrow_thread, (gpointer)func);
7750         pthread_join (t, NULL);
7751 }
7752 #endif
7753
7754 typedef void (*VoidVoidCallback) (void);
7755 typedef void (*MonoFtnPtrEHCallback) (guint32 gchandle);
7756
7757 typedef long long MonoObject;
7758 typedef MonoObject MonoException;
7759 typedef int32_t mono_bool;
7760
7761 static int sym_inited = 0;
7762 static void (*sym_mono_install_ftnptr_eh_callback) (MonoFtnPtrEHCallback);
7763 static MonoObject* (*sym_mono_gchandle_get_target) (guint32 gchandle);
7764 static guint32 (*sym_mono_gchandle_new) (MonoObject *, mono_bool pinned);
7765 static void (*sym_mono_gchandle_free) (guint32 gchandle);
7766 static void (*sym_mono_raise_exception) (MonoException *ex);
7767 static void (*sym_mono_domain_unload) (gpointer);
7768 static void (*sym_mono_threads_exit_gc_safe_region_unbalanced) (gpointer, gpointer *);
7769 static void (*null_function_ptr) (void);
7770
7771 static void
7772 mono_test_init_symbols (void)
7773 {
7774         if (sym_inited)
7775                 return;
7776
7777         sym_mono_install_ftnptr_eh_callback = (void (*) (MonoFtnPtrEHCallback)) (lookup_mono_symbol ("mono_install_ftnptr_eh_callback"));
7778
7779         sym_mono_gchandle_get_target = (MonoObject* (*) (guint32 gchandle)) (lookup_mono_symbol ("mono_gchandle_get_target"));
7780
7781         sym_mono_gchandle_new = (guint32 (*) (MonoObject *, mono_bool)) (lookup_mono_symbol ("mono_gchandle_new"));
7782
7783         sym_mono_gchandle_free = (void (*) (guint32 gchandle)) (lookup_mono_symbol ("mono_gchandle_free"));
7784
7785         sym_mono_raise_exception = (void (*) (MonoException *)) (lookup_mono_symbol ("mono_raise_exception"));
7786
7787         sym_mono_domain_unload = (void (*) (gpointer)) (lookup_mono_symbol ("mono_domain_unload"));
7788
7789         sym_mono_threads_exit_gc_safe_region_unbalanced = (void (*) (gpointer, gpointer *)) (lookup_mono_symbol ("mono_threads_exit_gc_safe_region_unbalanced"));
7790
7791         sym_inited = 1;
7792 }
7793
7794 #ifndef TARGET_WASM
7795
7796 static jmp_buf test_jmp_buf;
7797 static guint32 test_gchandle;
7798
7799 static void
7800 mono_test_longjmp_callback (guint32 gchandle)
7801 {
7802         test_gchandle = gchandle;
7803         longjmp (test_jmp_buf, 1);
7804 }
7805
7806 LIBTEST_API void STDCALL
7807 mono_test_setjmp_and_call (VoidVoidCallback managedCallback, intptr_t *out_handle)
7808 {
7809         mono_test_init_symbols ();
7810         if (setjmp (test_jmp_buf) == 0) {
7811                 *out_handle = 0;
7812                 sym_mono_install_ftnptr_eh_callback (mono_test_longjmp_callback);
7813                 managedCallback ();
7814                 *out_handle = 0; /* Do not expect to return here */
7815         } else {
7816                 sym_mono_install_ftnptr_eh_callback (NULL);
7817                 *out_handle = test_gchandle;
7818         }
7819 }
7820
7821 #endif
7822
7823 LIBTEST_API void STDCALL
7824 mono_test_marshal_bstr (void *ptr)
7825 {
7826 }
7827
7828 static void (*mono_test_capture_throw_callback) (guint32 gchandle, guint32 *exception_out);
7829
7830 static void
7831 mono_test_ftnptr_eh_callback (guint32 gchandle)
7832 {
7833         guint32 exception_handle = 0;
7834
7835         g_assert (gchandle != 0);
7836         MonoObject *exc = sym_mono_gchandle_get_target (gchandle);
7837         sym_mono_gchandle_free (gchandle);
7838
7839         guint32 handle = sym_mono_gchandle_new (exc, FALSE);
7840         mono_test_capture_throw_callback (handle, &exception_handle);
7841         sym_mono_gchandle_free (handle);
7842
7843         g_assert (exception_handle != 0);
7844         exc = sym_mono_gchandle_get_target (exception_handle);
7845         sym_mono_gchandle_free (exception_handle);
7846
7847         sym_mono_raise_exception (exc);
7848         g_error ("mono_raise_exception should not return");
7849 }
7850
7851 LIBTEST_API void STDCALL
7852 mono_test_setup_ftnptr_eh_callback (VoidVoidCallback managed_entry, void (*capture_throw_callback) (guint32, guint32 *))
7853 {
7854         mono_test_init_symbols ();
7855         mono_test_capture_throw_callback = capture_throw_callback;
7856         sym_mono_install_ftnptr_eh_callback (mono_test_ftnptr_eh_callback);
7857         managed_entry ();
7858 }
7859
7860 LIBTEST_API void STDCALL
7861 mono_test_cleanup_ftptr_eh_callback (void)
7862 {
7863         mono_test_init_symbols ();
7864         sym_mono_install_ftnptr_eh_callback (NULL);
7865 }
7866
7867 LIBTEST_API int STDCALL
7868 mono_test_cominterop_ccw_queryinterface (MonoComObject *pUnk)
7869 {
7870         void *pp;
7871         int hr = pUnk->vtbl->QueryInterface (pUnk, &IID_INotImplemented, &pp);
7872
7873         // Return true if we can't get INotImplemented
7874         return pUnk == NULL && hr == S_OK;
7875 }
7876
7877 LIBTEST_API void STDCALL
7878 mono_test_MerpCrashSnprintf (void)
7879 {
7880         fprintf (stderr, "Before overwrite\n");
7881
7882         char buff [1] = { '\0' };
7883         char overflow [1] = { 'a' }; // Not null-terminated
7884         g_snprintf (buff, sizeof(buff) * 10, "THISSHOULDOVERRUNTERRIBLY%s", overflow);
7885         g_snprintf ((char *) GINT_TO_POINTER(-1), sizeof(buff) * 10, "THISSHOULDOVERRUNTERRIBLY%s", overflow);
7886 }
7887
7888 LIBTEST_API void STDCALL
7889 mono_test_MerpCrashDladdr (void)
7890 {
7891 #ifndef HOST_WIN32
7892         dlopen (GINT_TO_POINTER(-1), -1);
7893 #endif
7894 }
7895
7896 LIBTEST_API void STDCALL
7897 mono_test_MerpCrashMalloc (void)
7898 {
7899         gpointer x = g_malloc (sizeof(gpointer));
7900         g_free (x);
7901
7902         // Double free
7903         g_free (x);
7904 }
7905
7906 LIBTEST_API void STDCALL
7907 mono_test_MerpCrashNullFp (void)
7908 {
7909         null_function_ptr ();
7910 }
7911
7912 LIBTEST_API void STDCALL
7913 mono_test_MerpCrashDomainUnload (void)
7914 {
7915         mono_test_init_symbols ();
7916         sym_mono_domain_unload (GINT_TO_POINTER (-1));
7917 }
7918
7919 LIBTEST_API void STDCALL
7920 mono_test_MerpCrashUnbalancedGCSafe (void)
7921 {
7922         mono_test_init_symbols ();
7923         gpointer foo = GINT_TO_POINTER (-1);
7924         gpointer bar = GINT_TO_POINTER (-2);
7925         sym_mono_threads_exit_gc_safe_region_unbalanced (foo, &bar);
7926 }
7927
7928 LIBTEST_API void STDCALL
7929 mono_test_MerpCrashUnhandledExceptionHook (void)
7930 {
7931         g_assert_not_reached ();
7932 }
7933
7934 #ifdef __cplusplus
7935 } // extern C
7936 #endif