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