mono/mini/jit-icalls.c

   1 /**
   2  * \file
   3  * internal calls used by the JIT
   4  *
   5  * Author:
   6  *   Dietmar Maurer (dietmar@ximian.com)
   7  *   Paolo Molaro (lupus@ximian.com)
   8  *
   9  * (C) 2002 Ximian, Inc.
  10  * Copyright 2003-2011 Novell Inc (http://www.novell.com)
  11  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  12  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  13  */
  14 #include <config.h>
  15 #include <math.h>
  16 #include <limits.h>
  17 #ifdef HAVE_ALLOCA_H
  18 #include <alloca.h>
  19 #endif
  20
  21 #include "jit-icalls.h"
  22 #include <mono/utils/mono-error-internals.h>
  23 #include <mono/metadata/exception-internals.h>
  24 #include <mono/metadata/threads-types.h>
  25 #include <mono/metadata/reflection-internals.h>
  26 #include <mono/utils/unlocked.h>
  27
  28 #ifdef ENABLE_LLVM
  29 #include "mini-llvm-cpp.h"
  30 #endif
  31
  32 void*
  33 mono_ldftn (MonoMethod *method)
  34 {
  35         gpointer addr;
  36         MonoError error;
  37
  38         if (mono_llvm_only) {
  39                 // FIXME: No error handling
  40
  41                 addr = mono_compile_method_checked (method, &error);
  42                 mono_error_assert_ok (&error);
  43                 g_assert (addr);
  44
  45                 if (mono_method_needs_static_rgctx_invoke (method, FALSE))
  46                         /* The caller doesn't pass it */
  47                         g_assert_not_reached ();
  48
  49                 addr = mini_add_method_trampoline (method, addr, mono_method_needs_static_rgctx_invoke (method, FALSE), FALSE);
  50                 return addr;
  51         }
  52
  53         addr = mono_create_jump_trampoline (mono_domain_get (), method, FALSE, &error);
  54         if (!mono_error_ok (&error)) {
  55                 mono_error_set_pending_exception (&error);
  56                 return NULL;
  57         }
  58         return mono_create_ftnptr (mono_domain_get (), addr);
  59 }
  60
  61 static void*
  62 ldvirtfn_internal (MonoObject *obj, MonoMethod *method, gboolean gshared)
  63 {
  64         MonoError error;
  65         MonoMethod *res;
  66
  67         if (obj == NULL) {
  68                 mono_set_pending_exception (mono_get_exception_null_reference ());
  69                 return NULL;
  70         }
  71
  72         res = mono_object_get_virtual_method (obj, method);
  73
  74         if (gshared && method->is_inflated && mono_method_get_context (method)->method_inst) {
  75                 MonoGenericContext context = { NULL, NULL };
  76
  77                 if (mono_class_is_ginst (res->klass))
  78                         context.class_inst = mono_class_get_generic_class (res->klass)->context.class_inst;
  79                 else if (mono_class_is_gtd (res->klass))
  80                         context.class_inst = mono_class_get_generic_container (res->klass)->context.class_inst;
  81                 context.method_inst = mono_method_get_context (method)->method_inst;
  82
  83                 res = mono_class_inflate_generic_method_checked (res, &context, &error);
  84                 if (!mono_error_ok (&error)) {
  85                         mono_error_set_pending_exception (&error);
  86                         return NULL;
  87                 }
  88         }
  89
  90         /* An rgctx wrapper is added by the trampolines no need to do it here */
  91
  92         return mono_ldftn (res);
  93 }
  94
  95 void*
  96 mono_ldvirtfn (MonoObject *obj, MonoMethod *method)
  97 {
  98         return ldvirtfn_internal (obj, method, FALSE);
  99 }
 100
 101 void*
 102 mono_ldvirtfn_gshared (MonoObject *obj, MonoMethod *method)
 103 {
 104         return ldvirtfn_internal (obj, method, TRUE);
 105 }
 106
 107 void
 108 mono_helper_stelem_ref_check (MonoArray *array, MonoObject *val)
 109 {
 110         MonoError error;
 111         if (!array) {
 112                 mono_set_pending_exception (mono_get_exception_null_reference ());
 113                 return;
 114         }
 115         if (val && !mono_object_isinst_checked (val, array->obj.vtable->klass->element_class, &error)) {
 116                 if (mono_error_set_pending_exception (&error))
 117                         return;
 118                 mono_set_pending_exception (mono_get_exception_array_type_mismatch ());
 119                 return;
 120         }
 121 }
 122
 123 #if !defined(MONO_ARCH_NO_EMULATE_LONG_MUL_OPTS) || defined(MONO_ARCH_EMULATE_LONG_MUL_OVF_OPTS)
 124
 125 gint64
 126 mono_llmult (gint64 a, gint64 b)
 127 {
 128         return a * b;
 129 }
 130
 131 guint64
 132 mono_llmult_ovf_un (guint64 a, guint64 b)
 133 {
 134         guint32 al = a;
 135         guint32 ah = a >> 32;
 136         guint32 bl = b;
 137         guint32 bh = b >> 32;
 138         guint64 res, t1;
 139
 140         // fixme: this is incredible slow
 141
 142         if (ah && bh)
 143                 goto raise_exception;
 144
 145         res = (guint64)al * (guint64)bl;
 146
 147         t1 = (guint64)ah * (guint64)bl + (guint64)al * (guint64)bh;
 148
 149         if (t1 > 0xffffffff)
 150                 goto raise_exception;
 151
 152         res += ((guint64)t1) << 32;
 153
 154         return res;
 155
 156  raise_exception:
 157         mono_set_pending_exception (mono_get_exception_overflow ());
 158         return 0;
 159 }
 160
 161 guint64
 162 mono_llmult_ovf (gint64 a, gint64 b)
 163 {
 164         guint32 al = a;
 165         gint32 ah = a >> 32;
 166         guint32 bl = b;
 167         gint32 bh = b >> 32;
 168         /*
 169         Use Karatsuba algorithm where:
 170                 a*b is: AhBh(R^2+R)+(Ah-Al)(Bl-Bh)R+AlBl(R+1)
 171                 where Ah is the "high half" (most significant 32 bits) of a and
 172                 where Al is the "low half" (least significant 32 bits) of a and
 173                 where  Bh is the "high half" of b and Bl is the "low half" and
 174                 where R is the Radix or "size of the half" (in our case 32 bits)
 175
 176         Note, for the product of two 64 bit numbers to fit into a 64
 177         result, ah and/or bh must be 0.  This will save us from doing
 178         the AhBh term at all.
 179
 180         Also note that we refactor so that we don't overflow 64 bits with
 181         intermediate results. So we use [(Ah-Al)(Bl-Bh)+AlBl]R+AlBl
 182         */
 183
 184         gint64 res, t1;
 185         gint32 sign;
 186
 187         /* need to work with absoulte values, so find out what the
 188            resulting sign will be and convert any negative numbers
 189            from two's complement
 190         */
 191         sign = ah ^ bh;
 192         if (ah < 0) {
 193                 if (((guint32)ah == 0x80000000) && (al == 0)) {
 194                         /* This has no two's complement */
 195                         if (b == 0)
 196                                 return 0;
 197                         else if (b == 1)
 198                                 return a;
 199                         else
 200                                 goto raise_exception;
 201                 }
 202
 203                 /* flip the bits and add 1 */
 204                 ah ^= ~0;
 205                 if (al ==  0)
 206                         ah += 1;
 207                 else {
 208                         al ^= ~0;
 209                         al +=1;
 210                 }
 211         }
 212
 213         if (bh < 0) {
 214                 if (((guint32)bh == 0x80000000) && (bl == 0)) {
 215                         /* This has no two's complement */
 216                         if (a == 0)
 217                                 return 0;
 218                         else if (a == 1)
 219                                 return b;
 220                         else
 221                                 goto raise_exception;
 222                 }
 223
 224                 /* flip the bits and add 1 */
 225                 bh ^= ~0;
 226                 if (bl ==  0)
 227                         bh += 1;
 228                 else {
 229                         bl ^= ~0;
 230                         bl +=1;
 231                 }
 232         }
 233
 234         /* we overflow for sure if both upper halves are greater
 235            than zero because we would need to shift their
 236            product 64 bits to the left and that will not fit
 237            in a 64 bit result */
 238         if (ah && bh)
 239                 goto raise_exception;
 240         if ((gint64)((gint64)ah * (gint64)bl) > (gint64)0x80000000 || (gint64)((gint64)al * (gint64)bh) > (gint64)0x80000000)
 241                 goto raise_exception;
 242
 243         /* do the AlBl term first */
 244         t1 = (gint64)al * (gint64)bl;
 245
 246         res = t1;
 247
 248         /* now do the [(Ah-Al)(Bl-Bh)+AlBl]R term */
 249         t1 += (gint64)(ah - al) * (gint64)(bl - bh);
 250         /* check for overflow */
 251         t1 <<= 32;
 252         if (t1 > (0x7FFFFFFFFFFFFFFFLL - res))
 253                 goto raise_exception;
 254
 255         res += t1;
 256
 257         if (res < 0)
 258                 goto raise_exception;
 259
 260         if (sign < 0)
 261                 return -res;
 262         else
 263                 return res;
 264
 265  raise_exception:
 266         mono_set_pending_exception (mono_get_exception_overflow ());
 267         return 0;
 268 }
 269
 270 gint64
 271 mono_lldiv (gint64 a, gint64 b)
 272 {
 273 #ifdef MONO_ARCH_NEED_DIV_CHECK
 274         if (!b) {
 275                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 276                 return 0;
 277         }
 278         else if (b == -1 && a == (-9223372036854775807LL - 1LL)) {
 279                 mono_set_pending_exception (mono_get_exception_arithmetic ());
 280                 return 0;
 281         }
 282 #endif
 283         return a / b;
 284 }
 285
 286 gint64
 287 mono_llrem (gint64 a, gint64 b)
 288 {
 289 #ifdef MONO_ARCH_NEED_DIV_CHECK
 290         if (!b) {
 291                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 292                 return 0;
 293         }
 294         else if (b == -1 && a == (-9223372036854775807LL - 1LL)) {
 295                 mono_set_pending_exception (mono_get_exception_arithmetic ());
 296                 return 0;
 297         }
 298 #endif
 299         return a % b;
 300 }
 301
 302 guint64
 303 mono_lldiv_un (guint64 a, guint64 b)
 304 {
 305 #ifdef MONO_ARCH_NEED_DIV_CHECK
 306         if (!b) {
 307                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 308                 return 0;
 309         }
 310 #endif
 311         return a / b;
 312 }
 313
 314 guint64
 315 mono_llrem_un (guint64 a, guint64 b)
 316 {
 317 #ifdef MONO_ARCH_NEED_DIV_CHECK
 318         if (!b) {
 319                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 320                 return 0;
 321         }
 322 #endif
 323         return a % b;
 324 }
 325
 326 #endif
 327
 328 #ifndef MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS
 329
 330 guint64
 331 mono_lshl (guint64 a, gint32 shamt)
 332 {
 333         guint64 res;
 334
 335         res = a << (shamt & 0x7f);
 336
 337         /*printf ("TESTL %lld << %d = %lld\n", a, shamt, res);*/
 338
 339         return res;
 340 }
 341
 342 guint64
 343 mono_lshr_un (guint64 a, gint32 shamt)
 344 {
 345         guint64 res;
 346
 347         res = a >> (shamt & 0x7f);
 348
 349         /*printf ("TESTR %lld >> %d = %lld\n", a, shamt, res);*/
 350
 351         return res;
 352 }
 353
 354 gint64
 355 mono_lshr (gint64 a, gint32 shamt)
 356 {
 357         gint64 res;
 358
 359         res = a >> (shamt & 0x7f);
 360
 361         /*printf ("TESTR %lld >> %d = %lld\n", a, shamt, res);*/
 362
 363         return res;
 364 }
 365
 366 #endif
 367
 368 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
 369
 370 gint32
 371 mono_idiv (gint32 a, gint32 b)
 372 {
 373 #ifdef MONO_ARCH_NEED_DIV_CHECK
 374         if (!b) {
 375                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 376                 return 0;
 377         }
 378         else if (b == -1 && a == (0x80000000)) {
 379                 mono_set_pending_exception (mono_get_exception_overflow ());
 380                 return 0;
 381         }
 382 #endif
 383         return a / b;
 384 }
 385
 386 guint32
 387 mono_idiv_un (guint32 a, guint32 b)
 388 {
 389 #ifdef MONO_ARCH_NEED_DIV_CHECK
 390         if (!b) {
 391                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 392                 return 0;
 393         }
 394 #endif
 395         return a / b;
 396 }
 397
 398 gint32
 399 mono_irem (gint32 a, gint32 b)
 400 {
 401 #ifdef MONO_ARCH_NEED_DIV_CHECK
 402         if (!b) {
 403                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 404                 return 0;
 405         }
 406         else if (b == -1 && a == (0x80000000)) {
 407                 mono_set_pending_exception (mono_get_exception_overflow ());
 408                 return 0;
 409         }
 410 #endif
 411         return a % b;
 412 }
 413
 414 guint32
 415 mono_irem_un (guint32 a, guint32 b)
 416 {
 417 #ifdef MONO_ARCH_NEED_DIV_CHECK
 418         if (!b) {
 419                 mono_set_pending_exception (mono_get_exception_divide_by_zero ());
 420                 return 0;
 421         }
 422 #endif
 423         return a % b;
 424 }
 425
 426 #endif
 427
 428 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_MUL_OVF)
 429
 430 gint32
 431 mono_imul (gint32 a, gint32 b)
 432 {
 433         return a * b;
 434 }
 435
 436 gint32
 437 mono_imul_ovf (gint32 a, gint32 b)
 438 {
 439         gint64 res;
 440
 441         res = (gint64)a * (gint64)b;
 442
 443         if ((res > 0x7fffffffL) || (res < -2147483648LL)) {
 444                 mono_set_pending_exception (mono_get_exception_overflow ());
 445                 return 0;
 446         }
 447
 448         return res;
 449 }
 450
 451 gint32
 452 mono_imul_ovf_un (guint32 a, guint32 b)
 453 {
 454         guint64 res;
 455
 456         res = (guint64)a * (guint64)b;
 457
 458         if (res >> 32) {
 459                 mono_set_pending_exception (mono_get_exception_overflow ());
 460                 return 0;
 461         }
 462
 463         return res;
 464 }
 465 #endif
 466
 467 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_SOFT_FLOAT_FALLBACK)
 468 double
 469 mono_fdiv (double a, double b)
 470 {
 471         return a / b;
 472 }
 473 #endif
 474
 475 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
 476
 477 double
 478 mono_fsub (double a, double b)
 479 {
 480         return a - b;
 481 }
 482
 483 double
 484 mono_fadd (double a, double b)
 485 {
 486         return a + b;
 487 }
 488
 489 double
 490 mono_fmul (double a, double b)
 491 {
 492         return a * b;
 493 }
 494
 495 double
 496 mono_fneg (double a)
 497 {
 498         return -a;
 499 }
 500
 501 double
 502 mono_fconv_r4 (double a)
 503 {
 504         return (float)a;
 505 }
 506
 507 double
 508 mono_conv_to_r8 (int a)
 509 {
 510         return (double)a;
 511 }
 512
 513 double
 514 mono_conv_to_r4 (int a)
 515 {
 516         return (double)(float)a;
 517 }
 518
 519 gint8
 520 mono_fconv_i1 (double a)
 521 {
 522         return (gint8)a;
 523 }
 524
 525 gint16
 526 mono_fconv_i2 (double a)
 527 {
 528         return (gint16)a;
 529 }
 530
 531 gint32
 532 mono_fconv_i4 (double a)
 533 {
 534         return (gint32)a;
 535 }
 536
 537 guint8
 538 mono_fconv_u1 (double a)
 539 {
 540         return (guint8)a;
 541 }
 542
 543 guint16
 544 mono_fconv_u2 (double a)
 545 {
 546         return (guint16)a;
 547 }
 548
 549 gboolean
 550 mono_fcmp_eq (double a, double b)
 551 {
 552         return a == b;
 553 }
 554
 555 gboolean
 556 mono_fcmp_ge (double a, double b)
 557 {
 558         return a >= b;
 559 }
 560
 561 gboolean
 562 mono_fcmp_gt (double a, double b)
 563 {
 564         return a > b;
 565 }
 566
 567 gboolean
 568 mono_fcmp_le (double a, double b)
 569 {
 570         return a <= b;
 571 }
 572
 573 gboolean
 574 mono_fcmp_lt (double a, double b)
 575 {
 576         return a < b;
 577 }
 578
 579 gboolean
 580 mono_fcmp_ne_un (double a, double b)
 581 {
 582         return isunordered (a, b) || a != b;
 583 }
 584
 585 gboolean
 586 mono_fcmp_ge_un (double a, double b)
 587 {
 588         return isunordered (a, b) || a >= b;
 589 }
 590
 591 gboolean
 592 mono_fcmp_gt_un (double a, double b)
 593 {
 594         return isunordered (a, b) || a > b;
 595 }
 596
 597 gboolean
 598 mono_fcmp_le_un (double a, double b)
 599 {
 600         return isunordered (a, b) || a <= b;
 601 }
 602
 603 gboolean
 604 mono_fcmp_lt_un (double a, double b)
 605 {
 606         return isunordered (a, b) || a < b;
 607 }
 608
 609 gboolean
 610 mono_fceq (double a, double b)
 611 {
 612         return a == b;
 613 }
 614
 615 gboolean
 616 mono_fcgt (double a, double b)
 617 {
 618         return a > b;
 619 }
 620
 621 gboolean
 622 mono_fcgt_un (double a, double b)
 623 {
 624         return isunordered (a, b) || a > b;
 625 }
 626
 627 gboolean
 628 mono_fclt (double a, double b)
 629 {
 630         return a < b;
 631 }
 632
 633 gboolean
 634 mono_fclt_un (double a, double b)
 635 {
 636         return isunordered (a, b) || a < b;
 637 }
 638
 639 gboolean
 640 mono_isfinite (double a)
 641 {
 642 #ifdef HAVE_ISFINITE
 643         return isfinite (a);
 644 #else
 645         g_assert_not_reached ();
 646         return TRUE;
 647 #endif
 648 }
 649
 650 double
 651 mono_fload_r4 (float *ptr)
 652 {
 653         return *ptr;
 654 }
 655
 656 void
 657 mono_fstore_r4 (double val, float *ptr)
 658 {
 659         *ptr = (float)val;
 660 }
 661
 662 /* returns the integer bitpattern that is passed in the regs or stack */
 663 guint32
 664 mono_fload_r4_arg (double val)
 665 {
 666         float v = (float)val;
 667         return *(guint32*)&v;
 668 }
 669
 670 #endif
 671
 672 MonoArray *
 673 mono_array_new_va (MonoMethod *cm, ...)
 674 {
 675         MonoError error;
 676         MonoArray *arr;
 677         MonoDomain *domain = mono_domain_get ();
 678         va_list ap;
 679         uintptr_t *lengths;
 680         intptr_t *lower_bounds;
 681         int pcount;
 682         int rank;
 683         int i, d;
 684
 685         pcount = mono_method_signature (cm)->param_count;
 686         rank = cm->klass->rank;
 687
 688         va_start (ap, cm);
 689
 690         lengths = (uintptr_t *)alloca (sizeof (uintptr_t) * pcount);
 691         for (i = 0; i < pcount; ++i)
 692                 lengths [i] = d = va_arg(ap, int);
 693
 694         if (rank == pcount) {
 695                 /* Only lengths provided. */
 696                 if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
 697                         lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
 698                         memset (lower_bounds, 0, sizeof (intptr_t) * rank);
 699                 } else {
 700                         lower_bounds = NULL;
 701                 }
 702         } else {
 703                 g_assert (pcount == (rank * 2));
 704                 /* lower bounds are first. */
 705                 lower_bounds = (intptr_t*)lengths;
 706                 lengths += rank;
 707         }
 708         va_end(ap);
 709
 710         arr = mono_array_new_full_checked (domain, cm->klass, lengths, lower_bounds, &error);
 711
 712         if (!mono_error_ok (&error)) {
 713                 mono_error_set_pending_exception (&error);
 714                 return NULL;
 715         }
 716
 717         return arr;
 718 }
 719
 720 /* Specialized version of mono_array_new_va () which avoids varargs */
 721 MonoArray *
 722 mono_array_new_1 (MonoMethod *cm, guint32 length)
 723 {
 724         MonoError error;
 725         MonoArray *arr;
 726         MonoDomain *domain = mono_domain_get ();
 727         uintptr_t lengths [1];
 728         intptr_t *lower_bounds;
 729         int pcount;
 730         int rank;
 731
 732         pcount = mono_method_signature (cm)->param_count;
 733         rank = cm->klass->rank;
 734
 735         lengths [0] = length;
 736
 737         g_assert (rank == pcount);
 738
 739         if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
 740                 lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
 741                 memset (lower_bounds, 0, sizeof (intptr_t) * rank);
 742         } else {
 743                 lower_bounds = NULL;
 744         }
 745
 746         arr = mono_array_new_full_checked (domain, cm->klass, lengths, lower_bounds, &error);
 747
 748         if (!mono_error_ok (&error)) {
 749                 mono_error_set_pending_exception (&error);
 750                 return NULL;
 751         }
 752
 753         return arr;
 754 }
 755
 756 MonoArray *
 757 mono_array_new_2 (MonoMethod *cm, guint32 length1, guint32 length2)
 758 {
 759         MonoError error;
 760         MonoArray *arr;
 761         MonoDomain *domain = mono_domain_get ();
 762         uintptr_t lengths [2];
 763         intptr_t *lower_bounds;
 764         int pcount;
 765         int rank;
 766
 767         pcount = mono_method_signature (cm)->param_count;
 768         rank = cm->klass->rank;
 769
 770         lengths [0] = length1;
 771         lengths [1] = length2;
 772
 773         g_assert (rank == pcount);
 774
 775         if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
 776                 lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
 777                 memset (lower_bounds, 0, sizeof (intptr_t) * rank);
 778         } else {
 779                 lower_bounds = NULL;
 780         }
 781
 782         arr = mono_array_new_full_checked (domain, cm->klass, lengths, lower_bounds, &error);
 783
 784         if (!mono_error_ok (&error)) {
 785                 mono_error_set_pending_exception (&error);
 786                 return NULL;
 787         }
 788
 789         return arr;
 790 }
 791
 792 MonoArray *
 793 mono_array_new_3 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 length3)
 794 {
 795         MonoError error;
 796         MonoArray *arr;
 797         MonoDomain *domain = mono_domain_get ();
 798         uintptr_t lengths [3];
 799         intptr_t *lower_bounds;
 800         int pcount;
 801         int rank;
 802
 803         pcount = mono_method_signature (cm)->param_count;
 804         rank = cm->klass->rank;
 805
 806         lengths [0] = length1;
 807         lengths [1] = length2;
 808         lengths [2] = length3;
 809
 810         g_assert (rank == pcount);
 811
 812         if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
 813                 lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
 814                 memset (lower_bounds, 0, sizeof (intptr_t) * rank);
 815         } else {
 816                 lower_bounds = NULL;
 817         }
 818
 819         arr = mono_array_new_full_checked (domain, cm->klass, lengths, lower_bounds, &error);
 820
 821         if (!mono_error_ok (&error)) {
 822                 mono_error_set_pending_exception (&error);
 823                 return NULL;
 824         }
 825
 826         return arr;
 827 }
 828
 829 MonoArray *
 830 mono_array_new_4 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 length3, guint32 length4)
 831 {
 832         MonoError error;
 833         MonoArray *arr;
 834         MonoDomain *domain = mono_domain_get ();
 835         uintptr_t lengths [4];
 836         intptr_t *lower_bounds;
 837         int pcount;
 838         int rank;
 839
 840         pcount = mono_method_signature (cm)->param_count;
 841         rank = cm->klass->rank;
 842
 843         lengths [0] = length1;
 844         lengths [1] = length2;
 845         lengths [2] = length3;
 846         lengths [3] = length4;
 847
 848         g_assert (rank == pcount);
 849
 850         if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) {
 851                 lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank);
 852                 memset (lower_bounds, 0, sizeof (intptr_t) * rank);
 853         } else {
 854                 lower_bounds = NULL;
 855         }
 856
 857         arr = mono_array_new_full_checked (domain, cm->klass, lengths, lower_bounds, &error);
 858
 859         if (!mono_error_ok (&error)) {
 860                 mono_error_set_pending_exception (&error);
 861                 return NULL;
 862         }
 863
 864         return arr;
 865 }
 866
 867 gpointer
 868 mono_class_static_field_address (MonoDomain *domain, MonoClassField *field)
 869 {
 870         MonoError error;
 871         MonoVTable *vtable;
 872         gpointer addr;
 873
 874         //printf ("SFLDA0 %s.%s::%s %d\n", field->parent->name_space, field->parent->name, field->name, field->offset, field->parent->inited);
 875
 876         mono_class_init (field->parent);
 877
 878         vtable = mono_class_vtable_full (domain, field->parent, &error);
 879         if (!is_ok (&error)) {
 880                 mono_error_set_pending_exception (&error);
 881                 return NULL;
 882         }
 883         if (!vtable->initialized) {
 884                 if (!mono_runtime_class_init_full (vtable, &error)) {
 885                         mono_error_set_pending_exception (&error);
 886                         return NULL;
 887                 }
 888         }
 889
 890         //printf ("SFLDA1 %p\n", (char*)vtable->data + field->offset);
 891
 892         if (field->offset == -1) {
 893                 /* Special static */
 894                 g_assert (domain->special_static_fields);
 895                 mono_domain_lock (domain);
 896                 addr = g_hash_table_lookup (domain->special_static_fields, field);
 897                 mono_domain_unlock (domain);
 898                 addr = mono_get_special_static_data (GPOINTER_TO_UINT (addr));
 899         } else {
 900                 addr = (char*)mono_vtable_get_static_field_data (vtable) + field->offset;
 901         }
 902         return addr;
 903 }
 904
 905 gpointer
 906 mono_ldtoken_wrapper (MonoImage *image, int token, MonoGenericContext *context)
 907 {
 908         MonoError error;
 909         MonoClass *handle_class;
 910         gpointer res;
 911
 912         res = mono_ldtoken_checked (image, token, &handle_class, context, &error);
 913         if (!mono_error_ok (&error)) {
 914                 mono_error_set_pending_exception (&error);
 915                 return NULL;
 916         }
 917         mono_class_init (handle_class);
 918
 919         return res;
 920 }
 921
 922 gpointer
 923 mono_ldtoken_wrapper_generic_shared (MonoImage *image, int token, MonoMethod *method)
 924 {
 925         MonoMethodSignature *sig = mono_method_signature (method);
 926         MonoGenericContext *generic_context;
 927
 928         if (sig->is_inflated) {
 929                 generic_context = mono_method_get_context (method);
 930         } else {
 931                 MonoGenericContainer *generic_container = mono_method_get_generic_container (method);
 932                 g_assert (generic_container);
 933                 generic_context = &generic_container->context;
 934         }
 935
 936         return mono_ldtoken_wrapper (image, token, generic_context);
 937 }
 938
 939 guint64
 940 mono_fconv_u8 (double v)
 941 {
 942         return (guint64)v;
 943 }
 944
 945 guint64
 946 mono_rconv_u8 (float v)
 947 {
 948         return (guint64)v;
 949 }
 950
 951 #ifdef MONO_ARCH_EMULATE_FCONV_TO_I8
 952 gint64
 953 mono_fconv_i8 (double v)
 954 {
 955         return (gint64)v;
 956 }
 957 #endif
 958
 959 guint32
 960 mono_fconv_u4 (double v)
 961 {
 962         /* MS.NET behaves like this for some reason */
 963 #ifdef HAVE_ISINF
 964         if (isinf (v) || isnan (v))
 965                 return 0;
 966 #endif
 967
 968         return (guint32)v;
 969 }
 970
 971 #ifndef HAVE_TRUNC
 972 /* Solaris doesn't have trunc */
 973 #ifdef HAVE_AINTL
 974 extern long double aintl (long double);
 975 #define trunc aintl
 976 #else
 977 /* FIXME: This means we will never throw overflow exceptions */
 978 #define trunc(v) res
 979 #endif
 980 #endif /* HAVE_TRUNC */
 981
 982 gint64
 983 mono_fconv_ovf_i8 (double v)
 984 {
 985         gint64 res;
 986
 987         res = (gint64)v;
 988
 989         if (isnan(v) || trunc (v) != res) {
 990                 mono_set_pending_exception (mono_get_exception_overflow ());
 991                 return 0;
 992         }
 993         return res;
 994 }
 995
 996 guint64
 997 mono_fconv_ovf_u8 (double v)
 998 {
 999         guint64 res;
1000
1001 /*
1002  * The soft-float implementation of some ARM devices have a buggy guin64 to double
1003  * conversion that it looses precision even when the integer if fully representable
1004  * as a double.
1005  *
1006  * This was found with 4294967295ull, converting to double and back looses one bit of precision.
1007  *
1008  * To work around this issue we test for value boundaries instead.
1009  */
1010 #if defined(__arm__) && defined(MONO_ARCH_SOFT_FLOAT_FALLBACK)
1011         if (isnan (v) || !(v >= -0.5 && v <= ULLONG_MAX+0.5)) {
1012                 mono_set_pending_exception (mono_get_exception_overflow ());
1013                 return 0;
1014         }
1015         res = (guint64)v;
1016 #else
1017         res = (guint64)v;
1018         if (isnan(v) || trunc (v) != res) {
1019                 mono_set_pending_exception (mono_get_exception_overflow ());
1020                 return 0;
1021         }
1022 #endif
1023         return res;
1024 }
1025
1026 #ifdef MONO_ARCH_EMULATE_FCONV_TO_I8
1027 gint64
1028 mono_rconv_i8 (float v)
1029 {
1030         return (gint64)v;
1031 }
1032 #endif
1033
1034 gint64
1035 mono_rconv_ovf_i8 (float v)
1036 {
1037         gint64 res;
1038
1039         res = (gint64)v;
1040
1041         if (isnan(v) || trunc (v) != res) {
1042                 mono_set_pending_exception (mono_get_exception_overflow ());
1043                 return 0;
1044         }
1045         return res;
1046 }
1047
1048 guint64
1049 mono_rconv_ovf_u8 (float v)
1050 {
1051         guint64 res;
1052
1053         res = (guint64)v;
1054         if (isnan(v) || trunc (v) != res) {
1055                 mono_set_pending_exception (mono_get_exception_overflow ());
1056                 return 0;
1057         }
1058         return res;
1059 }
1060
1061 #ifdef MONO_ARCH_EMULATE_LCONV_TO_R8
1062 double
1063 mono_lconv_to_r8 (gint64 a)
1064 {
1065         return (double)a;
1066 }
1067 #endif
1068
1069 #ifdef MONO_ARCH_EMULATE_LCONV_TO_R4
1070 float
1071 mono_lconv_to_r4 (gint64 a)
1072 {
1073         return (float)a;
1074 }
1075 #endif
1076
1077 #ifdef MONO_ARCH_EMULATE_CONV_R8_UN
1078 double
1079 mono_conv_to_r8_un (guint32 a)
1080 {
1081         return (double)a;
1082 }
1083 #endif
1084
1085 #ifdef MONO_ARCH_EMULATE_LCONV_TO_R8_UN
1086 double
1087 mono_lconv_to_r8_un (guint64 a)
1088 {
1089         return (double)a;
1090 }
1091 #endif
1092
1093 gpointer
1094 mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, gpointer *this_arg)
1095 {
1096         MonoError error;
1097         MonoMethod *vmethod;
1098         gpointer addr;
1099         MonoGenericContext *context = mono_method_get_context (method);
1100
1101         UnlockedIncrement (&mono_jit_stats.generic_virtual_invocations);
1102
1103         if (obj == NULL) {
1104                 mono_set_pending_exception (mono_get_exception_null_reference ());
1105                 return NULL;
1106         }
1107         vmethod = mono_object_get_virtual_method (obj, method);
1108         g_assert (!mono_class_is_gtd (vmethod->klass));
1109         g_assert (!mono_class_is_ginst (vmethod->klass) || !mono_class_get_generic_class (vmethod->klass)->context.class_inst->is_open);
1110         g_assert (!context->method_inst || !context->method_inst->is_open);
1111
1112         addr = mono_compile_method_checked (vmethod, &error);
1113         if (mono_error_set_pending_exception (&error))
1114                 return NULL;
1115
1116         addr = mini_add_method_trampoline (vmethod, addr, mono_method_needs_static_rgctx_invoke (vmethod, FALSE), FALSE);
1117
1118         /* Since this is a virtual call, have to unbox vtypes */
1119         if (obj->vtable->klass->valuetype)
1120                 *this_arg = mono_object_unbox (obj);
1121         else
1122                 *this_arg = obj;
1123
1124         return addr;
1125 }
1126
1127 MonoString*
1128 ves_icall_mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
1129 {
1130         MonoError error;
1131         MonoString *result = mono_ldstr_checked (domain, image, idx, &error);
1132         mono_error_set_pending_exception (&error);
1133         return result;
1134 }
1135
1136 MonoString*
1137 mono_helper_ldstr (MonoImage *image, guint32 idx)
1138 {
1139         MonoError error;
1140         MonoString *result = mono_ldstr_checked (mono_domain_get (), image, idx, &error);
1141         mono_error_set_pending_exception (&error);
1142         return result;
1143 }
1144
1145 MonoString*
1146 mono_helper_ldstr_mscorlib (guint32 idx)
1147 {
1148         MonoError error;
1149         MonoString *result = mono_ldstr_checked (mono_domain_get (), mono_defaults.corlib, idx, &error);
1150         mono_error_set_pending_exception (&error);
1151         return result;
1152 }
1153
1154 MonoObject*
1155 mono_helper_newobj_mscorlib (guint32 idx)
1156 {
1157         MonoError error;
1158         MonoClass *klass = mono_class_get_checked (mono_defaults.corlib, MONO_TOKEN_TYPE_DEF | idx, &error);
1159
1160         if (!mono_error_ok (&error)) {
1161                 mono_error_set_pending_exception (&error);
1162                 return NULL;
1163         }
1164
1165         MonoObject *obj = mono_object_new_checked (mono_domain_get (), klass, &error);
1166         if (!mono_error_ok (&error))
1167                 mono_error_set_pending_exception (&error);
1168         return obj;
1169 }
1170
1171 /*
1172  * On some architectures, gdb doesn't like encountering the cpu breakpoint instructions
1173  * in generated code. So instead we emit a call to this function and place a gdb
1174  * breakpoint here.
1175  */
1176 void
1177 mono_break (void)
1178 {
1179 }
1180
1181 MonoException *
1182 mono_create_corlib_exception_0 (guint32 token)
1183 {
1184         return mono_exception_from_token (mono_defaults.corlib, token);
1185 }
1186
1187 MonoException *
1188 mono_create_corlib_exception_1 (guint32 token, MonoString *arg)
1189 {
1190         MonoError error;
1191         MonoException *ret = mono_exception_from_token_two_strings_checked (
1192                 mono_defaults.corlib, token, arg, NULL, &error);
1193         mono_error_set_pending_exception (&error);
1194         return ret;
1195 }
1196
1197 MonoException *
1198 mono_create_corlib_exception_2 (guint32 token, MonoString *arg1, MonoString *arg2)
1199 {
1200         MonoError error;
1201         MonoException *ret = mono_exception_from_token_two_strings_checked (
1202                 mono_defaults.corlib, token, arg1, arg2, &error);
1203         mono_error_set_pending_exception (&error);
1204         return ret;
1205 }
1206
1207 MonoObject*
1208 mono_object_castclass_unbox (MonoObject *obj, MonoClass *klass)
1209 {
1210         MonoError error;
1211         MonoJitTlsData *jit_tls = NULL;
1212         MonoClass *oklass;
1213
1214         if (mini_get_debug_options ()->better_cast_details) {
1215                 jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls ();
1216                 jit_tls->class_cast_from = NULL;
1217         }
1218
1219         if (!obj)
1220                 return NULL;
1221
1222         oklass = obj->vtable->klass;
1223         if ((klass->enumtype && oklass == klass->element_class) || (oklass->enumtype && klass == oklass->element_class))
1224                 return obj;
1225         if (mono_object_isinst_checked (obj, klass, &error))
1226                 return obj;
1227         if (mono_error_set_pending_exception (&error))
1228                 return NULL;
1229
1230         if (mini_get_debug_options ()->better_cast_details) {
1231                 jit_tls->class_cast_from = oklass;
1232                 jit_tls->class_cast_to = klass;
1233         }
1234
1235         mono_set_pending_exception (mono_exception_from_name (mono_defaults.corlib,
1236                                         "System", "InvalidCastException"));
1237
1238         return NULL;
1239 }
1240
1241 MonoObject*
1242 mono_object_castclass_with_cache (MonoObject *obj, MonoClass *klass, gpointer *cache)
1243 {
1244         MonoError error;
1245         MonoJitTlsData *jit_tls = NULL;
1246         gpointer cached_vtable, obj_vtable;
1247
1248         if (mini_get_debug_options ()->better_cast_details) {
1249                 jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls ();
1250                 jit_tls->class_cast_from = NULL;
1251         }
1252
1253         if (!obj)
1254                 return NULL;
1255
1256         cached_vtable = *cache;
1257         obj_vtable = obj->vtable;
1258
1259         if (cached_vtable == obj_vtable)
1260                 return obj;
1261
1262         if (mono_object_isinst_checked (obj, klass, &error)) {
1263                 *cache = obj_vtable;
1264                 return obj;
1265         }
1266         if (mono_error_set_pending_exception (&error))
1267                 return NULL;
1268
1269         if (mini_get_debug_options ()->better_cast_details) {
1270                 jit_tls->class_cast_from = obj->vtable->klass;
1271                 jit_tls->class_cast_to = klass;
1272         }
1273
1274         mono_set_pending_exception (mono_exception_from_name (mono_defaults.corlib,
1275                                         "System", "InvalidCastException"));
1276
1277         return NULL;
1278 }
1279
1280 MonoObject*
1281 mono_object_isinst_with_cache (MonoObject *obj, MonoClass *klass, gpointer *cache)
1282 {
1283         MonoError error;
1284         size_t cached_vtable, obj_vtable;
1285
1286         if (!obj)
1287                 return NULL;
1288
1289         cached_vtable = (size_t)*cache;
1290         obj_vtable = (size_t)obj->vtable;
1291
1292         if ((cached_vtable & ~0x1) == obj_vtable) {
1293                 return (cached_vtable & 0x1) ? NULL : obj;
1294         }
1295
1296         if (mono_object_isinst_checked (obj, klass, &error)) {
1297                 *cache = (gpointer)obj_vtable;
1298                 return obj;
1299         } else {
1300                 if (mono_error_set_pending_exception (&error))
1301                         return NULL;
1302                 /*negative cache*/
1303                 *cache = (gpointer)(obj_vtable | 0x1);
1304                 return NULL;
1305         }
1306 }
1307
1308 gpointer
1309 mono_get_native_calli_wrapper (MonoImage *image, MonoMethodSignature *sig, gpointer func)
1310 {
1311         MonoError error;
1312         MonoMarshalSpec **mspecs;
1313         MonoMethodPInvoke piinfo;
1314         MonoMethod *m;
1315
1316         mspecs = g_new0 (MonoMarshalSpec*, sig->param_count + 1);
1317         memset (&piinfo, 0, sizeof (piinfo));
1318
1319         m = mono_marshal_get_native_func_wrapper (image, sig, &piinfo, mspecs, func);
1320
1321         gpointer compiled_ptr = mono_compile_method_checked (m, &error);
1322         mono_error_set_pending_exception (&error);
1323         return compiled_ptr;
1324 }
1325
1326 static MonoMethod*
1327 constrained_gsharedvt_call_setup (gpointer mp, MonoMethod *cmethod, MonoClass *klass, gpointer *this_arg, MonoError *error)
1328 {
1329         MonoMethod *m;
1330         int vt_slot, iface_offset;
1331
1332         error_init (error);
1333
1334         if (mono_class_is_interface (klass)) {
1335                 MonoObject *this_obj;
1336
1337                 /* Have to use the receiver's type instead of klass, the receiver is a ref type */
1338                 this_obj = *(MonoObject**)mp;
1339                 g_assert (this_obj);
1340
1341                 klass = this_obj->vtable->klass;
1342         }
1343
1344         if (mono_method_signature (cmethod)->pinvoke) {
1345                 /* Object.GetType () */
1346                 m = mono_marshal_get_native_wrapper (cmethod, TRUE, FALSE);
1347         } else {
1348                 /* Lookup the virtual method */
1349                 mono_class_setup_vtable (klass);
1350                 g_assert (klass->vtable);
1351                 vt_slot = mono_method_get_vtable_slot (cmethod);
1352                 if (mono_class_is_interface (cmethod->klass)) {
1353                         iface_offset = mono_class_interface_offset (klass, cmethod->klass);
1354                         g_assert (iface_offset != -1);
1355                         vt_slot += iface_offset;
1356                 }
1357                 m = klass->vtable [vt_slot];
1358                 if (cmethod->is_inflated)
1359                         m = mono_class_inflate_generic_method (m, mono_method_get_context (cmethod));
1360         }
1361
1362         if (klass->valuetype && (m->klass == mono_defaults.object_class || m->klass == mono_defaults.enum_class->parent || m->klass == mono_defaults.enum_class))
1363                 /*
1364                  * Calling a non-vtype method with a vtype receiver, has to box.
1365                  */
1366                 *this_arg = mono_value_box_checked (mono_domain_get (), klass, mp, error);
1367         else if (klass->valuetype)
1368                 /*
1369                  * Calling a vtype method with a vtype receiver
1370                  */
1371                 *this_arg = mp;
1372         else
1373                 /*
1374                  * Calling a non-vtype method
1375                  */
1376                 *this_arg = *(gpointer*)mp;
1377         return m;
1378 }
1379
1380 /*
1381  * mono_gsharedvt_constrained_call:
1382  *
1383  *   Make a call to CMETHOD using the receiver MP, which is assumed to be of type KLASS. ARGS contains
1384  * the arguments to the method in the format used by mono_runtime_invoke_checked ().
1385  */
1386 MonoObject*
1387 mono_gsharedvt_constrained_call (gpointer mp, MonoMethod *cmethod, MonoClass *klass, gboolean deref_arg, gpointer *args)
1388 {
1389         MonoError error;
1390         MonoObject *o;
1391         MonoMethod *m;
1392         gpointer this_arg;
1393         gpointer new_args [16];
1394
1395         m = constrained_gsharedvt_call_setup (mp, cmethod, klass, &this_arg, &error);
1396         if (!mono_error_ok (&error)) {
1397                 mono_error_set_pending_exception (&error);
1398                 return NULL;
1399         }
1400
1401         if (!m)
1402                 return NULL;
1403         if (args && deref_arg) {
1404                 new_args [0] = *(gpointer*)args [0];
1405                 args = new_args;
1406         }
1407         if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
1408                 /* Object.GetType () */
1409                 args = new_args;
1410                 args [0] = this_arg;
1411                 this_arg = NULL;
1412         }
1413
1414         o = mono_runtime_invoke_checked (m, this_arg, args, &error);
1415         if (!mono_error_ok (&error)) {
1416                 mono_error_set_pending_exception (&error);
1417                 return NULL;
1418         }
1419
1420         return o;
1421 }
1422
1423 void
1424 mono_gsharedvt_value_copy (gpointer dest, gpointer src, MonoClass *klass)
1425 {
1426         if (klass->valuetype)
1427                 mono_value_copy (dest, src, klass);
1428         else
1429         mono_gc_wbarrier_generic_store (dest, *(MonoObject**)src);
1430 }
1431
1432 void
1433 ves_icall_runtime_class_init (MonoVTable *vtable)
1434 {
1435         MONO_REQ_GC_UNSAFE_MODE;
1436         MonoError error;
1437
1438         mono_runtime_class_init_full (vtable, &error);
1439         mono_error_set_pending_exception (&error);
1440 }
1441
1442
1443 void
1444 mono_generic_class_init (MonoVTable *vtable)
1445 {
1446         MonoError error;
1447         mono_runtime_class_init_full (vtable, &error);
1448         mono_error_set_pending_exception (&error);
1449 }
1450
1451 void
1452 ves_icall_mono_delegate_ctor (MonoObject *this_obj_raw, MonoObject *target_raw, gpointer addr)
1453 {
1454         HANDLE_FUNCTION_ENTER ();
1455         MonoError error;
1456         MONO_HANDLE_DCL (MonoObject, this_obj);
1457         MONO_HANDLE_DCL (MonoObject, target);
1458         mono_delegate_ctor (this_obj, target, addr, &error);
1459         mono_error_set_pending_exception (&error);
1460         HANDLE_FUNCTION_RETURN ();
1461 }
1462
1463 gpointer
1464 mono_fill_class_rgctx (MonoVTable *vtable, int index)
1465 {
1466         MonoError error;
1467         gpointer res;
1468
1469         res = mono_class_fill_runtime_generic_context (vtable, index, &error);
1470         if (!mono_error_ok (&error)) {
1471                 mono_error_set_pending_exception (&error);
1472                 return NULL;
1473         }
1474         return res;
1475 }
1476
1477 gpointer
1478 mono_fill_method_rgctx (MonoMethodRuntimeGenericContext *mrgctx, int index)
1479 {
1480         MonoError error;
1481         gpointer res;
1482
1483         res = mono_method_fill_runtime_generic_context (mrgctx, index, &error);
1484         if (!mono_error_ok (&error)) {
1485                 mono_error_set_pending_exception (&error);
1486                 return NULL;
1487         }
1488         return res;
1489 }
1490
1491 /*
1492  * resolve_iface_call:
1493  *
1494  *   Return the executable code for the iface method IMT_METHOD called on THIS.
1495  * This function is called on a slowpath, so it doesn't need to be fast.
1496  * This returns an ftnptr by returning the address part, and the arg in the OUT_ARG
1497  * out parameter.
1498  */
1499 static gpointer
1500 resolve_iface_call (MonoObject *this_obj, int imt_slot, MonoMethod *imt_method, gpointer *out_arg, gboolean caller_gsharedvt, MonoError *error)
1501 {
1502         MonoVTable *vt;
1503         gpointer *imt, *vtable_slot;
1504         MonoMethod *impl_method, *generic_virtual = NULL, *variant_iface = NULL;
1505         gpointer addr, compiled_method, aot_addr;
1506         gboolean need_rgctx_tramp = FALSE, need_unbox_tramp = FALSE;
1507
1508         error_init (error);
1509         if (!this_obj)
1510                 /* The caller will handle it */
1511                 return NULL;
1512
1513         vt = this_obj->vtable;
1514         imt = (gpointer*)vt - MONO_IMT_SIZE;
1515
1516         vtable_slot = mini_resolve_imt_method (vt, imt + imt_slot, imt_method, &impl_method, &aot_addr, &need_rgctx_tramp, &variant_iface, error);
1517         return_val_if_nok (error, NULL);
1518
1519         // FIXME: This can throw exceptions
1520         addr = compiled_method = mono_compile_method_checked (impl_method, error);
1521         mono_error_assert_ok (error);
1522         g_assert (addr);
1523
1524         if (imt_method->is_inflated && ((MonoMethodInflated*)imt_method)->context.method_inst)
1525                 generic_virtual = imt_method;
1526
1527         if (generic_virtual || variant_iface) {
1528                 if (vt->klass->valuetype) /*FIXME is this required variant iface?*/
1529                         need_unbox_tramp = TRUE;
1530         } else {
1531                 if (impl_method->klass->valuetype)
1532                         need_unbox_tramp = TRUE;
1533         }
1534
1535         addr = mini_add_method_wrappers_llvmonly (impl_method, addr, caller_gsharedvt, need_unbox_tramp, out_arg);
1536
1537         if (generic_virtual || variant_iface) {
1538                 MonoMethod *target = generic_virtual ? generic_virtual : variant_iface;
1539
1540                 mono_method_add_generic_virtual_invocation (mono_domain_get (),
1541                                                                                                         vt, imt + imt_slot,
1542                                                                                                         target, addr);
1543         }
1544
1545         return addr;
1546 }
1547
1548 gpointer
1549 mono_resolve_iface_call_gsharedvt (MonoObject *this_obj, int imt_slot, MonoMethod *imt_method, gpointer *out_arg)
1550 {
1551         MonoError error;
1552         gpointer res = resolve_iface_call (this_obj, imt_slot, imt_method, out_arg, TRUE, &error);
1553         if (!is_ok (&error)) {
1554                 MonoException *ex = mono_error_convert_to_exception (&error);
1555                 mono_llvm_throw_exception ((MonoObject*)ex);
1556         }
1557         return res;
1558 }
1559
1560 static gboolean
1561 is_generic_method_definition (MonoMethod *m)
1562 {
1563         MonoGenericContext *context;
1564         if (m->is_generic)
1565                 return TRUE;
1566         if (!m->is_inflated)
1567                 return FALSE;
1568
1569         context = mono_method_get_context (m);
1570         if (!context->method_inst)
1571                 return FALSE;
1572         if (context->method_inst == mono_method_get_generic_container (((MonoMethodInflated*)m)->declaring)->context.method_inst)
1573                 return TRUE;
1574         return FALSE;
1575 }
1576
1577 /*
1578  * resolve_vcall:
1579  *
1580  *   Return the executable code for calling vt->vtable [slot].
1581  * This function is called on a slowpath, so it doesn't need to be fast.
1582  * This returns an ftnptr by returning the address part, and the arg in the OUT_ARG
1583  * out parameter.
1584  */
1585 static gpointer
1586 resolve_vcall (MonoVTable *vt, int slot, MonoMethod *imt_method, gpointer *out_arg, gboolean gsharedvt, MonoError *error)
1587 {
1588         MonoMethod *m, *generic_virtual = NULL;
1589         gpointer addr, compiled_method;
1590         gboolean need_unbox_tramp = FALSE;
1591
1592         error_init (error);
1593         /* Same as in common_call_trampoline () */
1594
1595         /* Avoid loading metadata or creating a generic vtable if possible */
1596         addr = mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, slot, error);
1597         return_val_if_nok (error, NULL);
1598         if (addr && !vt->klass->valuetype)
1599                 return mono_create_ftnptr (mono_domain_get (), addr);
1600
1601         m = mono_class_get_vtable_entry (vt->klass, slot);
1602
1603         if (is_generic_method_definition (m)) {
1604                 MonoGenericContext context = { NULL, NULL };
1605                 MonoMethod *declaring;
1606
1607                 if (m->is_inflated)
1608                         declaring = mono_method_get_declaring_generic_method (m);
1609                 else
1610                         declaring = m;
1611
1612                 if (mono_class_is_ginst (m->klass))
1613                         context.class_inst = mono_class_get_generic_class (m->klass)->context.class_inst;
1614                 else
1615                         g_assert (!mono_class_is_gtd (m->klass));
1616
1617                 generic_virtual = imt_method;
1618                 g_assert (generic_virtual);
1619                 g_assert (generic_virtual->is_inflated);
1620                 context.method_inst = ((MonoMethodInflated*)generic_virtual)->context.method_inst;
1621
1622                 m = mono_class_inflate_generic_method_checked (declaring, &context, error);
1623                 mono_error_assert_ok (error); /* FIXME don't swallow the error */
1624         }
1625
1626         if (generic_virtual) {
1627                 if (vt->klass->valuetype)
1628                         need_unbox_tramp = TRUE;
1629         } else {
1630                 if (m->klass->valuetype)
1631                         need_unbox_tramp = TRUE;
1632         }
1633
1634         if (m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
1635                 m = mono_marshal_get_synchronized_wrapper (m);
1636
1637         // FIXME: This can throw exceptions
1638         addr = compiled_method = mono_compile_method_checked (m, error);
1639         mono_error_assert_ok (error);
1640         g_assert (addr);
1641
1642         addr = mini_add_method_wrappers_llvmonly (m, addr, gsharedvt, need_unbox_tramp, out_arg);
1643
1644         if (!gsharedvt && generic_virtual) {
1645                 // FIXME: This wastes memory since add_generic_virtual_invocation ignores it in a lot of cases
1646                 MonoFtnDesc *ftndesc = mini_create_llvmonly_ftndesc (mono_domain_get (), addr, out_arg);
1647
1648                 mono_method_add_generic_virtual_invocation (mono_domain_get (),
1649                                                                                                         vt, vt->vtable + slot,
1650                                                                                                         generic_virtual, ftndesc);
1651         }
1652
1653         return addr;
1654 }
1655
1656 gpointer
1657 mono_resolve_vcall_gsharedvt (MonoObject *this_obj, int slot, MonoMethod *imt_method, gpointer *out_arg)
1658 {
1659         g_assert (this_obj);
1660
1661         MonoError error;
1662         gpointer result = resolve_vcall (this_obj->vtable, slot, imt_method, out_arg, TRUE, &error);
1663         if (!is_ok (&error)) {
1664                 MonoException *ex = mono_error_convert_to_exception (&error);
1665                 mono_llvm_throw_exception ((MonoObject*)ex);
1666         }
1667         return result;
1668 }
1669
1670 /*
1671  * mono_resolve_generic_virtual_call:
1672  *
1673  *   Resolve a generic virtual call.
1674  * This function is called on a slowpath, so it doesn't need to be fast.
1675  */
1676 MonoFtnDesc*
1677 mono_resolve_generic_virtual_call (MonoVTable *vt, int slot, MonoMethod *generic_virtual)
1678 {
1679         MonoMethod *m;
1680         gpointer addr, compiled_method;
1681         gboolean need_unbox_tramp = FALSE;
1682         MonoError error;
1683         MonoGenericContext context = { NULL, NULL };
1684         MonoMethod *declaring;
1685         gpointer arg = NULL;
1686
1687         m = mono_class_get_vtable_entry (vt->klass, slot);
1688
1689         g_assert (is_generic_method_definition (m));
1690
1691         if (m->is_inflated)
1692                 declaring = mono_method_get_declaring_generic_method (m);
1693         else
1694                 declaring = m;
1695
1696         if (mono_class_is_ginst (m->klass))
1697                 context.class_inst = mono_class_get_generic_class (m->klass)->context.class_inst;
1698         else
1699                 g_assert (!mono_class_is_gtd (m->klass));
1700
1701         g_assert (generic_virtual->is_inflated);
1702         context.method_inst = ((MonoMethodInflated*)generic_virtual)->context.method_inst;
1703
1704         m = mono_class_inflate_generic_method_checked (declaring, &context, &error);
1705         g_assert (mono_error_ok (&error));
1706
1707         if (vt->klass->valuetype)
1708                 need_unbox_tramp = TRUE;
1709
1710         // FIXME: This can throw exceptions
1711         addr = compiled_method = mono_compile_method_checked (m, &error);
1712         mono_error_assert_ok (&error);
1713         g_assert (addr);
1714
1715         addr = mini_add_method_wrappers_llvmonly (m, addr, FALSE, need_unbox_tramp, &arg);
1716
1717         /*
1718          * This wastes memory but the memory usage is bounded since
1719          * mono_method_add_generic_virtual_invocation () eventually builds an imt trampoline for
1720          * this vtable slot so we are not called any more for this instantiation.
1721          */
1722         MonoFtnDesc *ftndesc = mini_create_llvmonly_ftndesc (mono_domain_get (), addr, arg);
1723
1724         mono_method_add_generic_virtual_invocation (mono_domain_get (),
1725                                                                                                 vt, vt->vtable + slot,
1726                                                                                                 generic_virtual, ftndesc);
1727         return ftndesc;
1728 }
1729
1730 /*
1731  * mono_resolve_generic_virtual_call:
1732  *
1733  *   Resolve a generic virtual/variant iface call on interfaces.
1734  * This function is called on a slowpath, so it doesn't need to be fast.
1735  */
1736 MonoFtnDesc*
1737 mono_resolve_generic_virtual_iface_call (MonoVTable *vt, int imt_slot, MonoMethod *generic_virtual)
1738 {
1739         MonoError error;
1740         MonoMethod *m, *variant_iface;
1741         gpointer addr, aot_addr, compiled_method;
1742         gboolean need_unbox_tramp = FALSE;
1743         gboolean need_rgctx_tramp;
1744         gpointer arg = NULL;
1745         gpointer *imt;
1746
1747         imt = (gpointer*)vt - MONO_IMT_SIZE;
1748
1749         mini_resolve_imt_method (vt, imt + imt_slot, generic_virtual, &m, &aot_addr, &need_rgctx_tramp, &variant_iface, &error);
1750         if (!is_ok (&error)) {
1751                 MonoException *ex = mono_error_convert_to_exception (&error);
1752                 mono_llvm_throw_exception ((MonoObject*)ex);
1753         }
1754
1755         if (vt->klass->valuetype)
1756                 need_unbox_tramp = TRUE;
1757
1758         if (m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
1759                 m = mono_marshal_get_synchronized_wrapper (m);
1760
1761         addr = compiled_method = mono_compile_method_checked (m, &error);
1762         mono_error_raise_exception (&error);
1763         g_assert (addr);
1764
1765         addr = mini_add_method_wrappers_llvmonly (m, addr, FALSE, need_unbox_tramp, &arg);
1766
1767         /*
1768          * This wastes memory but the memory usage is bounded since
1769          * mono_method_add_generic_virtual_invocation () eventually builds an imt trampoline for
1770          * this vtable slot so we are not called any more for this instantiation.
1771          */
1772         MonoFtnDesc *ftndesc = mini_create_llvmonly_ftndesc (mono_domain_get (), addr, arg);
1773
1774         mono_method_add_generic_virtual_invocation (mono_domain_get (),
1775                                                                                                 vt, imt + imt_slot,
1776                                                                                                 variant_iface ? variant_iface : generic_virtual, ftndesc);
1777         return ftndesc;
1778 }
1779
1780 /*
1781  * mono_init_vtable_slot:
1782  *
1783  *   Initialize slot SLOT of VTABLE.
1784  * Return the contents of the vtable slot.
1785  */
1786 gpointer
1787 mono_init_vtable_slot (MonoVTable *vtable, int slot)
1788 {
1789         MonoError error;
1790         gpointer arg = NULL;
1791         gpointer addr;
1792         gpointer *ftnptr;
1793
1794         addr = resolve_vcall (vtable, slot, NULL, &arg, FALSE, &error);
1795         if (mono_error_set_pending_exception (&error))
1796                 return NULL;
1797         ftnptr = mono_domain_alloc0 (vtable->domain, 2 * sizeof (gpointer));
1798         ftnptr [0] = addr;
1799         ftnptr [1] = arg;
1800         mono_memory_barrier ();
1801
1802         vtable->vtable [slot] = ftnptr;
1803
1804         return ftnptr;
1805 }
1806
1807 /*
1808  * mono_llvmonly_init_delegate:
1809  *
1810  *   Initialize a MonoDelegate object.
1811  * Similar to mono_delegate_ctor ().
1812  */
1813 void
1814 mono_llvmonly_init_delegate (MonoDelegate *del)
1815 {
1816         MonoError error;
1817         MonoFtnDesc *ftndesc = *(MonoFtnDesc**)del->method_code;
1818
1819         /*
1820          * We store a MonoFtnDesc in del->method_code.
1821          * It would be better to store an ftndesc in del->method_ptr too,
1822          * but we don't have a a structure which could own its memory.
1823          */
1824         if (G_UNLIKELY (!ftndesc)) {
1825                 MonoMethod *m = del->method;
1826                 if (m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
1827                         m = mono_marshal_get_synchronized_wrapper (m);
1828
1829                 gpointer addr = mono_compile_method_checked (m, &error);
1830                 if (mono_error_set_pending_exception (&error))
1831                         return;
1832
1833                 if (m->klass->valuetype && mono_method_signature (m)->hasthis)
1834                     addr = mono_aot_get_unbox_trampoline (m);
1835
1836                 gpointer arg = mini_get_delegate_arg (del->method, addr);
1837
1838                 ftndesc = mini_create_llvmonly_ftndesc (mono_domain_get (), addr, arg);
1839                 mono_memory_barrier ();
1840                 *del->method_code = (gpointer)ftndesc;
1841         }
1842         del->method_ptr = ftndesc->addr;
1843         del->extra_arg = ftndesc->arg;
1844 }
1845
1846 void
1847 mono_llvmonly_init_delegate_virtual (MonoDelegate *del, MonoObject *target, MonoMethod *method)
1848 {
1849         MonoError error;
1850
1851         g_assert (target);
1852
1853         method = mono_object_get_virtual_method (target, method);
1854
1855         if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
1856                 method = mono_marshal_get_synchronized_wrapper (method);
1857
1858         del->method = method;
1859         del->method_ptr = mono_compile_method_checked (method, &error);
1860         if (mono_error_set_pending_exception (&error))
1861                 return;
1862         if (method->klass->valuetype)
1863                 del->method_ptr = mono_aot_get_unbox_trampoline (method);
1864         del->extra_arg = mini_get_delegate_arg (del->method, del->method_ptr);
1865 }
1866
1867 MonoObject*
1868 mono_get_assembly_object (MonoImage *image)
1869 {
1870         ICALL_ENTRY();
1871         MonoObjectHandle result = MONO_HANDLE_CAST (MonoObject, mono_assembly_get_object_handle (mono_domain_get (), image->assembly, &error));
1872         ICALL_RETURN_OBJ (result);
1873 }
1874
1875 MonoObject*
1876 mono_get_method_object (MonoMethod *method)
1877 {
1878         MonoError error;
1879         MonoObject * result;
1880         result = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), method, method->klass, &error);
1881         mono_error_set_pending_exception (&error);
1882         return result;
1883 }
1884
1885 double
1886 mono_ckfinite (double d)
1887 {
1888         if (isinf (d) || isnan (d))
1889                 mono_set_pending_exception (mono_get_exception_arithmetic ());
1890         return d;
1891 }
1892
1893 /*
1894  * mono_interruption_checkpoint_from_trampoline:
1895  *
1896  *   Check whenever the thread has a pending exception, and throw it
1897  * if needed.
1898  * Architectures should move away from calling this function and
1899  * instead call mono_thread_force_interruption_checkpoint_noraise (),
1900  * rewrind to the parent frame, and throw the exception normally.
1901  */
1902 void
1903 mono_interruption_checkpoint_from_trampoline (void)
1904 {
1905         MonoException *ex;
1906
1907         ex = mono_thread_force_interruption_checkpoint_noraise ();
1908         if (ex)
1909                 mono_raise_exception (ex);
1910 }
1911
1912 void
1913 mono_throw_method_access (MonoMethod *caller, MonoMethod *callee)
1914 {
1915         char *caller_name = mono_method_get_reflection_name (caller);
1916         char *callee_name = mono_method_get_reflection_name (callee);
1917         MonoError error;
1918
1919         error_init (&error);
1920         mono_error_set_generic_error (&error, "System", "MethodAccessException", "Method `%s' is inaccessible from method `%s'", callee_name, caller_name);
1921         mono_error_set_pending_exception (&error);
1922         g_free (callee_name);
1923         g_free (caller_name);
1924 }
1925
1926 void
1927 mono_dummy_jit_icall (void)
1928 {
1929 }