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