mono/mini/method-to-ir.c

   1 /*
   2  * method-to-ir.c: Convert CIL to the JIT internal representation
   3  *
   4  * Author:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *   Dietmar Maurer (dietmar@ximian.com)
   7  *
   8  * (C) 2002 Ximian, Inc.
   9  * Copyright 2003-2010 Novell, Inc (http://www.novell.com)
  10  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
  11  */
  12
  13 #include <config.h>
  14
  15 #ifndef DISABLE_JIT
  16
  17 #include <signal.h>
  18
  19 #ifdef HAVE_UNISTD_H
  20 #include <unistd.h>
  21 #endif
  22
  23 #include <math.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26
  27 #ifdef HAVE_SYS_TIME_H
  28 #include <sys/time.h>
  29 #endif
  30
  31 #ifdef HAVE_ALLOCA_H
  32 #include <alloca.h>
  33 #endif
  34
  35 #include <mono/utils/memcheck.h>
  36 #include "mini.h"
  37 #include <mono/metadata/abi-details.h>
  38 #include <mono/metadata/assembly.h>
  39 #include <mono/metadata/attrdefs.h>
  40 #include <mono/metadata/loader.h>
  41 #include <mono/metadata/tabledefs.h>
  42 #include <mono/metadata/class.h>
  43 #include <mono/metadata/object.h>
  44 #include <mono/metadata/exception.h>
  45 #include <mono/metadata/opcodes.h>
  46 #include <mono/metadata/mono-endian.h>
  47 #include <mono/metadata/tokentype.h>
  48 #include <mono/metadata/tabledefs.h>
  49 #include <mono/metadata/marshal.h>
  50 #include <mono/metadata/debug-helpers.h>
  51 #include <mono/metadata/mono-debug.h>
  52 #include <mono/metadata/mono-debug-debugger.h>
  53 #include <mono/metadata/gc-internals.h>
  54 #include <mono/metadata/security-manager.h>
  55 #include <mono/metadata/threads-types.h>
  56 #include <mono/metadata/security-core-clr.h>
  57 #include <mono/metadata/profiler-private.h>
  58 #include <mono/metadata/profiler.h>
  59 #include <mono/metadata/monitor.h>
  60 #include <mono/metadata/debug-mono-symfile.h>
  61 #include <mono/utils/mono-compiler.h>
  62 #include <mono/utils/mono-memory-model.h>
  63 #include <mono/metadata/mono-basic-block.h>
  64 #include <mono/metadata/reflection-internals.h>
  65
  66 #include "trace.h"
  67
  68 #include "ir-emit.h"
  69
  70 #include "jit-icalls.h"
  71 #include "jit.h"
  72 #include "debugger-agent.h"
  73 #include "seq-points.h"
  74 #include "aot-compiler.h"
  75 #include "mini-llvm.h"
  76
  77 #define BRANCH_COST 10
  78 #define INLINE_LENGTH_LIMIT 20
  79
  80 /* These have 'cfg' as an implicit argument */
  81 #define INLINE_FAILURE(msg) do {                                                                        \
  82         if ((cfg->method != cfg->current_method) && (cfg->current_method->wrapper_type == MONO_WRAPPER_NONE)) { \
  83                 inline_failure (cfg, msg);                                                                              \
  84                 goto exception_exit;                                                                                    \
  85         } \
  86         } while (0)
  87 #define CHECK_CFG_EXCEPTION do {\
  88                 if (cfg->exception_type != MONO_EXCEPTION_NONE) \
  89                         goto exception_exit;                                            \
  90         } while (0)
  91 #define METHOD_ACCESS_FAILURE(method, cmethod) do {                     \
  92                 method_access_failure ((cfg), (method), (cmethod));                     \
  93                 goto exception_exit;                                                                            \
  94         } while (0)
  95 #define FIELD_ACCESS_FAILURE(method, field) do {                                        \
  96                 field_access_failure ((cfg), (method), (field));                        \
  97                 goto exception_exit;    \
  98         } while (0)
  99 #define GENERIC_SHARING_FAILURE(opcode) do {            \
 100                 if (cfg->gshared) {                                                                     \
 101                         gshared_failure (cfg, opcode, __FILE__, __LINE__);      \
 102                         goto exception_exit;    \
 103                 }                       \
 104         } while (0)
 105 #define GSHAREDVT_FAILURE(opcode) do {          \
 106         if (cfg->gsharedvt) {                                                                                           \
 107                 gsharedvt_failure (cfg, opcode, __FILE__, __LINE__);                    \
 108                 goto exception_exit;                                                                                    \
 109         }                                                                                                                                       \
 110         } while (0)
 111 #define OUT_OF_MEMORY_FAILURE do {      \
 112                 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);                \
 113                 mono_error_set_out_of_memory (&cfg->error, "");                                 \
 114                 goto exception_exit;    \
 115         } while (0)
 116 #define DISABLE_AOT(cfg) do { \
 117                 if ((cfg)->verbose_level >= 2)                                            \
 118                         printf ("AOT disabled: %s:%d\n", __FILE__, __LINE__);   \
 119                 (cfg)->disable_aot = TRUE;                                                        \
 120         } while (0)
 121 #define LOAD_ERROR do { \
 122                 break_on_unverified ();                                                         \
 123                 mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD); \
 124                 goto exception_exit;                                                                    \
 125         } while (0)
 126
 127 #define TYPE_LOAD_ERROR(klass) do { \
 128                 cfg->exception_ptr = klass; \
 129                 LOAD_ERROR;                                     \
 130         } while (0)
 131
 132 #define CHECK_CFG_ERROR do {\
 133                 if (!mono_error_ok (&cfg->error)) { \
 134                         mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);        \
 135                         goto mono_error_exit; \
 136                 } \
 137         } while (0)
 138
 139 /* Determine whenever 'ins' represents a load of the 'this' argument */
 140 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
 141
 142 static int ldind_to_load_membase (int opcode);
 143 static int stind_to_store_membase (int opcode);
 144
 145 int mono_op_to_op_imm (int opcode);
 146 int mono_op_to_op_imm_noemul (int opcode);
 147
 148 MONO_API MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
 149
 150 static int inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
 151                                                   guchar *ip, guint real_offset, gboolean inline_always);
 152 static MonoInst*
 153 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp);
 154
 155 /* helper methods signatures */
 156 static MonoMethodSignature *helper_sig_domain_get;
 157 static MonoMethodSignature *helper_sig_rgctx_lazy_fetch_trampoline;
 158 static MonoMethodSignature *helper_sig_llvmonly_imt_thunk;
 159
 160
 161 /* type loading helpers */
 162 static GENERATE_GET_CLASS_WITH_CACHE (runtime_helpers, System.Runtime.CompilerServices, RuntimeHelpers)
 163 static GENERATE_TRY_GET_CLASS_WITH_CACHE (debuggable_attribute, System.Diagnostics, DebuggableAttribute)
 164
 165 /*
 166  * Instruction metadata
 167  */
 168 #ifdef MINI_OP
 169 #undef MINI_OP
 170 #endif
 171 #ifdef MINI_OP3
 172 #undef MINI_OP3
 173 #endif
 174 #define MINI_OP(a,b,dest,src1,src2) dest, src1, src2, ' ',
 175 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
 176 #define NONE ' '
 177 #define IREG 'i'
 178 #define FREG 'f'
 179 #define VREG 'v'
 180 #define XREG 'x'
 181 #if SIZEOF_REGISTER == 8 && SIZEOF_REGISTER == SIZEOF_VOID_P
 182 #define LREG IREG
 183 #else
 184 #define LREG 'l'
 185 #endif
 186 /* keep in sync with the enum in mini.h */
 187 const char
 188 ins_info[] = {
 189 #include "mini-ops.h"
 190 };
 191 #undef MINI_OP
 192 #undef MINI_OP3
 193
 194 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
 195 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
 196 /*
 197  * This should contain the index of the last sreg + 1. This is not the same
 198  * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
 199  */
 200 const gint8 ins_sreg_counts[] = {
 201 #include "mini-ops.h"
 202 };
 203 #undef MINI_OP
 204 #undef MINI_OP3
 205
 206 #define MONO_INIT_VARINFO(vi,id) do { \
 207         (vi)->range.first_use.pos.bid = 0xffff; \
 208         (vi)->reg = -1; \
 209         (vi)->idx = (id); \
 210 } while (0)
 211
 212 guint32
 213 mono_alloc_ireg (MonoCompile *cfg)
 214 {
 215         return alloc_ireg (cfg);
 216 }
 217
 218 guint32
 219 mono_alloc_lreg (MonoCompile *cfg)
 220 {
 221         return alloc_lreg (cfg);
 222 }
 223
 224 guint32
 225 mono_alloc_freg (MonoCompile *cfg)
 226 {
 227         return alloc_freg (cfg);
 228 }
 229
 230 guint32
 231 mono_alloc_preg (MonoCompile *cfg)
 232 {
 233         return alloc_preg (cfg);
 234 }
 235
 236 guint32
 237 mono_alloc_dreg (MonoCompile *cfg, MonoStackType stack_type)
 238 {
 239         return alloc_dreg (cfg, stack_type);
 240 }
 241
 242 /*
 243  * mono_alloc_ireg_ref:
 244  *
 245  *   Allocate an IREG, and mark it as holding a GC ref.
 246  */
 247 guint32
 248 mono_alloc_ireg_ref (MonoCompile *cfg)
 249 {
 250         return alloc_ireg_ref (cfg);
 251 }
 252
 253 /*
 254  * mono_alloc_ireg_mp:
 255  *
 256  *   Allocate an IREG, and mark it as holding a managed pointer.
 257  */
 258 guint32
 259 mono_alloc_ireg_mp (MonoCompile *cfg)
 260 {
 261         return alloc_ireg_mp (cfg);
 262 }
 263
 264 /*
 265  * mono_alloc_ireg_copy:
 266  *
 267  *   Allocate an IREG with the same GC type as VREG.
 268  */
 269 guint32
 270 mono_alloc_ireg_copy (MonoCompile *cfg, guint32 vreg)
 271 {
 272         if (vreg_is_ref (cfg, vreg))
 273                 return alloc_ireg_ref (cfg);
 274         else if (vreg_is_mp (cfg, vreg))
 275                 return alloc_ireg_mp (cfg);
 276         else
 277                 return alloc_ireg (cfg);
 278 }
 279
 280 guint
 281 mono_type_to_regmove (MonoCompile *cfg, MonoType *type)
 282 {
 283         if (type->byref)
 284                 return OP_MOVE;
 285
 286         type = mini_get_underlying_type (type);
 287 handle_enum:
 288         switch (type->type) {
 289         case MONO_TYPE_I1:
 290         case MONO_TYPE_U1:
 291                 return OP_MOVE;
 292         case MONO_TYPE_I2:
 293         case MONO_TYPE_U2:
 294                 return OP_MOVE;
 295         case MONO_TYPE_I4:
 296         case MONO_TYPE_U4:
 297                 return OP_MOVE;
 298         case MONO_TYPE_I:
 299         case MONO_TYPE_U:
 300         case MONO_TYPE_PTR:
 301         case MONO_TYPE_FNPTR:
 302                 return OP_MOVE;
 303         case MONO_TYPE_CLASS:
 304         case MONO_TYPE_STRING:
 305         case MONO_TYPE_OBJECT:
 306         case MONO_TYPE_SZARRAY:
 307         case MONO_TYPE_ARRAY:
 308                 return OP_MOVE;
 309         case MONO_TYPE_I8:
 310         case MONO_TYPE_U8:
 311 #if SIZEOF_REGISTER == 8
 312                 return OP_MOVE;
 313 #else
 314                 return OP_LMOVE;
 315 #endif
 316         case MONO_TYPE_R4:
 317                 return cfg->r4fp ? OP_RMOVE : OP_FMOVE;
 318         case MONO_TYPE_R8:
 319                 return OP_FMOVE;
 320         case MONO_TYPE_VALUETYPE:
 321                 if (type->data.klass->enumtype) {
 322                         type = mono_class_enum_basetype (type->data.klass);
 323                         goto handle_enum;
 324                 }
 325                 if (MONO_CLASS_IS_SIMD (cfg, mono_class_from_mono_type (type)))
 326                         return OP_XMOVE;
 327                 return OP_VMOVE;
 328         case MONO_TYPE_TYPEDBYREF:
 329                 return OP_VMOVE;
 330         case MONO_TYPE_GENERICINST:
 331                 type = &type->data.generic_class->container_class->byval_arg;
 332                 goto handle_enum;
 333         case MONO_TYPE_VAR:
 334         case MONO_TYPE_MVAR:
 335                 g_assert (cfg->gshared);
 336                 if (mini_type_var_is_vt (type))
 337                         return OP_VMOVE;
 338                 else
 339                         return mono_type_to_regmove (cfg, mini_get_underlying_type (type));
 340         default:
 341                 g_error ("unknown type 0x%02x in type_to_regstore", type->type);
 342         }
 343         return -1;
 344 }
 345
 346 void
 347 mono_print_bb (MonoBasicBlock *bb, const char *msg)
 348 {
 349         int i;
 350         MonoInst *tree;
 351
 352         printf ("\n%s %d: [IN: ", msg, bb->block_num);
 353         for (i = 0; i < bb->in_count; ++i)
 354                 printf (" BB%d(%d)", bb->in_bb [i]->block_num, bb->in_bb [i]->dfn);
 355         printf (", OUT: ");
 356         for (i = 0; i < bb->out_count; ++i)
 357                 printf (" BB%d(%d)", bb->out_bb [i]->block_num, bb->out_bb [i]->dfn);
 358         printf (" ]\n");
 359         for (tree = bb->code; tree; tree = tree->next)
 360                 mono_print_ins_index (-1, tree);
 361 }
 362
 363 void
 364 mono_create_helper_signatures (void)
 365 {
 366         helper_sig_domain_get = mono_create_icall_signature ("ptr");
 367         helper_sig_rgctx_lazy_fetch_trampoline = mono_create_icall_signature ("ptr ptr");
 368         helper_sig_llvmonly_imt_thunk = mono_create_icall_signature ("ptr ptr ptr");
 369 }
 370
 371 static MONO_NEVER_INLINE void
 372 break_on_unverified (void)
 373 {
 374         if (mini_get_debug_options ()->break_on_unverified)
 375                 G_BREAKPOINT ();
 376 }
 377
 378 static MONO_NEVER_INLINE void
 379 method_access_failure (MonoCompile *cfg, MonoMethod *method, MonoMethod *cil_method)
 380 {
 381         char *method_fname = mono_method_full_name (method, TRUE);
 382         char *cil_method_fname = mono_method_full_name (cil_method, TRUE);
 383         mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
 384         mono_error_set_generic_error (&cfg->error, "System", "MethodAccessException", "Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname);
 385         g_free (method_fname);
 386         g_free (cil_method_fname);
 387 }
 388
 389 static MONO_NEVER_INLINE void
 390 field_access_failure (MonoCompile *cfg, MonoMethod *method, MonoClassField *field)
 391 {
 392         char *method_fname = mono_method_full_name (method, TRUE);
 393         char *field_fname = mono_field_full_name (field);
 394         mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
 395         mono_error_set_generic_error (&cfg->error, "System", "FieldAccessException", "Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname);
 396         g_free (method_fname);
 397         g_free (field_fname);
 398 }
 399
 400 static MONO_NEVER_INLINE void
 401 inline_failure (MonoCompile *cfg, const char *msg)
 402 {
 403         if (cfg->verbose_level >= 2)
 404                 printf ("inline failed: %s\n", msg);
 405         mono_cfg_set_exception (cfg, MONO_EXCEPTION_INLINE_FAILED);
 406 }
 407
 408 static MONO_NEVER_INLINE void
 409 gshared_failure (MonoCompile *cfg, int opcode, const char *file, int line)
 410 {
 411         if (cfg->verbose_level > 2)                                                                                     \
 412                 printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", cfg->current_method->klass->name_space, cfg->current_method->klass->name, cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), line);
 413         mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED);
 414 }
 415
 416 static MONO_NEVER_INLINE void
 417 gsharedvt_failure (MonoCompile *cfg, int opcode, const char *file, int line)
 418 {
 419         cfg->exception_message = g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", cfg->current_method->klass->name_space, cfg->current_method->klass->name, cfg->current_method->name, cfg->current_method->signature->param_count, mono_opcode_name ((opcode)), file, line);
 420         if (cfg->verbose_level >= 2)
 421                 printf ("%s\n", cfg->exception_message);
 422         mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED);
 423 }
 424
 425 /*
 426  * When using gsharedvt, some instatiations might be verifiable, and some might be not. i.e.
 427  * foo<T> (int i) { ldarg.0; box T; }
 428  */
 429 #define UNVERIFIED do { \
 430         if (cfg->gsharedvt) { \
 431                 if (cfg->verbose_level > 2)                                                                     \
 432                         printf ("gsharedvt method failed to verify, falling back to instantiation.\n"); \
 433                 mono_cfg_set_exception (cfg, MONO_EXCEPTION_GENERIC_SHARING_FAILED); \
 434                 goto exception_exit;                                                                                    \
 435         }                                                                                                                                       \
 436         break_on_unverified ();                                                                                         \
 437         goto unverified;                                                                                                        \
 438 } while (0)
 439
 440 #define GET_BBLOCK(cfg,tblock,ip) do {  \
 441                 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
 442                 if (!(tblock)) {        \
 443                         if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
 444             NEW_BBLOCK (cfg, (tblock)); \
 445                         (tblock)->cil_code = (ip);      \
 446                         ADD_BBLOCK (cfg, (tblock));     \
 447                 } \
 448         } while (0)
 449
 450 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 451 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
 452                 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
 453                 (dest)->dreg = alloc_ireg_mp ((cfg)); \
 454                 (dest)->sreg1 = (sr1); \
 455                 (dest)->sreg2 = (sr2); \
 456                 (dest)->inst_imm = (imm); \
 457                 (dest)->backend.shift_amount = (shift); \
 458                 MONO_ADD_INS ((cfg)->cbb, (dest)); \
 459         } while (0)
 460 #endif
 461
 462 /* Emit conversions so both operands of a binary opcode are of the same type */
 463 static void
 464 add_widen_op (MonoCompile *cfg, MonoInst *ins, MonoInst **arg1_ref, MonoInst **arg2_ref)
 465 {
 466         MonoInst *arg1 = *arg1_ref;
 467         MonoInst *arg2 = *arg2_ref;
 468
 469         if (cfg->r4fp &&
 470                 ((arg1->type == STACK_R4 && arg2->type == STACK_R8) ||
 471                  (arg1->type == STACK_R8 && arg2->type == STACK_R4))) {
 472                 MonoInst *conv;
 473
 474                 /* Mixing r4/r8 is allowed by the spec */
 475                 if (arg1->type == STACK_R4) {
 476                         int dreg = alloc_freg (cfg);
 477
 478                         EMIT_NEW_UNALU (cfg, conv, OP_RCONV_TO_R8, dreg, arg1->dreg);
 479                         conv->type = STACK_R8;
 480                         ins->sreg1 = dreg;
 481                         *arg1_ref = conv;
 482                 }
 483                 if (arg2->type == STACK_R4) {
 484                         int dreg = alloc_freg (cfg);
 485
 486                         EMIT_NEW_UNALU (cfg, conv, OP_RCONV_TO_R8, dreg, arg2->dreg);
 487                         conv->type = STACK_R8;
 488                         ins->sreg2 = dreg;
 489                         *arg2_ref = conv;
 490                 }
 491         }
 492
 493 #if SIZEOF_REGISTER == 8
 494         /* FIXME: Need to add many more cases */
 495         if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) {
 496                 MonoInst *widen;
 497
 498                 int dr = alloc_preg (cfg);
 499                 EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg);
 500                 (ins)->sreg2 = widen->dreg;
 501         }
 502 #endif
 503 }
 504
 505 #define ADD_BINOP(op) do {      \
 506                 MONO_INST_NEW (cfg, ins, (op)); \
 507                 sp -= 2;        \
 508                 ins->sreg1 = sp [0]->dreg;      \
 509                 ins->sreg2 = sp [1]->dreg;      \
 510                 type_from_op (cfg, ins, sp [0], sp [1]);        \
 511                 CHECK_TYPE (ins);       \
 512                 /* Have to insert a widening op */               \
 513         add_widen_op (cfg, ins, &sp [0], &sp [1]);               \
 514         ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
 515         MONO_ADD_INS ((cfg)->cbb, (ins)); \
 516         *sp++ = mono_decompose_opcode ((cfg), (ins));   \
 517         } while (0)
 518
 519 #define ADD_UNOP(op) do {       \
 520                 MONO_INST_NEW (cfg, ins, (op)); \
 521                 sp--;   \
 522                 ins->sreg1 = sp [0]->dreg;      \
 523                 type_from_op (cfg, ins, sp [0], NULL);  \
 524                 CHECK_TYPE (ins);       \
 525         (ins)->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type); \
 526         MONO_ADD_INS ((cfg)->cbb, (ins)); \
 527                 *sp++ = mono_decompose_opcode (cfg, ins);       \
 528         } while (0)
 529
 530 #define ADD_BINCOND(next_block) do {    \
 531                 MonoInst *cmp;  \
 532                 sp -= 2; \
 533                 MONO_INST_NEW(cfg, cmp, OP_COMPARE);    \
 534                 cmp->sreg1 = sp [0]->dreg;      \
 535                 cmp->sreg2 = sp [1]->dreg;      \
 536                 type_from_op (cfg, cmp, sp [0], sp [1]);        \
 537                 CHECK_TYPE (cmp);       \
 538                 add_widen_op (cfg, cmp, &sp [0], &sp [1]);                                              \
 539                 type_from_op (cfg, ins, sp [0], sp [1]);                                                        \
 540                 ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);   \
 541                 GET_BBLOCK (cfg, tblock, target);               \
 542                 link_bblock (cfg, cfg->cbb, tblock);    \
 543                 ins->inst_true_bb = tblock;     \
 544                 if ((next_block)) {     \
 545                         link_bblock (cfg, cfg->cbb, (next_block));      \
 546                         ins->inst_false_bb = (next_block);      \
 547                         start_new_bblock = 1;   \
 548                 } else {        \
 549                         GET_BBLOCK (cfg, tblock, ip);           \
 550                         link_bblock (cfg, cfg->cbb, tblock);    \
 551                         ins->inst_false_bb = tblock;    \
 552                         start_new_bblock = 2;   \
 553                 }       \
 554                 if (sp != stack_start) {                                                                        \
 555                     handle_stack_args (cfg, stack_start, sp - stack_start); \
 556                         CHECK_UNVERIFIABLE (cfg); \
 557                 } \
 558         MONO_ADD_INS (cfg->cbb, cmp); \
 559                 MONO_ADD_INS (cfg->cbb, ins);   \
 560         } while (0)
 561
 562 /* *
 563  * link_bblock: Links two basic blocks
 564  *
 565  * links two basic blocks in the control flow graph, the 'from'
 566  * argument is the starting block and the 'to' argument is the block
 567  * the control flow ends to after 'from'.
 568  */
 569 static void
 570 link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to)
 571 {
 572         MonoBasicBlock **newa;
 573         int i, found;
 574
 575 #if 0
 576         if (from->cil_code) {
 577                 if (to->cil_code)
 578                         printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
 579                 else
 580                         printf ("edge from IL%04x to exit\n", from->cil_code - cfg->cil_code);
 581         } else {
 582                 if (to->cil_code)
 583                         printf ("edge from entry to IL_%04x\n", to->cil_code - cfg->cil_code);
 584                 else
 585                         printf ("edge from entry to exit\n");
 586         }
 587 #endif
 588
 589         found = FALSE;
 590         for (i = 0; i < from->out_count; ++i) {
 591                 if (to == from->out_bb [i]) {
 592                         found = TRUE;
 593                         break;
 594                 }
 595         }
 596         if (!found) {
 597                 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
 598                 for (i = 0; i < from->out_count; ++i) {
 599                         newa [i] = from->out_bb [i];
 600                 }
 601                 newa [i] = to;
 602                 from->out_count++;
 603                 from->out_bb = newa;
 604         }
 605
 606         found = FALSE;
 607         for (i = 0; i < to->in_count; ++i) {
 608                 if (from == to->in_bb [i]) {
 609                         found = TRUE;
 610                         break;
 611                 }
 612         }
 613         if (!found) {
 614                 newa = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
 615                 for (i = 0; i < to->in_count; ++i) {
 616                         newa [i] = to->in_bb [i];
 617                 }
 618                 newa [i] = from;
 619                 to->in_count++;
 620                 to->in_bb = newa;
 621         }
 622 }
 623
 624 void
 625 mono_link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to)
 626 {
 627         link_bblock (cfg, from, to);
 628 }
 629
 630 /**
 631  * mono_find_block_region:
 632  *
 633  *   We mark each basic block with a region ID. We use that to avoid BB
 634  *   optimizations when blocks are in different regions.
 635  *
 636  * Returns:
 637  *   A region token that encodes where this region is, and information
 638  *   about the clause owner for this block.
 639  *
 640  *   The region encodes the try/catch/filter clause that owns this block
 641  *   as well as the type.  -1 is a special value that represents a block
 642  *   that is in none of try/catch/filter.
 643  */
 644 static int
 645 mono_find_block_region (MonoCompile *cfg, int offset)
 646 {
 647         MonoMethodHeader *header = cfg->header;
 648         MonoExceptionClause *clause;
 649         int i;
 650
 651         for (i = 0; i < header->num_clauses; ++i) {
 652                 clause = &header->clauses [i];
 653                 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
 654                     (offset < (clause->handler_offset)))
 655                         return ((i + 1) << 8) | MONO_REGION_FILTER | clause->flags;
 656
 657                 if (MONO_OFFSET_IN_HANDLER (clause, offset)) {
 658                         if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY)
 659                                 return ((i + 1) << 8) | MONO_REGION_FINALLY | clause->flags;
 660                         else if (clause->flags == MONO_EXCEPTION_CLAUSE_FAULT)
 661                                 return ((i + 1) << 8) | MONO_REGION_FAULT | clause->flags;
 662                         else
 663                                 return ((i + 1) << 8) | MONO_REGION_CATCH | clause->flags;
 664                 }
 665         }
 666         for (i = 0; i < header->num_clauses; ++i) {
 667                 clause = &header->clauses [i];
 668
 669                 if (MONO_OFFSET_IN_CLAUSE (clause, offset))
 670                         return ((i + 1) << 8) | clause->flags;
 671         }
 672
 673         return -1;
 674 }
 675
 676 static GList*
 677 mono_find_final_block (MonoCompile *cfg, unsigned char *ip, unsigned char *target, int type)
 678 {
 679         MonoMethodHeader *header = cfg->header;
 680         MonoExceptionClause *clause;
 681         int i;
 682         GList *res = NULL;
 683
 684         for (i = 0; i < header->num_clauses; ++i) {
 685                 clause = &header->clauses [i];
 686                 if (MONO_OFFSET_IN_CLAUSE (clause, (ip - header->code)) &&
 687                     (!MONO_OFFSET_IN_CLAUSE (clause, (target - header->code)))) {
 688                         if (clause->flags == type)
 689                                 res = g_list_append (res, clause);
 690                 }
 691         }
 692         return res;
 693 }
 694
 695 static void
 696 mono_create_spvar_for_region (MonoCompile *cfg, int region)
 697 {
 698         MonoInst *var;
 699
 700         var = (MonoInst *)g_hash_table_lookup (cfg->spvars, GINT_TO_POINTER (region));
 701         if (var)
 702                 return;
 703
 704         var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
 705         /* prevent it from being register allocated */
 706         var->flags |= MONO_INST_VOLATILE;
 707
 708         g_hash_table_insert (cfg->spvars, GINT_TO_POINTER (region), var);
 709 }
 710
 711 MonoInst *
 712 mono_find_exvar_for_offset (MonoCompile *cfg, int offset)
 713 {
 714         return (MonoInst *)g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
 715 }
 716
 717 static MonoInst*
 718 mono_create_exvar_for_offset (MonoCompile *cfg, int offset)
 719 {
 720         MonoInst *var;
 721
 722         var = (MonoInst *)g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
 723         if (var)
 724                 return var;
 725
 726         var = mono_compile_create_var (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL);
 727         /* prevent it from being register allocated */
 728         var->flags |= MONO_INST_VOLATILE;
 729
 730         g_hash_table_insert (cfg->exvars, GINT_TO_POINTER (offset), var);
 731
 732         return var;
 733 }
 734
 735 /*
 736  * Returns the type used in the eval stack when @type is loaded.
 737  * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
 738  */
 739 void
 740 type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst)
 741 {
 742         MonoClass *klass;
 743
 744         type = mini_get_underlying_type (type);
 745         inst->klass = klass = mono_class_from_mono_type (type);
 746         if (type->byref) {
 747                 inst->type = STACK_MP;
 748                 return;
 749         }
 750
 751 handle_enum:
 752         switch (type->type) {
 753         case MONO_TYPE_VOID:
 754                 inst->type = STACK_INV;
 755                 return;
 756         case MONO_TYPE_I1:
 757         case MONO_TYPE_U1:
 758         case MONO_TYPE_I2:
 759         case MONO_TYPE_U2:
 760         case MONO_TYPE_I4:
 761         case MONO_TYPE_U4:
 762                 inst->type = STACK_I4;
 763                 return;
 764         case MONO_TYPE_I:
 765         case MONO_TYPE_U:
 766         case MONO_TYPE_PTR:
 767         case MONO_TYPE_FNPTR:
 768                 inst->type = STACK_PTR;
 769                 return;
 770         case MONO_TYPE_CLASS:
 771         case MONO_TYPE_STRING:
 772         case MONO_TYPE_OBJECT:
 773         case MONO_TYPE_SZARRAY:
 774         case MONO_TYPE_ARRAY:
 775                 inst->type = STACK_OBJ;
 776                 return;
 777         case MONO_TYPE_I8:
 778         case MONO_TYPE_U8:
 779                 inst->type = STACK_I8;
 780                 return;
 781         case MONO_TYPE_R4:
 782                 inst->type = cfg->r4_stack_type;
 783                 break;
 784         case MONO_TYPE_R8:
 785                 inst->type = STACK_R8;
 786                 return;
 787         case MONO_TYPE_VALUETYPE:
 788                 if (type->data.klass->enumtype) {
 789                         type = mono_class_enum_basetype (type->data.klass);
 790                         goto handle_enum;
 791                 } else {
 792                         inst->klass = klass;
 793                         inst->type = STACK_VTYPE;
 794                         return;
 795                 }
 796         case MONO_TYPE_TYPEDBYREF:
 797                 inst->klass = mono_defaults.typed_reference_class;
 798                 inst->type = STACK_VTYPE;
 799                 return;
 800         case MONO_TYPE_GENERICINST:
 801                 type = &type->data.generic_class->container_class->byval_arg;
 802                 goto handle_enum;
 803         case MONO_TYPE_VAR:
 804         case MONO_TYPE_MVAR:
 805                 g_assert (cfg->gshared);
 806                 if (mini_is_gsharedvt_type (type)) {
 807                         g_assert (cfg->gsharedvt);
 808                         inst->type = STACK_VTYPE;
 809                 } else {
 810                         type_to_eval_stack_type (cfg, mini_get_underlying_type (type), inst);
 811                 }
 812                 return;
 813         default:
 814                 g_error ("unknown type 0x%02x in eval stack type", type->type);
 815         }
 816 }
 817
 818 /*
 819  * The following tables are used to quickly validate the IL code in type_from_op ().
 820  */
 821 static const char
 822 bin_num_table [STACK_MAX] [STACK_MAX] = {
 823         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 824         {STACK_INV, STACK_I4,  STACK_INV, STACK_PTR, STACK_INV, STACK_MP,  STACK_INV, STACK_INV},
 825         {STACK_INV, STACK_INV, STACK_I8,  STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 826         {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_MP,  STACK_INV, STACK_INV},
 827         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8,  STACK_INV, STACK_INV, STACK_INV, STACK_R8},
 828         {STACK_INV, STACK_MP,  STACK_INV, STACK_MP,  STACK_INV, STACK_PTR, STACK_INV, STACK_INV},
 829         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 830         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 831         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R4}
 832 };
 833
 834 static const char
 835 neg_table [] = {
 836         STACK_INV, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_INV, STACK_INV, STACK_INV, STACK_R4
 837 };
 838
 839 /* reduce the size of this table */
 840 static const char
 841 bin_int_table [STACK_MAX] [STACK_MAX] = {
 842         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 843         {STACK_INV, STACK_I4,  STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 844         {STACK_INV, STACK_INV, STACK_I8,  STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 845         {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 846         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 847         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 848         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 849         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
 850 };
 851
 852 static const char
 853 bin_comp_table [STACK_MAX] [STACK_MAX] = {
 854 /*      Inv i  L  p  F  &  O  vt r4 */
 855         {0},
 856         {0, 1, 0, 1, 0, 0, 0, 0}, /* i, int32 */
 857         {0, 0, 1, 0, 0, 0, 0, 0}, /* L, int64 */
 858         {0, 1, 0, 1, 0, 2, 4, 0}, /* p, ptr */
 859         {0, 0, 0, 0, 1, 0, 0, 0, 1}, /* F, R8 */
 860         {0, 0, 0, 2, 0, 1, 0, 0}, /* &, managed pointer */
 861         {0, 0, 0, 4, 0, 0, 3, 0}, /* O, reference */
 862         {0, 0, 0, 0, 0, 0, 0, 0}, /* vt value type */
 863         {0, 0, 0, 0, 1, 0, 0, 0, 1}, /* r, r4 */
 864 };
 865
 866 /* reduce the size of this table */
 867 static const char
 868 shift_table [STACK_MAX] [STACK_MAX] = {
 869         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 870         {STACK_INV, STACK_I4,  STACK_INV, STACK_I4,  STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 871         {STACK_INV, STACK_I8,  STACK_INV, STACK_I8,  STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 872         {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 873         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 874         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 875         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 876         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
 877 };
 878
 879 /*
 880  * Tables to map from the non-specific opcode to the matching
 881  * type-specific opcode.
 882  */
 883 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
 884 static const guint16
 885 binops_op_map [STACK_MAX] = {
 886         0, OP_IADD-CEE_ADD, OP_LADD-CEE_ADD, OP_PADD-CEE_ADD, OP_FADD-CEE_ADD, OP_PADD-CEE_ADD, 0, 0, OP_RADD-CEE_ADD
 887 };
 888
 889 /* handles from CEE_NEG to CEE_CONV_U8 */
 890 static const guint16
 891 unops_op_map [STACK_MAX] = {
 892         0, OP_INEG-CEE_NEG, OP_LNEG-CEE_NEG, OP_PNEG-CEE_NEG, OP_FNEG-CEE_NEG, OP_PNEG-CEE_NEG, 0, 0, OP_RNEG-CEE_NEG
 893 };
 894
 895 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
 896 static const guint16
 897 ovfops_op_map [STACK_MAX] = {
 898         0, OP_ICONV_TO_U2-CEE_CONV_U2, OP_LCONV_TO_U2-CEE_CONV_U2, OP_PCONV_TO_U2-CEE_CONV_U2, OP_FCONV_TO_U2-CEE_CONV_U2, OP_PCONV_TO_U2-CEE_CONV_U2, OP_PCONV_TO_U2-CEE_CONV_U2, 0, OP_RCONV_TO_U2-CEE_CONV_U2
 899 };
 900
 901 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
 902 static const guint16
 903 ovf2ops_op_map [STACK_MAX] = {
 904         0, OP_ICONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_LCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_PCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_FCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, OP_PCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN, 0, 0, OP_RCONV_TO_OVF_I1_UN-CEE_CONV_OVF_I1_UN
 905 };
 906
 907 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
 908 static const guint16
 909 ovf3ops_op_map [STACK_MAX] = {
 910         0, OP_ICONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_LCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_PCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_FCONV_TO_OVF_I1-CEE_CONV_OVF_I1, OP_PCONV_TO_OVF_I1-CEE_CONV_OVF_I1, 0, 0, OP_RCONV_TO_OVF_I1-CEE_CONV_OVF_I1
 911 };
 912
 913 /* handles from CEE_BEQ to CEE_BLT_UN */
 914 static const guint16
 915 beqops_op_map [STACK_MAX] = {
 916         0, OP_IBEQ-CEE_BEQ, OP_LBEQ-CEE_BEQ, OP_PBEQ-CEE_BEQ, OP_FBEQ-CEE_BEQ, OP_PBEQ-CEE_BEQ, OP_PBEQ-CEE_BEQ, 0, OP_FBEQ-CEE_BEQ
 917 };
 918
 919 /* handles from CEE_CEQ to CEE_CLT_UN */
 920 static const guint16
 921 ceqops_op_map [STACK_MAX] = {
 922         0, OP_ICEQ-OP_CEQ, OP_LCEQ-OP_CEQ, OP_PCEQ-OP_CEQ, OP_FCEQ-OP_CEQ, OP_PCEQ-OP_CEQ, OP_PCEQ-OP_CEQ, 0, OP_RCEQ-OP_CEQ
 923 };
 924
 925 /*
 926  * Sets ins->type (the type on the eval stack) according to the
 927  * type of the opcode and the arguments to it.
 928  * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
 929  *
 930  * FIXME: this function sets ins->type unconditionally in some cases, but
 931  * it should set it to invalid for some types (a conv.x on an object)
 932  */
 933 static void
 934 type_from_op (MonoCompile *cfg, MonoInst *ins, MonoInst *src1, MonoInst *src2)
 935 {
 936         switch (ins->opcode) {
 937         /* binops */
 938         case CEE_ADD:
 939         case CEE_SUB:
 940         case CEE_MUL:
 941         case CEE_DIV:
 942         case CEE_REM:
 943                 /* FIXME: check unverifiable args for STACK_MP */
 944                 ins->type = bin_num_table [src1->type] [src2->type];
 945                 ins->opcode += binops_op_map [ins->type];
 946                 break;
 947         case CEE_DIV_UN:
 948         case CEE_REM_UN:
 949         case CEE_AND:
 950         case CEE_OR:
 951         case CEE_XOR:
 952                 ins->type = bin_int_table [src1->type] [src2->type];
 953                 ins->opcode += binops_op_map [ins->type];
 954                 break;
 955         case CEE_SHL:
 956         case CEE_SHR:
 957         case CEE_SHR_UN:
 958                 ins->type = shift_table [src1->type] [src2->type];
 959                 ins->opcode += binops_op_map [ins->type];
 960                 break;
 961         case OP_COMPARE:
 962         case OP_LCOMPARE:
 963         case OP_ICOMPARE:
 964                 ins->type = bin_comp_table [src1->type] [src2->type] ? STACK_I4: STACK_INV;
 965                 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
 966                         ins->opcode = OP_LCOMPARE;
 967                 else if (src1->type == STACK_R4)
 968                         ins->opcode = OP_RCOMPARE;
 969                 else if (src1->type == STACK_R8)
 970                         ins->opcode = OP_FCOMPARE;
 971                 else
 972                         ins->opcode = OP_ICOMPARE;
 973                 break;
 974         case OP_ICOMPARE_IMM:
 975                 ins->type = bin_comp_table [src1->type] [src1->type] ? STACK_I4 : STACK_INV;
 976                 if ((src1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
 977                         ins->opcode = OP_LCOMPARE_IMM;
 978                 break;
 979         case CEE_BEQ:
 980         case CEE_BGE:
 981         case CEE_BGT:
 982         case CEE_BLE:
 983         case CEE_BLT:
 984         case CEE_BNE_UN:
 985         case CEE_BGE_UN:
 986         case CEE_BGT_UN:
 987         case CEE_BLE_UN:
 988         case CEE_BLT_UN:
 989                 ins->opcode += beqops_op_map [src1->type];
 990                 break;
 991         case OP_CEQ:
 992                 ins->type = bin_comp_table [src1->type] [src2->type] ? STACK_I4: STACK_INV;
 993                 ins->opcode += ceqops_op_map [src1->type];
 994                 break;
 995         case OP_CGT:
 996         case OP_CGT_UN:
 997         case OP_CLT:
 998         case OP_CLT_UN:
 999                 ins->type = (bin_comp_table [src1->type] [src2->type] & 1) ? STACK_I4: STACK_INV;
1000                 ins->opcode += ceqops_op_map [src1->type];
1001                 break;
1002         /* unops */
1003         case CEE_NEG:
1004                 ins->type = neg_table [src1->type];
1005                 ins->opcode += unops_op_map [ins->type];
1006                 break;
1007         case CEE_NOT:
1008                 if (src1->type >= STACK_I4 && src1->type <= STACK_PTR)
1009                         ins->type = src1->type;
1010                 else
1011                         ins->type = STACK_INV;
1012                 ins->opcode += unops_op_map [ins->type];
1013                 break;
1014         case CEE_CONV_I1:
1015         case CEE_CONV_I2:
1016         case CEE_CONV_I4:
1017         case CEE_CONV_U4:
1018                 ins->type = STACK_I4;
1019                 ins->opcode += unops_op_map [src1->type];
1020                 break;
1021         case CEE_CONV_R_UN:
1022                 ins->type = STACK_R8;
1023                 switch (src1->type) {
1024                 case STACK_I4:
1025                 case STACK_PTR:
1026                         ins->opcode = OP_ICONV_TO_R_UN;
1027                         break;
1028                 case STACK_I8:
1029                         ins->opcode = OP_LCONV_TO_R_UN;
1030                         break;
1031                 }
1032                 break;
1033         case CEE_CONV_OVF_I1:
1034         case CEE_CONV_OVF_U1:
1035         case CEE_CONV_OVF_I2:
1036         case CEE_CONV_OVF_U2:
1037         case CEE_CONV_OVF_I4:
1038         case CEE_CONV_OVF_U4:
1039                 ins->type = STACK_I4;
1040                 ins->opcode += ovf3ops_op_map [src1->type];
1041                 break;
1042         case CEE_CONV_OVF_I_UN:
1043         case CEE_CONV_OVF_U_UN:
1044                 ins->type = STACK_PTR;
1045                 ins->opcode += ovf2ops_op_map [src1->type];
1046                 break;
1047         case CEE_CONV_OVF_I1_UN:
1048         case CEE_CONV_OVF_I2_UN:
1049         case CEE_CONV_OVF_I4_UN:
1050         case CEE_CONV_OVF_U1_UN:
1051         case CEE_CONV_OVF_U2_UN:
1052         case CEE_CONV_OVF_U4_UN:
1053                 ins->type = STACK_I4;
1054                 ins->opcode += ovf2ops_op_map [src1->type];
1055                 break;
1056         case CEE_CONV_U:
1057                 ins->type = STACK_PTR;
1058                 switch (src1->type) {
1059                 case STACK_I4:
1060                         ins->opcode = OP_ICONV_TO_U;
1061                         break;
1062                 case STACK_PTR:
1063                 case STACK_MP:
1064 #if SIZEOF_VOID_P == 8
1065                         ins->opcode = OP_LCONV_TO_U;
1066 #else
1067                         ins->opcode = OP_MOVE;
1068 #endif
1069                         break;
1070                 case STACK_I8:
1071                         ins->opcode = OP_LCONV_TO_U;
1072                         break;
1073                 case STACK_R8:
1074                         ins->opcode = OP_FCONV_TO_U;
1075                         break;
1076                 }
1077                 break;
1078         case CEE_CONV_I8:
1079         case CEE_CONV_U8:
1080                 ins->type = STACK_I8;
1081                 ins->opcode += unops_op_map [src1->type];
1082                 break;
1083         case CEE_CONV_OVF_I8:
1084         case CEE_CONV_OVF_U8:
1085                 ins->type = STACK_I8;
1086                 ins->opcode += ovf3ops_op_map [src1->type];
1087                 break;
1088         case CEE_CONV_OVF_U8_UN:
1089         case CEE_CONV_OVF_I8_UN:
1090                 ins->type = STACK_I8;
1091                 ins->opcode += ovf2ops_op_map [src1->type];
1092                 break;
1093         case CEE_CONV_R4:
1094                 ins->type = cfg->r4_stack_type;
1095                 ins->opcode += unops_op_map [src1->type];
1096                 break;
1097         case CEE_CONV_R8:
1098                 ins->type = STACK_R8;
1099                 ins->opcode += unops_op_map [src1->type];
1100                 break;
1101         case OP_CKFINITE:
1102                 ins->type = STACK_R8;
1103                 break;
1104         case CEE_CONV_U2:
1105         case CEE_CONV_U1:
1106                 ins->type = STACK_I4;
1107                 ins->opcode += ovfops_op_map [src1->type];
1108                 break;
1109         case CEE_CONV_I:
1110         case CEE_CONV_OVF_I:
1111         case CEE_CONV_OVF_U:
1112                 ins->type = STACK_PTR;
1113                 ins->opcode += ovfops_op_map [src1->type];
1114                 break;
1115         case CEE_ADD_OVF:
1116         case CEE_ADD_OVF_UN:
1117         case CEE_MUL_OVF:
1118         case CEE_MUL_OVF_UN:
1119         case CEE_SUB_OVF:
1120         case CEE_SUB_OVF_UN:
1121                 ins->type = bin_num_table [src1->type] [src2->type];
1122                 ins->opcode += ovfops_op_map [src1->type];
1123                 if (ins->type == STACK_R8)
1124                         ins->type = STACK_INV;
1125                 break;
1126         case OP_LOAD_MEMBASE:
1127                 ins->type = STACK_PTR;
1128                 break;
1129         case OP_LOADI1_MEMBASE:
1130         case OP_LOADU1_MEMBASE:
1131         case OP_LOADI2_MEMBASE:
1132         case OP_LOADU2_MEMBASE:
1133         case OP_LOADI4_MEMBASE:
1134         case OP_LOADU4_MEMBASE:
1135                 ins->type = STACK_PTR;
1136                 break;
1137         case OP_LOADI8_MEMBASE:
1138                 ins->type = STACK_I8;
1139                 break;
1140         case OP_LOADR4_MEMBASE:
1141                 ins->type = cfg->r4_stack_type;
1142                 break;
1143         case OP_LOADR8_MEMBASE:
1144                 ins->type = STACK_R8;
1145                 break;
1146         default:
1147                 g_error ("opcode 0x%04x not handled in type from op", ins->opcode);
1148                 break;
1149         }
1150
1151         if (ins->type == STACK_MP)
1152                 ins->klass = mono_defaults.object_class;
1153 }
1154
1155 static const char
1156 ldind_type [] = {
1157         STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
1158 };
1159
1160 #if 0
1161
1162 static const char
1163 param_table [STACK_MAX] [STACK_MAX] = {
1164         {0},
1165 };
1166
1167 static int
1168 check_values_to_signature (MonoInst *args, MonoType *this_ins, MonoMethodSignature *sig)
1169 {
1170         int i;
1171
1172         if (sig->hasthis) {
1173                 switch (args->type) {
1174                 case STACK_I4:
1175                 case STACK_I8:
1176                 case STACK_R8:
1177                 case STACK_VTYPE:
1178                 case STACK_INV:
1179                         return 0;
1180                 }
1181                 args++;
1182         }
1183         for (i = 0; i < sig->param_count; ++i) {
1184                 switch (args [i].type) {
1185                 case STACK_INV:
1186                         return 0;
1187                 case STACK_MP:
1188                         if (!sig->params [i]->byref)
1189                                 return 0;
1190                         continue;
1191                 case STACK_OBJ:
1192                         if (sig->params [i]->byref)
1193                                 return 0;
1194                         switch (sig->params [i]->type) {
1195                         case MONO_TYPE_CLASS:
1196                         case MONO_TYPE_STRING:
1197                         case MONO_TYPE_OBJECT:
1198                         case MONO_TYPE_SZARRAY:
1199                         case MONO_TYPE_ARRAY:
1200                                 break;
1201                         default:
1202                                 return 0;
1203                         }
1204                         continue;
1205                 case STACK_R8:
1206                         if (sig->params [i]->byref)
1207                                 return 0;
1208                         if (sig->params [i]->type != MONO_TYPE_R4 && sig->params [i]->type != MONO_TYPE_R8)
1209                                 return 0;
1210                         continue;
1211                 case STACK_PTR:
1212                 case STACK_I4:
1213                 case STACK_I8:
1214                 case STACK_VTYPE:
1215                         break;
1216                 }
1217                 /*if (!param_table [args [i].type] [sig->params [i]->type])
1218                         return 0;*/
1219         }
1220         return 1;
1221 }
1222 #endif
1223
1224 /*
1225  * When we need a pointer to the current domain many times in a method, we
1226  * call mono_domain_get() once and we store the result in a local variable.
1227  * This function returns the variable that represents the MonoDomain*.
1228  */
1229 inline static MonoInst *
1230 mono_get_domainvar (MonoCompile *cfg)
1231 {
1232         if (!cfg->domainvar)
1233                 cfg->domainvar = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1234         return cfg->domainvar;
1235 }
1236
1237 /*
1238  * The got_var contains the address of the Global Offset Table when AOT
1239  * compiling.
1240  */
1241 MonoInst *
1242 mono_get_got_var (MonoCompile *cfg)
1243 {
1244         if (!cfg->compile_aot || !cfg->backend->need_got_var)
1245                 return NULL;
1246         if (!cfg->got_var) {
1247                 cfg->got_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1248         }
1249         return cfg->got_var;
1250 }
1251
1252 static MonoInst *
1253 mono_get_vtable_var (MonoCompile *cfg)
1254 {
1255         g_assert (cfg->gshared);
1256
1257         if (!cfg->rgctx_var) {
1258                 cfg->rgctx_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1259                 /* force the var to be stack allocated */
1260                 cfg->rgctx_var->flags |= MONO_INST_VOLATILE;
1261         }
1262
1263         return cfg->rgctx_var;
1264 }
1265
1266 static MonoType*
1267 type_from_stack_type (MonoInst *ins) {
1268         switch (ins->type) {
1269         case STACK_I4: return &mono_defaults.int32_class->byval_arg;
1270         case STACK_I8: return &mono_defaults.int64_class->byval_arg;
1271         case STACK_PTR: return &mono_defaults.int_class->byval_arg;
1272         case STACK_R4: return &mono_defaults.single_class->byval_arg;
1273         case STACK_R8: return &mono_defaults.double_class->byval_arg;
1274         case STACK_MP:
1275                 return &ins->klass->this_arg;
1276         case STACK_OBJ: return &mono_defaults.object_class->byval_arg;
1277         case STACK_VTYPE: return &ins->klass->byval_arg;
1278         default:
1279                 g_error ("stack type %d to monotype not handled\n", ins->type);
1280         }
1281         return NULL;
1282 }
1283
1284 static G_GNUC_UNUSED int
1285 type_to_stack_type (MonoCompile *cfg, MonoType *t)
1286 {
1287         t = mono_type_get_underlying_type (t);
1288         switch (t->type) {
1289         case MONO_TYPE_I1:
1290         case MONO_TYPE_U1:
1291         case MONO_TYPE_I2:
1292         case MONO_TYPE_U2:
1293         case MONO_TYPE_I4:
1294         case MONO_TYPE_U4:
1295                 return STACK_I4;
1296         case MONO_TYPE_I:
1297         case MONO_TYPE_U:
1298         case MONO_TYPE_PTR:
1299         case MONO_TYPE_FNPTR:
1300                 return STACK_PTR;
1301         case MONO_TYPE_CLASS:
1302         case MONO_TYPE_STRING:
1303         case MONO_TYPE_OBJECT:
1304         case MONO_TYPE_SZARRAY:
1305         case MONO_TYPE_ARRAY:
1306                 return STACK_OBJ;
1307         case MONO_TYPE_I8:
1308         case MONO_TYPE_U8:
1309                 return STACK_I8;
1310         case MONO_TYPE_R4:
1311                 return cfg->r4_stack_type;
1312         case MONO_TYPE_R8:
1313                 return STACK_R8;
1314         case MONO_TYPE_VALUETYPE:
1315         case MONO_TYPE_TYPEDBYREF:
1316                 return STACK_VTYPE;
1317         case MONO_TYPE_GENERICINST:
1318                 if (mono_type_generic_inst_is_valuetype (t))
1319                         return STACK_VTYPE;
1320                 else
1321                         return STACK_OBJ;
1322                 break;
1323         default:
1324                 g_assert_not_reached ();
1325         }
1326
1327         return -1;
1328 }
1329
1330 static MonoClass*
1331 array_access_to_klass (int opcode)
1332 {
1333         switch (opcode) {
1334         case CEE_LDELEM_U1:
1335                 return mono_defaults.byte_class;
1336         case CEE_LDELEM_U2:
1337                 return mono_defaults.uint16_class;
1338         case CEE_LDELEM_I:
1339         case CEE_STELEM_I:
1340                 return mono_defaults.int_class;
1341         case CEE_LDELEM_I1:
1342         case CEE_STELEM_I1:
1343                 return mono_defaults.sbyte_class;
1344         case CEE_LDELEM_I2:
1345         case CEE_STELEM_I2:
1346                 return mono_defaults.int16_class;
1347         case CEE_LDELEM_I4:
1348         case CEE_STELEM_I4:
1349                 return mono_defaults.int32_class;
1350         case CEE_LDELEM_U4:
1351                 return mono_defaults.uint32_class;
1352         case CEE_LDELEM_I8:
1353         case CEE_STELEM_I8:
1354                 return mono_defaults.int64_class;
1355         case CEE_LDELEM_R4:
1356         case CEE_STELEM_R4:
1357                 return mono_defaults.single_class;
1358         case CEE_LDELEM_R8:
1359         case CEE_STELEM_R8:
1360                 return mono_defaults.double_class;
1361         case CEE_LDELEM_REF:
1362         case CEE_STELEM_REF:
1363                 return mono_defaults.object_class;
1364         default:
1365                 g_assert_not_reached ();
1366         }
1367         return NULL;
1368 }
1369
1370 /*
1371  * We try to share variables when possible
1372  */
1373 static MonoInst *
1374 mono_compile_get_interface_var (MonoCompile *cfg, int slot, MonoInst *ins)
1375 {
1376         MonoInst *res;
1377         int pos, vnum;
1378
1379         /* inlining can result in deeper stacks */
1380         if (slot >= cfg->header->max_stack)
1381                 return mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
1382
1383         pos = ins->type - 1 + slot * STACK_MAX;
1384
1385         switch (ins->type) {
1386         case STACK_I4:
1387         case STACK_I8:
1388         case STACK_R8:
1389         case STACK_PTR:
1390         case STACK_MP:
1391         case STACK_OBJ:
1392                 if ((vnum = cfg->intvars [pos]))
1393                         return cfg->varinfo [vnum];
1394                 res = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
1395                 cfg->intvars [pos] = res->inst_c0;
1396                 break;
1397         default:
1398                 res = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
1399         }
1400         return res;
1401 }
1402
1403 static void
1404 mono_save_token_info (MonoCompile *cfg, MonoImage *image, guint32 token, gpointer key)
1405 {
1406         /*
1407          * Don't use this if a generic_context is set, since that means AOT can't
1408          * look up the method using just the image+token.
1409          * table == 0 means this is a reference made from a wrapper.
1410          */
1411         if (cfg->compile_aot && !cfg->generic_context && (mono_metadata_token_table (token) > 0)) {
1412                 MonoJumpInfoToken *jump_info_token = (MonoJumpInfoToken *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1413                 jump_info_token->image = image;
1414                 jump_info_token->token = token;
1415                 g_hash_table_insert (cfg->token_info_hash, key, jump_info_token);
1416         }
1417 }
1418
1419 /*
1420  * This function is called to handle items that are left on the evaluation stack
1421  * at basic block boundaries. What happens is that we save the values to local variables
1422  * and we reload them later when first entering the target basic block (with the
1423  * handle_loaded_temps () function).
1424  * A single joint point will use the same variables (stored in the array bb->out_stack or
1425  * bb->in_stack, if the basic block is before or after the joint point).
1426  *
1427  * This function needs to be called _before_ emitting the last instruction of
1428  * the bb (i.e. before emitting a branch).
1429  * If the stack merge fails at a join point, cfg->unverifiable is set.
1430  */
1431 static void
1432 handle_stack_args (MonoCompile *cfg, MonoInst **sp, int count)
1433 {
1434         int i, bindex;
1435         MonoBasicBlock *bb = cfg->cbb;
1436         MonoBasicBlock *outb;
1437         MonoInst *inst, **locals;
1438         gboolean found;
1439
1440         if (!count)
1441                 return;
1442         if (cfg->verbose_level > 3)
1443                 printf ("%d item(s) on exit from B%d\n", count, bb->block_num);
1444         if (!bb->out_scount) {
1445                 bb->out_scount = count;
1446                 //printf ("bblock %d has out:", bb->block_num);
1447                 found = FALSE;
1448                 for (i = 0; i < bb->out_count; ++i) {
1449                         outb = bb->out_bb [i];
1450                         /* exception handlers are linked, but they should not be considered for stack args */
1451                         if (outb->flags & BB_EXCEPTION_HANDLER)
1452                                 continue;
1453                         //printf (" %d", outb->block_num);
1454                         if (outb->in_stack) {
1455                                 found = TRUE;
1456                                 bb->out_stack = outb->in_stack;
1457                                 break;
1458                         }
1459                 }
1460                 //printf ("\n");
1461                 if (!found) {
1462                         bb->out_stack = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * count);
1463                         for (i = 0; i < count; ++i) {
1464                                 /*
1465                                  * try to reuse temps already allocated for this purpouse, if they occupy the same
1466                                  * stack slot and if they are of the same type.
1467                                  * This won't cause conflicts since if 'local' is used to
1468                                  * store one of the values in the in_stack of a bblock, then
1469                                  * the same variable will be used for the same outgoing stack
1470                                  * slot as well.
1471                                  * This doesn't work when inlining methods, since the bblocks
1472                                  * in the inlined methods do not inherit their in_stack from
1473                                  * the bblock they are inlined to. See bug #58863 for an
1474                                  * example.
1475                                  */
1476                                 if (cfg->inlined_method)
1477                                         bb->out_stack [i] = mono_compile_create_var (cfg, type_from_stack_type (sp [i]), OP_LOCAL);
1478                                 else
1479                                         bb->out_stack [i] = mono_compile_get_interface_var (cfg, i, sp [i]);
1480                         }
1481                 }
1482         }
1483
1484         for (i = 0; i < bb->out_count; ++i) {
1485                 outb = bb->out_bb [i];
1486                 /* exception handlers are linked, but they should not be considered for stack args */
1487                 if (outb->flags & BB_EXCEPTION_HANDLER)
1488                         continue;
1489                 if (outb->in_scount) {
1490                         if (outb->in_scount != bb->out_scount) {
1491                                 cfg->unverifiable = TRUE;
1492                                 return;
1493                         }
1494                         continue; /* check they are the same locals */
1495                 }
1496                 outb->in_scount = count;
1497                 outb->in_stack = bb->out_stack;
1498         }
1499
1500         locals = bb->out_stack;
1501         cfg->cbb = bb;
1502         for (i = 0; i < count; ++i) {
1503                 EMIT_NEW_TEMPSTORE (cfg, inst, locals [i]->inst_c0, sp [i]);
1504                 inst->cil_code = sp [i]->cil_code;
1505                 sp [i] = locals [i];
1506                 if (cfg->verbose_level > 3)
1507                         printf ("storing %d to temp %d\n", i, (int)locals [i]->inst_c0);
1508         }
1509
1510         /*
1511          * It is possible that the out bblocks already have in_stack assigned, and
1512          * the in_stacks differ. In this case, we will store to all the different
1513          * in_stacks.
1514          */
1515
1516         found = TRUE;
1517         bindex = 0;
1518         while (found) {
1519                 /* Find a bblock which has a different in_stack */
1520                 found = FALSE;
1521                 while (bindex < bb->out_count) {
1522                         outb = bb->out_bb [bindex];
1523                         /* exception handlers are linked, but they should not be considered for stack args */
1524                         if (outb->flags & BB_EXCEPTION_HANDLER) {
1525                                 bindex++;
1526                                 continue;
1527                         }
1528                         if (outb->in_stack != locals) {
1529                                 for (i = 0; i < count; ++i) {
1530                                         EMIT_NEW_TEMPSTORE (cfg, inst, outb->in_stack [i]->inst_c0, sp [i]);
1531                                         inst->cil_code = sp [i]->cil_code;
1532                                         sp [i] = locals [i];
1533                                         if (cfg->verbose_level > 3)
1534                                                 printf ("storing %d to temp %d\n", i, (int)outb->in_stack [i]->inst_c0);
1535                                 }
1536                                 locals = outb->in_stack;
1537                                 found = TRUE;
1538                                 break;
1539                         }
1540                         bindex ++;
1541                 }
1542         }
1543 }
1544
1545 static MonoInst*
1546 emit_runtime_constant (MonoCompile *cfg, MonoJumpInfoType patch_type, gpointer data)
1547 {
1548         MonoInst *ins;
1549
1550         if (cfg->compile_aot) {
1551                 EMIT_NEW_AOTCONST (cfg, ins, patch_type, data);
1552         } else {
1553                 MonoJumpInfo ji;
1554                 gpointer target;
1555                 MonoError error;
1556
1557                 ji.type = patch_type;
1558                 ji.data.target = data;
1559                 target = mono_resolve_patch_target (NULL, cfg->domain, NULL, &ji, FALSE, &error);
1560                 mono_error_assert_ok (&error);
1561
1562                 EMIT_NEW_PCONST (cfg, ins, target);
1563         }
1564         return ins;
1565 }
1566
1567 static void
1568 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1569 {
1570         int ibitmap_reg = alloc_preg (cfg);
1571 #ifdef COMPRESSED_INTERFACE_BITMAP
1572         MonoInst *args [2];
1573         MonoInst *res, *ins;
1574         NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, ibitmap_reg, base_reg, offset);
1575         MONO_ADD_INS (cfg->cbb, ins);
1576         args [0] = ins;
1577         args [1] = emit_runtime_constant (cfg, MONO_PATCH_INFO_IID, klass);
1578         res = mono_emit_jit_icall (cfg, mono_class_interface_match, args);
1579         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, intf_bit_reg, res->dreg);
1580 #else
1581         int ibitmap_byte_reg = alloc_preg (cfg);
1582
1583         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, base_reg, offset);
1584
1585         if (cfg->compile_aot) {
1586                 int iid_reg = alloc_preg (cfg);
1587                 int shifted_iid_reg = alloc_preg (cfg);
1588                 int ibitmap_byte_address_reg = alloc_preg (cfg);
1589                 int masked_iid_reg = alloc_preg (cfg);
1590                 int iid_one_bit_reg = alloc_preg (cfg);
1591                 int iid_bit_reg = alloc_preg (cfg);
1592                 MONO_EMIT_NEW_AOTCONST (cfg, iid_reg, klass, MONO_PATCH_INFO_IID);
1593                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_IMM, shifted_iid_reg, iid_reg, 3);
1594                 MONO_EMIT_NEW_BIALU (cfg, OP_PADD, ibitmap_byte_address_reg, ibitmap_reg, shifted_iid_reg);
1595                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1596                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, masked_iid_reg, iid_reg, 7);
1597                 MONO_EMIT_NEW_ICONST (cfg, iid_one_bit_reg, 1);
1598                 MONO_EMIT_NEW_BIALU (cfg, OP_ISHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg);
1599                 MONO_EMIT_NEW_BIALU (cfg, OP_IAND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg);
1600         } else {
1601                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1602                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1603         }
1604 #endif
1605 }
1606
1607 /*
1608  * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1609  * stored in "klass_reg" implements the interface "klass".
1610  */
1611 static void
1612 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1613 {
1614         mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1615 }
1616
1617 /*
1618  * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1619  * stored in "vtable_reg" implements the interface "klass".
1620  */
1621 static void
1622 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1623 {
1624         mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1625 }
1626
1627 /*
1628  * Emit code which checks whenever the interface id of @klass is smaller than
1629  * than the value given by max_iid_reg.
1630 */
1631 static void
1632 mini_emit_max_iid_check (MonoCompile *cfg, int max_iid_reg, MonoClass *klass,
1633                                                  MonoBasicBlock *false_target)
1634 {
1635         if (cfg->compile_aot) {
1636                 int iid_reg = alloc_preg (cfg);
1637                 MONO_EMIT_NEW_AOTCONST (cfg, iid_reg, klass, MONO_PATCH_INFO_IID);
1638                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, max_iid_reg, iid_reg);
1639         }
1640         else
1641                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, max_iid_reg, klass->interface_id);
1642         if (false_target)
1643                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target);
1644         else
1645                 MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "InvalidCastException");
1646 }
1647
1648 /* Same as above, but obtains max_iid from a vtable */
1649 static void
1650 mini_emit_max_iid_check_vtable (MonoCompile *cfg, int vtable_reg, MonoClass *klass,
1651                                                                  MonoBasicBlock *false_target)
1652 {
1653         int max_iid_reg = alloc_preg (cfg);
1654
1655         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, max_interface_id));
1656         mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
1657 }
1658
1659 /* Same as above, but obtains max_iid from a klass */
1660 static void
1661 mini_emit_max_iid_check_class (MonoCompile *cfg, int klass_reg, MonoClass *klass,
1662                                                                  MonoBasicBlock *false_target)
1663 {
1664         int max_iid_reg = alloc_preg (cfg);
1665
1666         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, max_interface_id));
1667         mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
1668 }
1669
1670 static void
1671 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1672 {
1673         int idepth_reg = alloc_preg (cfg);
1674         int stypes_reg = alloc_preg (cfg);
1675         int stype = alloc_preg (cfg);
1676
1677         mono_class_setup_supertypes (klass);
1678
1679         if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1680                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1681                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
1682                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target);
1683         }
1684         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1685         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1686         if (klass_ins) {
1687                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, stype, klass_ins->dreg);
1688         } else if (cfg->compile_aot) {
1689                 int const_reg = alloc_preg (cfg);
1690                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
1691                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, stype, const_reg);
1692         } else {
1693                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, stype, klass);
1694         }
1695         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, true_target);
1696 }
1697
1698 static void
1699 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1700 {
1701         mini_emit_isninst_cast_inst (cfg, klass_reg, klass, NULL, false_target, true_target);
1702 }
1703
1704 static void
1705 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1706 {
1707         int intf_reg = alloc_preg (cfg);
1708
1709         mini_emit_max_iid_check_vtable (cfg, vtable_reg, klass, false_target);
1710         mini_emit_load_intf_bit_reg_vtable (cfg, intf_reg, vtable_reg, klass);
1711         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, intf_reg, 0);
1712         if (true_target)
1713                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, true_target);
1714         else
1715                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "InvalidCastException");
1716 }
1717
1718 /*
1719  * Variant of the above that takes a register to the class, not the vtable.
1720  */
1721 static void
1722 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1723 {
1724         int intf_bit_reg = alloc_preg (cfg);
1725
1726         mini_emit_max_iid_check_class (cfg, klass_reg, klass, false_target);
1727         mini_emit_load_intf_bit_reg_class (cfg, intf_bit_reg, klass_reg, klass);
1728         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, intf_bit_reg, 0);
1729         if (true_target)
1730                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, true_target);
1731         else
1732                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "InvalidCastException");
1733 }
1734
1735 static inline void
1736 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1737 {
1738         if (klass_inst) {
1739                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, klass_inst->dreg);
1740         } else {
1741                 MonoInst *ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_CLASS, klass);
1742                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, ins->dreg);
1743         }
1744         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
1745 }
1746
1747 static inline void
1748 mini_emit_class_check (MonoCompile *cfg, int klass_reg, MonoClass *klass)
1749 {
1750         mini_emit_class_check_inst (cfg, klass_reg, klass, NULL);
1751 }
1752
1753 static inline void
1754 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1755 {
1756         if (cfg->compile_aot) {
1757                 int const_reg = alloc_preg (cfg);
1758                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
1759                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, const_reg);
1760         } else {
1761                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
1762         }
1763         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, branch_op, target);
1764 }
1765
1766 static void
1767 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1768
1769 static void
1770 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1771 {
1772         if (klass->rank) {
1773                 int rank_reg = alloc_preg (cfg);
1774                 int eclass_reg = alloc_preg (cfg);
1775
1776                 g_assert (!klass_inst);
1777                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, rank));
1778                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
1779                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
1780                 //              MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
1781                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
1782                 if (klass->cast_class == mono_defaults.object_class) {
1783                         int parent_reg = alloc_preg (cfg);
1784                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
1785                         mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1786                         mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
1787                 } else if (klass->cast_class == mono_defaults.enum_class->parent) {
1788                         mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1789                         mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
1790                 } else if (klass->cast_class == mono_defaults.enum_class) {
1791                         mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
1792                 } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
1793                         mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, NULL, NULL);
1794                 } else {
1795                         // Pass -1 as obj_reg to skip the check below for arrays of arrays
1796                         mini_emit_castclass (cfg, -1, eclass_reg, klass->cast_class, object_is_null);
1797                 }
1798
1799                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY) && (obj_reg != -1)) {
1800                         /* Check that the object is a vector too */
1801                         int bounds_reg = alloc_preg (cfg);
1802                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg, obj_reg, MONO_STRUCT_OFFSET (MonoArray, bounds));
1803                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, bounds_reg, 0);
1804                         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
1805                 }
1806         } else {
1807                 int idepth_reg = alloc_preg (cfg);
1808                 int stypes_reg = alloc_preg (cfg);
1809                 int stype = alloc_preg (cfg);
1810
1811                 mono_class_setup_supertypes (klass);
1812
1813                 if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1814                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth));
1815                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
1816                         MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "InvalidCastException");
1817                 }
1818                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes));
1819                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1820                 mini_emit_class_check_inst (cfg, stype, klass, klass_inst);
1821         }
1822 }
1823
1824 static void
1825 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1826 {
1827         mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, NULL, object_is_null);
1828 }
1829
1830 static void
1831 mini_emit_memset (MonoCompile *cfg, int destreg, int offset, int size, int val, int align)
1832 {
1833         int val_reg;
1834
1835         g_assert (val == 0);
1836
1837         if (align == 0)
1838                 align = 4;
1839
1840         if ((size <= SIZEOF_REGISTER) && (size <= align)) {
1841                 switch (size) {
1842                 case 1:
1843                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI1_MEMBASE_IMM, destreg, offset, val);
1844                         return;
1845                 case 2:
1846                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI2_MEMBASE_IMM, destreg, offset, val);
1847                         return;
1848                 case 4:
1849                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI4_MEMBASE_IMM, destreg, offset, val);
1850                         return;
1851 #if SIZEOF_REGISTER == 8
1852                 case 8:
1853                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI8_MEMBASE_IMM, destreg, offset, val);
1854                         return;
1855 #endif
1856                 }
1857         }
1858
1859         val_reg = alloc_preg (cfg);
1860
1861         if (SIZEOF_REGISTER == 8)
1862                 MONO_EMIT_NEW_I8CONST (cfg, val_reg, val);
1863         else
1864                 MONO_EMIT_NEW_ICONST (cfg, val_reg, val);
1865
1866         if (align < 4) {
1867                 /* This could be optimized further if neccesary */
1868                 while (size >= 1) {
1869                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
1870                         offset += 1;
1871                         size -= 1;
1872                 }
1873                 return;
1874         }
1875
1876         if (!cfg->backend->no_unaligned_access && SIZEOF_REGISTER == 8) {
1877                 if (offset % 8) {
1878                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
1879                         offset += 4;
1880                         size -= 4;
1881                 }
1882                 while (size >= 8) {
1883                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI8_MEMBASE_REG, destreg, offset, val_reg);
1884                         offset += 8;
1885                         size -= 8;
1886                 }
1887         }
1888
1889         while (size >= 4) {
1890                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
1891                 offset += 4;
1892                 size -= 4;
1893         }
1894         while (size >= 2) {
1895                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, destreg, offset, val_reg);
1896                 offset += 2;
1897                 size -= 2;
1898         }
1899         while (size >= 1) {
1900                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
1901                 offset += 1;
1902                 size -= 1;
1903         }
1904 }
1905
1906 void
1907 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1908 {
1909         int cur_reg;
1910
1911         if (align == 0)
1912                 align = 4;
1913
1914         /*FIXME arbitrary hack to avoid unbound code expansion.*/
1915         g_assert (size < 10000);
1916
1917         if (align < 4) {
1918                 /* This could be optimized further if neccesary */
1919                 while (size >= 1) {
1920                         cur_reg = alloc_preg (cfg);
1921                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
1922                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
1923                         doffset += 1;
1924                         soffset += 1;
1925                         size -= 1;
1926                 }
1927         }
1928
1929         if (!cfg->backend->no_unaligned_access && SIZEOF_REGISTER == 8) {
1930                 while (size >= 8) {
1931                         cur_reg = alloc_preg (cfg);
1932                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI8_MEMBASE, cur_reg, srcreg, soffset);
1933                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI8_MEMBASE_REG, destreg, doffset, cur_reg);
1934                         doffset += 8;
1935                         soffset += 8;
1936                         size -= 8;
1937                 }
1938         }
1939
1940         while (size >= 4) {
1941                 cur_reg = alloc_preg (cfg);
1942                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, cur_reg, srcreg, soffset);
1943                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, doffset, cur_reg);
1944                 doffset += 4;
1945                 soffset += 4;
1946                 size -= 4;
1947         }
1948         while (size >= 2) {
1949                 cur_reg = alloc_preg (cfg);
1950                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI2_MEMBASE, cur_reg, srcreg, soffset);
1951                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, destreg, doffset, cur_reg);
1952                 doffset += 2;
1953                 soffset += 2;
1954                 size -= 2;
1955         }
1956         while (size >= 1) {
1957                 cur_reg = alloc_preg (cfg);
1958                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
1959                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
1960                 doffset += 1;
1961                 soffset += 1;
1962                 size -= 1;
1963         }
1964 }
1965
1966 static void
1967 emit_tls_set (MonoCompile *cfg, int sreg1, MonoTlsKey tls_key)
1968 {
1969         MonoInst *ins, *c;
1970
1971         if (cfg->compile_aot) {
1972                 EMIT_NEW_TLS_OFFSETCONST (cfg, c, tls_key);
1973                 MONO_INST_NEW (cfg, ins, OP_TLS_SET_REG);
1974                 ins->sreg1 = sreg1;
1975                 ins->sreg2 = c->dreg;
1976                 MONO_ADD_INS (cfg->cbb, ins);
1977         } else {
1978                 MONO_INST_NEW (cfg, ins, OP_TLS_SET);
1979                 ins->sreg1 = sreg1;
1980                 ins->inst_offset = mini_get_tls_offset (tls_key);
1981                 MONO_ADD_INS (cfg->cbb, ins);
1982         }
1983 }
1984
1985 /*
1986  * emit_push_lmf:
1987  *
1988  *   Emit IR to push the current LMF onto the LMF stack.
1989  */
1990 static void
1991 emit_push_lmf (MonoCompile *cfg)
1992 {
1993         /*
1994          * Emit IR to push the LMF:
1995          * lmf_addr = <lmf_addr from tls>
1996          * lmf->lmf_addr = lmf_addr
1997          * lmf->prev_lmf = *lmf_addr
1998          * *lmf_addr = lmf
1999          */
2000         int lmf_reg, prev_lmf_reg;
2001         MonoInst *ins, *lmf_ins;
2002
2003         if (!cfg->lmf_ir)
2004                 return;
2005
2006         if (cfg->lmf_ir_mono_lmf && mini_tls_get_supported (cfg, TLS_KEY_LMF)) {
2007                 /* Load current lmf */
2008                 lmf_ins = mono_get_lmf_intrinsic (cfg);
2009                 g_assert (lmf_ins);
2010                 MONO_ADD_INS (cfg->cbb, lmf_ins);
2011                 EMIT_NEW_VARLOADA (cfg, ins, cfg->lmf_var, NULL);
2012                 lmf_reg = ins->dreg;
2013                 /* Save previous_lmf */
2014                 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), lmf_ins->dreg);
2015                 /* Set new LMF */
2016                 emit_tls_set (cfg, lmf_reg, TLS_KEY_LMF);
2017         } else {
2018                 /*
2019                  * Store lmf_addr in a variable, so it can be allocated to a global register.
2020                  */
2021                 if (!cfg->lmf_addr_var)
2022                         cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2023
2024 #ifdef HOST_WIN32
2025                 ins = mono_get_jit_tls_intrinsic (cfg);
2026                 if (ins) {
2027                         int jit_tls_dreg = ins->dreg;
2028
2029                         MONO_ADD_INS (cfg->cbb, ins);
2030                         lmf_reg = alloc_preg (cfg);
2031                         EMIT_NEW_BIALU_IMM (cfg, lmf_ins, OP_PADD_IMM, lmf_reg, jit_tls_dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2032                 } else {
2033                         lmf_ins = mono_emit_jit_icall (cfg, mono_get_lmf_addr, NULL);
2034                 }
2035 #else
2036                 lmf_ins = mono_get_lmf_addr_intrinsic (cfg);
2037                 if (lmf_ins) {
2038                         MONO_ADD_INS (cfg->cbb, lmf_ins);
2039                 } else {
2040 #ifdef TARGET_IOS
2041                         MonoInst *args [16], *jit_tls_ins, *ins;
2042
2043                         /* Inline mono_get_lmf_addr () */
2044                         /* jit_tls = pthread_getspecific (mono_jit_tls_id); lmf_addr = &jit_tls->lmf; */
2045
2046                         /* Load mono_jit_tls_id */
2047                         if (cfg->compile_aot)
2048                                 EMIT_NEW_AOTCONST (cfg, args [0], MONO_PATCH_INFO_JIT_TLS_ID, NULL);
2049                         else
2050                                 EMIT_NEW_ICONST (cfg, args [0], mono_jit_tls_id);
2051                         /* call pthread_getspecific () */
2052                         jit_tls_ins = mono_emit_jit_icall (cfg, pthread_getspecific, args);
2053                         /* lmf_addr = &jit_tls->lmf */
2054                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, cfg->lmf_addr_var->dreg, jit_tls_ins->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, lmf));
2055                         lmf_ins = ins;
2056 #else
2057                         lmf_ins = mono_emit_jit_icall (cfg, mono_get_lmf_addr, NULL);
2058 #endif
2059                 }
2060 #endif
2061                 lmf_ins->dreg = cfg->lmf_addr_var->dreg;
2062
2063                 EMIT_NEW_VARLOADA (cfg, ins, cfg->lmf_var, NULL);
2064                 lmf_reg = ins->dreg;
2065
2066                 prev_lmf_reg = alloc_preg (cfg);
2067                 /* Save previous_lmf */
2068                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, cfg->lmf_addr_var->dreg, 0);
2069                 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), prev_lmf_reg);
2070                 /* Set new lmf */
2071                 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, cfg->lmf_addr_var->dreg, 0, lmf_reg);
2072         }
2073 }
2074
2075 /*
2076  * emit_pop_lmf:
2077  *
2078  *   Emit IR to pop the current LMF from the LMF stack.
2079  */
2080 static void
2081 emit_pop_lmf (MonoCompile *cfg)
2082 {
2083         int lmf_reg, lmf_addr_reg, prev_lmf_reg;
2084         MonoInst *ins;
2085
2086         if (!cfg->lmf_ir)
2087                 return;
2088
2089         EMIT_NEW_VARLOADA (cfg, ins, cfg->lmf_var, NULL);
2090         lmf_reg = ins->dreg;
2091
2092         if (cfg->lmf_ir_mono_lmf && mini_tls_get_supported (cfg, TLS_KEY_LMF)) {
2093                 /* Load previous_lmf */
2094                 prev_lmf_reg = alloc_preg (cfg);
2095                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2096                 /* Set new LMF */
2097                 emit_tls_set (cfg, prev_lmf_reg, TLS_KEY_LMF);
2098         } else {
2099                 /*
2100                  * Emit IR to pop the LMF:
2101                  * *(lmf->lmf_addr) = lmf->prev_lmf
2102                  */
2103                 /* This could be called before emit_push_lmf () */
2104                 if (!cfg->lmf_addr_var)
2105                         cfg->lmf_addr_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2106                 lmf_addr_reg = cfg->lmf_addr_var->dreg;
2107
2108                 prev_lmf_reg = alloc_preg (cfg);
2109                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, MONO_STRUCT_OFFSET (MonoLMF, previous_lmf));
2110                 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, lmf_addr_reg, 0, prev_lmf_reg);
2111         }
2112 }
2113
2114 static void
2115 emit_instrumentation_call (MonoCompile *cfg, void *func)
2116 {
2117         MonoInst *iargs [1];
2118
2119         /*
2120          * Avoid instrumenting inlined methods since it can
2121          * distort profiling results.
2122          */
2123         if (cfg->method != cfg->current_method)
2124                 return;
2125
2126         if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE) {
2127                 EMIT_NEW_METHODCONST (cfg, iargs [0], cfg->method);
2128                 mono_emit_jit_icall (cfg, func, iargs);
2129         }
2130 }
2131
2132 static int
2133 ret_type_to_call_opcode (MonoCompile *cfg, MonoType *type, int calli, int virt)
2134 {
2135 handle_enum:
2136         type = mini_get_underlying_type (type);
2137         switch (type->type) {
2138         case MONO_TYPE_VOID:
2139                 return calli? OP_VOIDCALL_REG: virt? OP_VOIDCALL_MEMBASE: OP_VOIDCALL;
2140         case MONO_TYPE_I1:
2141         case MONO_TYPE_U1:
2142         case MONO_TYPE_I2:
2143         case MONO_TYPE_U2:
2144         case MONO_TYPE_I4:
2145         case MONO_TYPE_U4:
2146                 return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
2147         case MONO_TYPE_I:
2148         case MONO_TYPE_U:
2149         case MONO_TYPE_PTR:
2150         case MONO_TYPE_FNPTR:
2151                 return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
2152         case MONO_TYPE_CLASS:
2153         case MONO_TYPE_STRING:
2154         case MONO_TYPE_OBJECT:
2155         case MONO_TYPE_SZARRAY:
2156         case MONO_TYPE_ARRAY:
2157                 return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
2158         case MONO_TYPE_I8:
2159         case MONO_TYPE_U8:
2160                 return calli? OP_LCALL_REG: virt? OP_LCALL_MEMBASE: OP_LCALL;
2161         case MONO_TYPE_R4:
2162                 if (cfg->r4fp)
2163                         return calli? OP_RCALL_REG: virt? OP_RCALL_MEMBASE: OP_RCALL;
2164                 else
2165                         return calli? OP_FCALL_REG: virt? OP_FCALL_MEMBASE: OP_FCALL;
2166         case MONO_TYPE_R8:
2167                 return calli? OP_FCALL_REG: virt? OP_FCALL_MEMBASE: OP_FCALL;
2168         case MONO_TYPE_VALUETYPE:
2169                 if (type->data.klass->enumtype) {
2170                         type = mono_class_enum_basetype (type->data.klass);
2171                         goto handle_enum;
2172                 } else
2173                         return calli? OP_VCALL_REG: virt? OP_VCALL_MEMBASE: OP_VCALL;
2174         case MONO_TYPE_TYPEDBYREF:
2175                 return calli? OP_VCALL_REG: virt? OP_VCALL_MEMBASE: OP_VCALL;
2176         case MONO_TYPE_GENERICINST:
2177                 type = &type->data.generic_class->container_class->byval_arg;
2178                 goto handle_enum;
2179         case MONO_TYPE_VAR:
2180         case MONO_TYPE_MVAR:
2181                 /* gsharedvt */
2182                 return calli? OP_VCALL_REG: virt? OP_VCALL_MEMBASE: OP_VCALL;
2183         default:
2184                 g_error ("unknown type 0x%02x in ret_type_to_call_opcode", type->type);
2185         }
2186         return -1;
2187 }
2188
2189 /*
2190  * target_type_is_incompatible:
2191  * @cfg: MonoCompile context
2192  *
2193  * Check that the item @arg on the evaluation stack can be stored
2194  * in the target type (can be a local, or field, etc).
2195  * The cfg arg can be used to check if we need verification or just
2196  * validity checks.
2197  *
2198  * Returns: non-0 value if arg can't be stored on a target.
2199  */
2200 static int
2201 target_type_is_incompatible (MonoCompile *cfg, MonoType *target, MonoInst *arg)
2202 {
2203         MonoType *simple_type;
2204         MonoClass *klass;
2205
2206         if (target->byref) {
2207                 /* FIXME: check that the pointed to types match */
2208                 if (arg->type == STACK_MP) {
2209                         MonoClass *base_class = mono_class_from_mono_type (target);
2210                         /* This is needed to handle gshared types + ldaddr */
2211                         simple_type = mini_get_underlying_type (&base_class->byval_arg);
2212                         return target->type != MONO_TYPE_I && arg->klass != base_class && arg->klass != mono_class_from_mono_type (simple_type);
2213                 }
2214                 if (arg->type == STACK_PTR)
2215                         return 0;
2216                 return 1;
2217         }
2218
2219         simple_type = mini_get_underlying_type (target);
2220         switch (simple_type->type) {
2221         case MONO_TYPE_VOID:
2222                 return 1;
2223         case MONO_TYPE_I1:
2224         case MONO_TYPE_U1:
2225         case MONO_TYPE_I2:
2226         case MONO_TYPE_U2:
2227         case MONO_TYPE_I4:
2228         case MONO_TYPE_U4:
2229                 if (arg->type != STACK_I4 && arg->type != STACK_PTR)
2230                         return 1;
2231                 return 0;
2232         case MONO_TYPE_PTR:
2233                 /* STACK_MP is needed when setting pinned locals */
2234                 if (arg->type != STACK_I4 && arg->type != STACK_PTR && arg->type != STACK_MP)
2235                         return 1;
2236                 return 0;
2237         case MONO_TYPE_I:
2238         case MONO_TYPE_U:
2239         case MONO_TYPE_FNPTR:
2240                 /*
2241                  * Some opcodes like ldloca returns 'transient pointers' which can be stored in
2242                  * in native int. (#688008).
2243                  */
2244                 if (arg->type != STACK_I4 && arg->type != STACK_PTR && arg->type != STACK_MP)
2245                         return 1;
2246                 return 0;
2247         case MONO_TYPE_CLASS:
2248         case MONO_TYPE_STRING:
2249         case MONO_TYPE_OBJECT:
2250         case MONO_TYPE_SZARRAY:
2251         case MONO_TYPE_ARRAY:
2252                 if (arg->type != STACK_OBJ)
2253                         return 1;
2254                 /* FIXME: check type compatibility */
2255                 return 0;
2256         case MONO_TYPE_I8:
2257         case MONO_TYPE_U8:
2258                 if (arg->type != STACK_I8)
2259                         return 1;
2260                 return 0;
2261         case MONO_TYPE_R4:
2262                 if (arg->type != cfg->r4_stack_type)
2263                         return 1;
2264                 return 0;
2265         case MONO_TYPE_R8:
2266                 if (arg->type != STACK_R8)
2267                         return 1;
2268                 return 0;
2269         case MONO_TYPE_VALUETYPE:
2270                 if (arg->type != STACK_VTYPE)
2271                         return 1;
2272                 klass = mono_class_from_mono_type (simple_type);
2273                 if (klass != arg->klass)
2274                         return 1;
2275                 return 0;
2276         case MONO_TYPE_TYPEDBYREF:
2277                 if (arg->type != STACK_VTYPE)
2278                         return 1;
2279                 klass = mono_class_from_mono_type (simple_type);
2280                 if (klass != arg->klass)
2281                         return 1;
2282                 return 0;
2283         case MONO_TYPE_GENERICINST:
2284                 if (mono_type_generic_inst_is_valuetype (simple_type)) {
2285                         MonoClass *target_class;
2286                         if (arg->type != STACK_VTYPE)
2287                                 return 1;
2288                         klass = mono_class_from_mono_type (simple_type);
2289                         target_class = mono_class_from_mono_type (target);
2290                         /* The second cases is needed when doing partial sharing */
2291                         if (klass != arg->klass && target_class != arg->klass && target_class != mono_class_from_mono_type (mini_get_underlying_type (&arg->klass->byval_arg)))
2292                                 return 1;
2293                         return 0;
2294                 } else {
2295                         if (arg->type != STACK_OBJ)
2296                                 return 1;
2297                         /* FIXME: check type compatibility */
2298                         return 0;
2299                 }
2300         case MONO_TYPE_VAR:
2301         case MONO_TYPE_MVAR:
2302                 g_assert (cfg->gshared);
2303                 if (mini_type_var_is_vt (simple_type)) {
2304                         if (arg->type != STACK_VTYPE)
2305                                 return 1;
2306                 } else {
2307                         if (arg->type != STACK_OBJ)
2308                                 return 1;
2309                 }
2310                 return 0;
2311         default:
2312                 g_error ("unknown type 0x%02x in target_type_is_incompatible", simple_type->type);
2313         }
2314         return 1;
2315 }
2316
2317 /*
2318  * Prepare arguments for passing to a function call.
2319  * Return a non-zero value if the arguments can't be passed to the given
2320  * signature.
2321  * The type checks are not yet complete and some conversions may need
2322  * casts on 32 or 64 bit architectures.
2323  *
2324  * FIXME: implement this using target_type_is_incompatible ()
2325  */
2326 static int
2327 check_call_signature (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args)
2328 {
2329         MonoType *simple_type;
2330         int i;
2331
2332         if (sig->hasthis) {
2333                 if (args [0]->type != STACK_OBJ && args [0]->type != STACK_MP && args [0]->type != STACK_PTR)
2334                         return 1;
2335                 args++;
2336         }
2337         for (i = 0; i < sig->param_count; ++i) {
2338                 if (sig->params [i]->byref) {
2339                         if (args [i]->type != STACK_MP && args [i]->type != STACK_PTR)
2340                                 return 1;
2341                         continue;
2342                 }
2343                 simple_type = mini_get_underlying_type (sig->params [i]);
2344 handle_enum:
2345                 switch (simple_type->type) {
2346                 case MONO_TYPE_VOID:
2347                         return 1;
2348                         continue;
2349                 case MONO_TYPE_I1:
2350                 case MONO_TYPE_U1:
2351                 case MONO_TYPE_I2:
2352                 case MONO_TYPE_U2:
2353                 case MONO_TYPE_I4:
2354                 case MONO_TYPE_U4:
2355                         if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR)
2356                                 return 1;
2357                         continue;
2358                 case MONO_TYPE_I:
2359                 case MONO_TYPE_U:
2360                 case MONO_TYPE_PTR:
2361                 case MONO_TYPE_FNPTR:
2362                         if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
2363                                 return 1;
2364                         continue;
2365                 case MONO_TYPE_CLASS:
2366                 case MONO_TYPE_STRING:
2367                 case MONO_TYPE_OBJECT:
2368                 case MONO_TYPE_SZARRAY:
2369                 case MONO_TYPE_ARRAY:
2370                         if (args [i]->type != STACK_OBJ)
2371                                 return 1;
2372                         continue;
2373                 case MONO_TYPE_I8:
2374                 case MONO_TYPE_U8:
2375                         if (args [i]->type != STACK_I8)
2376                                 return 1;
2377                         continue;
2378                 case MONO_TYPE_R4:
2379                         if (args [i]->type != cfg->r4_stack_type)
2380                                 return 1;
2381                         continue;
2382                 case MONO_TYPE_R8:
2383                         if (args [i]->type != STACK_R8)
2384                                 return 1;
2385                         continue;
2386                 case MONO_TYPE_VALUETYPE:
2387                         if (simple_type->data.klass->enumtype) {
2388                                 simple_type = mono_class_enum_basetype (simple_type->data.klass);
2389                                 goto handle_enum;
2390                         }
2391                         if (args [i]->type != STACK_VTYPE)
2392                                 return 1;
2393                         continue;
2394                 case MONO_TYPE_TYPEDBYREF:
2395                         if (args [i]->type != STACK_VTYPE)
2396                                 return 1;
2397                         continue;
2398                 case MONO_TYPE_GENERICINST:
2399                         simple_type = &simple_type->data.generic_class->container_class->byval_arg;
2400                         goto handle_enum;
2401                 case MONO_TYPE_VAR:
2402                 case MONO_TYPE_MVAR:
2403                         /* gsharedvt */
2404                         if (args [i]->type != STACK_VTYPE)
2405                                 return 1;
2406                         continue;
2407                 default:
2408                         g_error ("unknown type 0x%02x in check_call_signature",
2409                                  simple_type->type);
2410                 }
2411         }
2412         return 0;
2413 }
2414
2415 static int
2416 callvirt_to_call (int opcode)
2417 {
2418         switch (opcode) {
2419         case OP_CALL_MEMBASE:
2420                 return OP_CALL;
2421         case OP_VOIDCALL_MEMBASE:
2422                 return OP_VOIDCALL;
2423         case OP_FCALL_MEMBASE:
2424                 return OP_FCALL;
2425         case OP_RCALL_MEMBASE:
2426                 return OP_RCALL;
2427         case OP_VCALL_MEMBASE:
2428                 return OP_VCALL;
2429         case OP_LCALL_MEMBASE:
2430                 return OP_LCALL;
2431         default:
2432                 g_assert_not_reached ();
2433         }
2434
2435         return -1;
2436 }
2437
2438 static int
2439 callvirt_to_call_reg (int opcode)
2440 {
2441         switch (opcode) {
2442         case OP_CALL_MEMBASE:
2443                 return OP_CALL_REG;
2444         case OP_VOIDCALL_MEMBASE:
2445                 return OP_VOIDCALL_REG;
2446         case OP_FCALL_MEMBASE:
2447                 return OP_FCALL_REG;
2448         case OP_RCALL_MEMBASE:
2449                 return OP_RCALL_REG;
2450         case OP_VCALL_MEMBASE:
2451                 return OP_VCALL_REG;
2452         case OP_LCALL_MEMBASE:
2453                 return OP_LCALL_REG;
2454         default:
2455                 g_assert_not_reached ();
2456         }
2457
2458         return -1;
2459 }
2460
2461 /* Either METHOD or IMT_ARG needs to be set */
2462 static void
2463 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoMethod *method, MonoInst *imt_arg)
2464 {
2465         int method_reg;
2466
2467         if (COMPILE_LLVM (cfg)) {
2468                 if (imt_arg) {
2469                         method_reg = alloc_preg (cfg);
2470                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, method_reg, imt_arg->dreg);
2471                 } else {
2472                         MonoInst *ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_METHODCONST, method);
2473                         method_reg = ins->dreg;
2474                 }
2475
2476 #ifdef ENABLE_LLVM
2477                 call->imt_arg_reg = method_reg;
2478 #endif
2479                 mono_call_inst_add_outarg_reg (cfg, call, method_reg, MONO_ARCH_IMT_REG, FALSE);
2480                 return;
2481         }
2482
2483         if (imt_arg) {
2484                 method_reg = alloc_preg (cfg);
2485                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, method_reg, imt_arg->dreg);
2486         } else {
2487                 MonoInst *ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_METHODCONST, method);
2488                 method_reg = ins->dreg;
2489         }
2490
2491         mono_call_inst_add_outarg_reg (cfg, call, method_reg, MONO_ARCH_IMT_REG, FALSE);
2492 }
2493
2494 static MonoJumpInfo *
2495 mono_patch_info_new (MonoMemPool *mp, int ip, MonoJumpInfoType type, gconstpointer target)
2496 {
2497         MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
2498
2499         ji->ip.i = ip;
2500         ji->type = type;
2501         ji->data.target = target;
2502
2503         return ji;
2504 }
2505
2506 static int
2507 mini_class_check_context_used (MonoCompile *cfg, MonoClass *klass)
2508 {
2509         if (cfg->gshared)
2510                 return mono_class_check_context_used (klass);
2511         else
2512                 return 0;
2513 }
2514
2515 static int
2516 mini_method_check_context_used (MonoCompile *cfg, MonoMethod *method)
2517 {
2518         if (cfg->gshared)
2519                 return mono_method_check_context_used (method);
2520         else
2521                 return 0;
2522 }
2523
2524 /*
2525  * check_method_sharing:
2526  *
2527  *   Check whenever the vtable or an mrgctx needs to be passed when calling CMETHOD.
2528  */
2529 static void
2530 check_method_sharing (MonoCompile *cfg, MonoMethod *cmethod, gboolean *out_pass_vtable, gboolean *out_pass_mrgctx)
2531 {
2532         gboolean pass_vtable = FALSE;
2533         gboolean pass_mrgctx = FALSE;
2534
2535         if (((cmethod->flags & METHOD_ATTRIBUTE_STATIC) || cmethod->klass->valuetype) &&
2536                 (cmethod->klass->generic_class || cmethod->klass->generic_container)) {
2537                 gboolean sharable = FALSE;
2538
2539                 if (mono_method_is_generic_sharable_full (cmethod, TRUE, TRUE, TRUE))
2540                         sharable = TRUE;
2541
2542                 /*
2543                  * Pass vtable iff target method might
2544                  * be shared, which means that sharing
2545                  * is enabled for its class and its
2546                  * context is sharable (and it's not a
2547                  * generic method).
2548                  */
2549                 if (sharable && !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
2550                         pass_vtable = TRUE;
2551         }
2552
2553         if (mini_method_get_context (cmethod) &&
2554                 mini_method_get_context (cmethod)->method_inst) {
2555                 g_assert (!pass_vtable);
2556
2557                 if (mono_method_is_generic_sharable_full (cmethod, TRUE, TRUE, TRUE)) {
2558                         pass_mrgctx = TRUE;
2559                 } else {
2560                         if (cfg->gsharedvt && mini_is_gsharedvt_signature (mono_method_signature (cmethod)))
2561                                 pass_mrgctx = TRUE;
2562                 }
2563         }
2564
2565         if (out_pass_vtable)
2566                 *out_pass_vtable = pass_vtable;
2567         if (out_pass_mrgctx)
2568                 *out_pass_mrgctx = pass_mrgctx;
2569 }
2570
2571 inline static MonoCallInst *
2572 mono_emit_call_args (MonoCompile *cfg, MonoMethodSignature *sig,
2573                                          MonoInst **args, int calli, int virtual_, int tail, int rgctx, int unbox_trampoline)
2574 {
2575         MonoType *sig_ret;
2576         MonoCallInst *call;
2577 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2578         int i;
2579 #endif
2580
2581         if (cfg->llvm_only)
2582                 tail = FALSE;
2583
2584         if (tail) {
2585                 emit_instrumentation_call (cfg, mono_profiler_method_leave);
2586
2587                 MONO_INST_NEW_CALL (cfg, call, OP_TAILCALL);
2588         } else
2589                 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (cfg, sig->ret, calli, virtual_));
2590
2591         call->args = args;
2592         call->signature = sig;
2593         call->rgctx_reg = rgctx;
2594         sig_ret = mini_get_underlying_type (sig->ret);
2595
2596         type_to_eval_stack_type ((cfg), sig_ret, &call->inst);
2597
2598         if (tail) {
2599                 if (mini_type_is_vtype (sig_ret)) {
2600                         call->vret_var = cfg->vret_addr;
2601                         //g_assert_not_reached ();
2602                 }
2603         } else if (mini_type_is_vtype (sig_ret)) {
2604                 MonoInst *temp = mono_compile_create_var (cfg, sig_ret, OP_LOCAL);
2605                 MonoInst *loada;
2606
2607                 temp->backend.is_pinvoke = sig->pinvoke;
2608
2609                 /*
2610                  * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2611                  * address of return value to increase optimization opportunities.
2612                  * Before vtype decomposition, the dreg of the call ins itself represents the
2613                  * fact the call modifies the return value. After decomposition, the call will
2614                  * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2615                  * will be transformed into an LDADDR.
2616                  */
2617                 MONO_INST_NEW (cfg, loada, OP_OUTARG_VTRETADDR);
2618                 loada->dreg = alloc_preg (cfg);
2619                 loada->inst_p0 = temp;
2620                 /* We reference the call too since call->dreg could change during optimization */
2621                 loada->inst_p1 = call;
2622                 MONO_ADD_INS (cfg->cbb, loada);
2623
2624                 call->inst.dreg = temp->dreg;
2625
2626                 call->vret_var = loada;
2627         } else if (!MONO_TYPE_IS_VOID (sig_ret))
2628                 call->inst.dreg = alloc_dreg (cfg, (MonoStackType)call->inst.type);
2629
2630 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
2631         if (COMPILE_SOFT_FLOAT (cfg)) {
2632                 /*
2633                  * If the call has a float argument, we would need to do an r8->r4 conversion using
2634                  * an icall, but that cannot be done during the call sequence since it would clobber
2635                  * the call registers + the stack. So we do it before emitting the call.
2636                  */
2637                 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
2638                         MonoType *t;
2639                         MonoInst *in = call->args [i];
2640
2641                         if (i >= sig->hasthis)
2642                                 t = sig->params [i - sig->hasthis];
2643                         else
2644                                 t = &mono_defaults.int_class->byval_arg;
2645                         t = mono_type_get_underlying_type (t);
2646
2647                         if (!t->byref && t->type == MONO_TYPE_R4) {
2648                                 MonoInst *iargs [1];
2649                                 MonoInst *conv;
2650
2651                                 iargs [0] = in;
2652                                 conv = mono_emit_jit_icall (cfg, mono_fload_r4_arg, iargs);
2653
2654                                 /* The result will be in an int vreg */
2655                                 call->args [i] = conv;
2656                         }
2657                 }
2658         }
2659 #endif
2660
2661         call->need_unbox_trampoline = unbox_trampoline;
2662
2663 #ifdef ENABLE_LLVM
2664         if (COMPILE_LLVM (cfg))
2665                 mono_llvm_emit_call (cfg, call);
2666         else
2667                 mono_arch_emit_call (cfg, call);
2668 #else
2669         mono_arch_emit_call (cfg, call);
2670 #endif
2671
2672         cfg->param_area = MAX (cfg->param_area, call->stack_usage);
2673         cfg->flags |= MONO_CFG_HAS_CALLS;
2674
2675         return call;
2676 }
2677
2678 static void
2679 set_rgctx_arg (MonoCompile *cfg, MonoCallInst *call, int rgctx_reg, MonoInst *rgctx_arg)
2680 {
2681         mono_call_inst_add_outarg_reg (cfg, call, rgctx_reg, MONO_ARCH_RGCTX_REG, FALSE);
2682         cfg->uses_rgctx_reg = TRUE;
2683         call->rgctx_reg = TRUE;
2684 #ifdef ENABLE_LLVM
2685         call->rgctx_arg_reg = rgctx_reg;
2686 #endif
2687 }
2688
2689 inline static MonoInst*
2690 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *imt_arg, MonoInst *rgctx_arg)
2691 {
2692         MonoCallInst *call;
2693         MonoInst *ins;
2694         int rgctx_reg = -1;
2695         gboolean check_sp = FALSE;
2696
2697         if (cfg->check_pinvoke_callconv && cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
2698                 WrapperInfo *info = mono_marshal_get_wrapper_info (cfg->method);
2699
2700                 if (info && info->subtype == WRAPPER_SUBTYPE_PINVOKE)
2701                         check_sp = TRUE;
2702         }
2703
2704         if (rgctx_arg) {
2705                 rgctx_reg = mono_alloc_preg (cfg);
2706                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, rgctx_reg, rgctx_arg->dreg);
2707         }
2708
2709         if (check_sp) {
2710                 if (!cfg->stack_inbalance_var)
2711                         cfg->stack_inbalance_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
2712
2713                 MONO_INST_NEW (cfg, ins, OP_GET_SP);
2714                 ins->dreg = cfg->stack_inbalance_var->dreg;
2715                 MONO_ADD_INS (cfg->cbb, ins);
2716         }
2717
2718         call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE, rgctx_arg ? TRUE : FALSE, FALSE);
2719
2720         call->inst.sreg1 = addr->dreg;
2721
2722         if (imt_arg)
2723                 emit_imt_argument (cfg, call, NULL, imt_arg);
2724
2725         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2726
2727         if (check_sp) {
2728                 int sp_reg;
2729
2730                 sp_reg = mono_alloc_preg (cfg);
2731
2732                 MONO_INST_NEW (cfg, ins, OP_GET_SP);
2733                 ins->dreg = sp_reg;
2734                 MONO_ADD_INS (cfg->cbb, ins);
2735
2736                 /* Restore the stack so we don't crash when throwing the exception */
2737                 MONO_INST_NEW (cfg, ins, OP_SET_SP);
2738                 ins->sreg1 = cfg->stack_inbalance_var->dreg;
2739                 MONO_ADD_INS (cfg->cbb, ins);
2740
2741                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, cfg->stack_inbalance_var->dreg, sp_reg);
2742                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "ExecutionEngineException");
2743         }
2744
2745         if (rgctx_arg)
2746                 set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
2747
2748         return (MonoInst*)call;
2749 }
2750
2751 static MonoInst*
2752 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2753
2754 static MonoInst*
2755 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type);
2756 static MonoInst*
2757 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, MonoRgctxInfoType rgctx_type);
2758
2759 static MonoInst*
2760 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig, gboolean tail,
2761                                                         MonoInst **args, MonoInst *this_ins, MonoInst *imt_arg, MonoInst *rgctx_arg)
2762 {
2763 #ifndef DISABLE_REMOTING
2764         gboolean might_be_remote = FALSE;
2765 #endif
2766         gboolean virtual_ = this_ins != NULL;
2767         gboolean enable_for_aot = TRUE;
2768         int context_used;
2769         MonoCallInst *call;
2770         MonoInst *call_target = NULL;
2771         int rgctx_reg = 0;
2772         gboolean need_unbox_trampoline;
2773
2774         if (!sig)
2775                 sig = mono_method_signature (method);
2776
2777         if (cfg->llvm_only && (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE))
2778                 g_assert_not_reached ();
2779
2780         if (rgctx_arg) {
2781                 rgctx_reg = mono_alloc_preg (cfg);
2782                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, rgctx_reg, rgctx_arg->dreg);
2783         }
2784
2785         if (method->string_ctor) {
2786                 /* Create the real signature */
2787                 /* FIXME: Cache these */
2788                 MonoMethodSignature *ctor_sig = mono_metadata_signature_dup_mempool (cfg->mempool, sig);
2789                 ctor_sig->ret = &mono_defaults.string_class->byval_arg;
2790
2791                 sig = ctor_sig;
2792         }
2793
2794         context_used = mini_method_check_context_used (cfg, method);
2795
2796 #ifndef DISABLE_REMOTING
2797         might_be_remote = this_ins && sig->hasthis &&
2798                 (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) &&
2799                 !(method->flags & METHOD_ATTRIBUTE_VIRTUAL) && (!MONO_CHECK_THIS (this_ins) || context_used);
2800
2801         if (might_be_remote && context_used) {
2802                 MonoInst *addr;
2803
2804                 g_assert (cfg->gshared);
2805
2806                 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2807
2808                 return mono_emit_calli (cfg, sig, args, addr, NULL, NULL);
2809         }
2810 #endif
2811
2812         if (cfg->llvm_only && !call_target && virtual_ && (method->flags & METHOD_ATTRIBUTE_VIRTUAL))
2813                 return emit_llvmonly_virtual_call (cfg, method, sig, 0, args);
2814
2815         need_unbox_trampoline = method->klass == mono_defaults.object_class || (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
2816
2817         call = mono_emit_call_args (cfg, sig, args, FALSE, virtual_, tail, rgctx_arg ? TRUE : FALSE, need_unbox_trampoline);
2818
2819 #ifndef DISABLE_REMOTING
2820         if (might_be_remote)
2821                 call->method = mono_marshal_get_remoting_invoke_with_check (method);
2822         else
2823 #endif
2824                 call->method = method;
2825         call->inst.flags |= MONO_INST_HAS_METHOD;
2826         call->inst.inst_left = this_ins;
2827         call->tail_call = tail;
2828
2829         if (virtual_) {
2830                 int vtable_reg, slot_reg, this_reg;
2831                 int offset;
2832
2833                 this_reg = this_ins->dreg;
2834
2835                 if (!cfg->llvm_only && (method->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (method->name, "Invoke")) {
2836                         MonoInst *dummy_use;
2837
2838                         MONO_EMIT_NULL_CHECK (cfg, this_reg);
2839
2840                         /* Make a call to delegate->invoke_impl */
2841                         call->inst.inst_basereg = this_reg;
2842                         call->inst.inst_offset = MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl);
2843                         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2844
2845                         /* We must emit a dummy use here because the delegate trampoline will
2846                         replace the 'this' argument with the delegate target making this activation
2847                         no longer a root for the delegate.
2848                         This is an issue for delegates that target collectible code such as dynamic
2849                         methods of GC'able assemblies.
2850
2851                         For a test case look into #667921.
2852
2853                         FIXME: a dummy use is not the best way to do it as the local register allocator
2854                         will put it on a caller save register and spil it around the call.
2855                         Ideally, we would either put it on a callee save register or only do the store part.
2856                          */
2857                         EMIT_NEW_DUMMY_USE (cfg, dummy_use, args [0]);
2858
2859                         return (MonoInst*)call;
2860                 }
2861
2862                 if ((!cfg->compile_aot || enable_for_aot) &&
2863                         (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
2864                          (MONO_METHOD_IS_FINAL (method) &&
2865                           method->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)) &&
2866                         !(mono_class_is_marshalbyref (method->klass) && context_used)) {
2867                         /*
2868                          * the method is not virtual, we just need to ensure this is not null
2869                          * and then we can call the method directly.
2870                          */
2871 #ifndef DISABLE_REMOTING
2872                         if (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class) {
2873                                 /*
2874                                  * The check above ensures method is not gshared, this is needed since
2875                                  * gshared methods can't have wrappers.
2876                                  */
2877                                 method = call->method = mono_marshal_get_remoting_invoke_with_check (method);
2878                         }
2879 #endif
2880
2881                         if (!method->string_ctor)
2882                                 MONO_EMIT_NEW_CHECK_THIS (cfg, this_reg);
2883
2884                         call->inst.opcode = callvirt_to_call (call->inst.opcode);
2885                 } else if ((method->flags & METHOD_ATTRIBUTE_VIRTUAL) && MONO_METHOD_IS_FINAL (method)) {
2886                         /*
2887                          * the method is virtual, but we can statically dispatch since either
2888                          * it's class or the method itself are sealed.
2889                          * But first we need to ensure it's not a null reference.
2890                          */
2891                         MONO_EMIT_NEW_CHECK_THIS (cfg, this_reg);
2892
2893                         call->inst.opcode = callvirt_to_call (call->inst.opcode);
2894                 } else if (call_target) {
2895                         vtable_reg = alloc_preg (cfg);
2896                         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2897
2898                         call->inst.opcode = callvirt_to_call_reg (call->inst.opcode);
2899                         call->inst.sreg1 = call_target->dreg;
2900                         call->inst.flags &= !MONO_INST_HAS_METHOD;
2901                 } else {
2902                         vtable_reg = alloc_preg (cfg);
2903                         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
2904                         if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
2905                                 guint32 imt_slot = mono_method_get_imt_slot (method);
2906                                 emit_imt_argument (cfg, call, call->method, imt_arg);
2907                                 slot_reg = vtable_reg;
2908                                 offset = ((gint32)imt_slot - MONO_IMT_SIZE) * SIZEOF_VOID_P;
2909                         } else {
2910                                 slot_reg = vtable_reg;
2911                                 offset = MONO_STRUCT_OFFSET (MonoVTable, vtable) +
2912                                         ((mono_method_get_vtable_index (method)) * (SIZEOF_VOID_P));
2913                                 if (imt_arg) {
2914                                         g_assert (mono_method_signature (method)->generic_param_count);
2915                                         emit_imt_argument (cfg, call, call->method, imt_arg);
2916                                 }
2917                         }
2918
2919                         call->inst.sreg1 = slot_reg;
2920                         call->inst.inst_offset = offset;
2921                         call->is_virtual = TRUE;
2922                 }
2923         }
2924
2925         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2926
2927         if (rgctx_arg)
2928                 set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
2929
2930         return (MonoInst*)call;
2931 }
2932
2933 MonoInst*
2934 mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this_ins)
2935 {
2936         return mono_emit_method_call_full (cfg, method, mono_method_signature (method), FALSE, args, this_ins, NULL, NULL);
2937 }
2938
2939 MonoInst*
2940 mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig,
2941                                            MonoInst **args)
2942 {
2943         MonoCallInst *call;
2944
2945         g_assert (sig);
2946
2947         call = mono_emit_call_args (cfg, sig, args, FALSE, FALSE, FALSE, FALSE, FALSE);
2948         call->fptr = func;
2949
2950         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2951
2952         return (MonoInst*)call;
2953 }
2954
2955 MonoInst*
2956 mono_emit_jit_icall (MonoCompile *cfg, gconstpointer func, MonoInst **args)
2957 {
2958         MonoJitICallInfo *info = mono_find_jit_icall_by_addr (func);
2959
2960         g_assert (info);
2961
2962         return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, args);
2963 }
2964
2965 /*
2966  * mono_emit_abs_call:
2967  *
2968  *   Emit a call to the runtime function described by PATCH_TYPE and DATA.
2969  */
2970 inline static MonoInst*
2971 mono_emit_abs_call (MonoCompile *cfg, MonoJumpInfoType patch_type, gconstpointer data,
2972                                         MonoMethodSignature *sig, MonoInst **args)
2973 {
2974         MonoJumpInfo *ji = mono_patch_info_new (cfg->mempool, 0, patch_type, data);
2975         MonoInst *ins;
2976
2977         /*
2978          * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2979          * handle it.
2980          */
2981         if (cfg->abs_patches == NULL)
2982                 cfg->abs_patches = g_hash_table_new (NULL, NULL);
2983         g_hash_table_insert (cfg->abs_patches, ji, ji);
2984         ins = mono_emit_native_call (cfg, ji, sig, args);
2985         ((MonoCallInst*)ins)->fptr_is_patch = TRUE;
2986         return ins;
2987 }
2988
2989 static MonoMethodSignature*
2990 sig_to_rgctx_sig (MonoMethodSignature *sig)
2991 {
2992         // FIXME: memory allocation
2993         MonoMethodSignature *res;
2994         int i;
2995
2996         res = (MonoMethodSignature *)g_malloc (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count + 1) * sizeof (MonoType*));
2997         memcpy (res, sig, MONO_SIZEOF_METHOD_SIGNATURE);
2998         res->param_count = sig->param_count + 1;
2999         for (i = 0; i < sig->param_count; ++i)
3000                 res->params [i] = sig->params [i];
3001         res->params [sig->param_count] = &mono_defaults.int_class->this_arg;
3002         return res;
3003 }
3004
3005 /* Make an indirect call to FSIG passing an additional argument */
3006 static MonoInst*
3007 emit_extra_arg_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **orig_args, int arg_reg, MonoInst *call_target)
3008 {
3009         MonoMethodSignature *csig;
3010         MonoInst *args_buf [16];
3011         MonoInst **args;
3012         int i, pindex, tmp_reg;
3013
3014         /* Make a call with an rgctx/extra arg */
3015         if (fsig->param_count + 2 < 16)
3016                 args = args_buf;
3017         else
3018                 args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (fsig->param_count + 2));
3019         pindex = 0;
3020         if (fsig->hasthis)
3021                 args [pindex ++] = orig_args [0];
3022         for (i = 0; i < fsig->param_count; ++i)
3023                 args [pindex ++] = orig_args [fsig->hasthis + i];
3024         tmp_reg = alloc_preg (cfg);
3025         EMIT_NEW_UNALU (cfg, args [pindex], OP_MOVE, tmp_reg, arg_reg);
3026         csig = sig_to_rgctx_sig (fsig);
3027         return mono_emit_calli (cfg, csig, args, call_target, NULL, NULL);
3028 }
3029
3030 /* Emit an indirect call to the function descriptor ADDR */
3031 static MonoInst*
3032 emit_llvmonly_calli (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, MonoInst *addr)
3033 {
3034         int addr_reg, arg_reg;
3035         MonoInst *call_target;
3036
3037         g_assert (cfg->llvm_only);
3038
3039         /*
3040          * addr points to a <addr, arg> pair, load both of them, and
3041          * make a call to addr, passing arg as an extra arg.
3042          */
3043         addr_reg = alloc_preg (cfg);
3044         EMIT_NEW_LOAD_MEMBASE (cfg, call_target, OP_LOAD_MEMBASE, addr_reg, addr->dreg, 0);
3045         arg_reg = alloc_preg (cfg);
3046         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, arg_reg, addr->dreg, sizeof (gpointer));
3047
3048         return emit_extra_arg_calli (cfg, fsig, args, arg_reg, call_target);
3049 }
3050
3051 static gboolean
3052 direct_icalls_enabled (MonoCompile *cfg)
3053 {
3054         /* LLVM on amd64 can't handle calls to non-32 bit addresses */
3055 #ifdef TARGET_AMD64
3056         if (cfg->compile_llvm)
3057                 return FALSE;
3058 #endif
3059         if (cfg->gen_sdb_seq_points || cfg->disable_direct_icalls)
3060                 return FALSE;
3061         return TRUE;
3062 }
3063
3064 MonoInst*
3065 mono_emit_jit_icall_by_info (MonoCompile *cfg, MonoJitICallInfo *info, MonoInst **args)
3066 {
3067         /*
3068          * Call the jit icall without a wrapper if possible.
3069          * The wrapper is needed for the following reasons:
3070          * - to handle exceptions thrown using mono_raise_exceptions () from the
3071          *   icall function. The EH code needs the lmf frame pushed by the
3072          *   wrapper to be able to unwind back to managed code.
3073          * - to be able to do stack walks for asynchronously suspended
3074          *   threads when debugging.
3075          */
3076         if (info->no_raise && direct_icalls_enabled (cfg)) {
3077                 char *name;
3078                 int costs;
3079
3080                 if (!info->wrapper_method) {
3081                         name = g_strdup_printf ("__icall_wrapper_%s", info->name);
3082                         info->wrapper_method = mono_marshal_get_icall_wrapper (info->sig, name, info->func, TRUE);
3083                         g_free (name);
3084                         mono_memory_barrier ();
3085                 }
3086
3087                 /*
3088                  * Inline the wrapper method, which is basically a call to the C icall, and
3089                  * an exception check.
3090                  */
3091                 costs = inline_method (cfg, info->wrapper_method, NULL,
3092                                                            args, NULL, cfg->real_offset, TRUE);
3093                 g_assert (costs > 0);
3094                 g_assert (!MONO_TYPE_IS_VOID (info->sig->ret));
3095
3096                 return args [0];
3097         } else {
3098                 return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, args);
3099         }
3100 }
3101
3102 static MonoInst*
3103 mono_emit_widen_call_res (MonoCompile *cfg, MonoInst *ins, MonoMethodSignature *fsig)
3104 {
3105         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
3106                 if ((fsig->pinvoke || LLVM_ENABLED) && !fsig->ret->byref) {
3107                         int widen_op = -1;
3108
3109                         /*
3110                          * Native code might return non register sized integers
3111                          * without initializing the upper bits.
3112                          */
3113                         switch (mono_type_to_load_membase (cfg, fsig->ret)) {
3114                         case OP_LOADI1_MEMBASE:
3115                                 widen_op = OP_ICONV_TO_I1;
3116                                 break;
3117                         case OP_LOADU1_MEMBASE:
3118                                 widen_op = OP_ICONV_TO_U1;
3119                                 break;
3120                         case OP_LOADI2_MEMBASE:
3121                                 widen_op = OP_ICONV_TO_I2;
3122                                 break;
3123                         case OP_LOADU2_MEMBASE:
3124                                 widen_op = OP_ICONV_TO_U2;
3125                                 break;
3126                         default:
3127                                 break;
3128                         }
3129
3130                         if (widen_op != -1) {
3131                                 int dreg = alloc_preg (cfg);
3132                                 MonoInst *widen;
3133
3134                                 EMIT_NEW_UNALU (cfg, widen, widen_op, dreg, ins->dreg);
3135                                 widen->type = ins->type;
3136                                 ins = widen;
3137                         }
3138                 }
3139         }
3140
3141         return ins;
3142 }
3143
3144 static MonoMethod*
3145 get_memcpy_method (void)
3146 {
3147         static MonoMethod *memcpy_method = NULL;
3148         if (!memcpy_method) {
3149                 memcpy_method = mono_class_get_method_from_name (mono_defaults.string_class, "memcpy", 3);
3150                 if (!memcpy_method)
3151                         g_error ("Old corlib found. Install a new one");
3152         }
3153         return memcpy_method;
3154 }
3155
3156 static void
3157 create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bitmap, int offset)
3158 {
3159         MonoClassField *field;
3160         gpointer iter = NULL;
3161
3162         while ((field = mono_class_get_fields (klass, &iter))) {
3163                 int foffset;
3164
3165                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
3166                         continue;
3167                 foffset = klass->valuetype ? field->offset - sizeof (MonoObject): field->offset;
3168                 if (mini_type_is_reference (mono_field_get_type (field))) {
3169                         g_assert ((foffset % SIZEOF_VOID_P) == 0);
3170                         *wb_bitmap |= 1 << ((offset + foffset) / SIZEOF_VOID_P);
3171                 } else {
3172                         MonoClass *field_class = mono_class_from_mono_type (field->type);
3173                         if (field_class->has_references)
3174                                 create_write_barrier_bitmap (cfg, field_class, wb_bitmap, offset + foffset);
3175                 }
3176         }
3177 }
3178
3179 static void
3180 emit_write_barrier (MonoCompile *cfg, MonoInst *ptr, MonoInst *value)
3181 {
3182         int card_table_shift_bits;
3183         gpointer card_table_mask;
3184         guint8 *card_table;
3185         MonoInst *dummy_use;
3186         int nursery_shift_bits;
3187         size_t nursery_size;
3188
3189         if (!cfg->gen_write_barriers)
3190                 return;
3191
3192         card_table = mono_gc_get_card_table (&card_table_shift_bits, &card_table_mask);
3193
3194         mono_gc_get_nursery (&nursery_shift_bits, &nursery_size);
3195
3196         if (cfg->backend->have_card_table_wb && !cfg->compile_aot && card_table && nursery_shift_bits > 0 && !COMPILE_LLVM (cfg)) {
3197                 MonoInst *wbarrier;
3198
3199                 MONO_INST_NEW (cfg, wbarrier, OP_CARD_TABLE_WBARRIER);
3200                 wbarrier->sreg1 = ptr->dreg;
3201                 wbarrier->sreg2 = value->dreg;
3202                 MONO_ADD_INS (cfg->cbb, wbarrier);
3203         } else if (card_table && !cfg->compile_aot && !mono_gc_card_table_nursery_check ()) {
3204                 int offset_reg = alloc_preg (cfg);
3205                 int card_reg;
3206                 MonoInst *ins;
3207
3208                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_UN_IMM, offset_reg, ptr->dreg, card_table_shift_bits);
3209                 if (card_table_mask)
3210                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PAND_IMM, offset_reg, offset_reg, card_table_mask);
3211
3212                 /*We can't use PADD_IMM since the cardtable might end up in high addresses and amd64 doesn't support
3213                  * IMM's larger than 32bits.
3214                  */
3215                 ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_GC_CARD_TABLE_ADDR, NULL);
3216                 card_reg = ins->dreg;
3217
3218                 MONO_EMIT_NEW_BIALU (cfg, OP_PADD, offset_reg, offset_reg, card_reg);
3219                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI1_MEMBASE_IMM, offset_reg, 0, 1);
3220         } else {
3221                 MonoMethod *write_barrier = mono_gc_get_write_barrier ();
3222                 mono_emit_method_call (cfg, write_barrier, &ptr, NULL);
3223         }
3224
3225         EMIT_NEW_DUMMY_USE (cfg, dummy_use, value);
3226 }
3227
3228 static gboolean
3229 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
3230 {
3231         int dest_ptr_reg, tmp_reg, destreg, srcreg, offset;
3232         unsigned need_wb = 0;
3233
3234         if (align == 0)
3235                 align = 4;
3236
3237         /*types with references can't have alignment smaller than sizeof(void*) */
3238         if (align < SIZEOF_VOID_P)
3239                 return FALSE;
3240
3241         /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
3242         if (size > 32 * SIZEOF_VOID_P)
3243                 return FALSE;
3244
3245         create_write_barrier_bitmap (cfg, klass, &need_wb, 0);
3246
3247         /* We don't unroll more than 5 stores to avoid code bloat. */
3248         if (size > 5 * SIZEOF_VOID_P) {
3249                 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
3250                 size += (SIZEOF_VOID_P - 1);
3251                 size &= ~(SIZEOF_VOID_P - 1);
3252
3253                 EMIT_NEW_ICONST (cfg, iargs [2], size);
3254                 EMIT_NEW_ICONST (cfg, iargs [3], need_wb);
3255                 mono_emit_jit_icall (cfg, mono_gc_wbarrier_value_copy_bitmap, iargs);
3256                 return TRUE;
3257         }
3258
3259         destreg = iargs [0]->dreg;
3260         srcreg = iargs [1]->dreg;
3261         offset = 0;
3262
3263         dest_ptr_reg = alloc_preg (cfg);
3264         tmp_reg = alloc_preg (cfg);
3265
3266         /*tmp = dreg*/
3267         EMIT_NEW_UNALU (cfg, iargs [0], OP_MOVE, dest_ptr_reg, destreg);
3268
3269         while (size >= SIZEOF_VOID_P) {
3270                 MonoInst *load_inst;
3271                 MONO_INST_NEW (cfg, load_inst, OP_LOAD_MEMBASE);
3272                 load_inst->dreg = tmp_reg;
3273                 load_inst->inst_basereg = srcreg;
3274                 load_inst->inst_offset = offset;
3275                 MONO_ADD_INS (cfg->cbb, load_inst);
3276
3277                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, dest_ptr_reg, 0, tmp_reg);
3278
3279                 if (need_wb & 0x1)
3280                         emit_write_barrier (cfg, iargs [0], load_inst);
3281
3282                 offset += SIZEOF_VOID_P;
3283                 size -= SIZEOF_VOID_P;
3284                 need_wb >>= 1;
3285
3286                 /*tmp += sizeof (void*)*/
3287                 if (size >= SIZEOF_VOID_P) {
3288                         NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, dest_ptr_reg, dest_ptr_reg, SIZEOF_VOID_P);
3289                         MONO_ADD_INS (cfg->cbb, iargs [0]);
3290                 }
3291         }
3292
3293         /* Those cannot be references since size < sizeof (void*) */
3294         while (size >= 4) {
3295                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, tmp_reg, srcreg, offset);
3296                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, offset, tmp_reg);
3297                 offset += 4;
3298                 size -= 4;
3299         }
3300
3301         while (size >= 2) {
3302                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI2_MEMBASE, tmp_reg, srcreg, offset);
3303                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, destreg, offset, tmp_reg);
3304                 offset += 2;
3305                 size -= 2;
3306         }
3307
3308         while (size >= 1) {
3309                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, tmp_reg, srcreg, offset);
3310                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, offset, tmp_reg);
3311                 offset += 1;
3312                 size -= 1;
3313         }
3314
3315         return TRUE;
3316 }
3317
3318 /*
3319  * Emit code to copy a valuetype of type @klass whose address is stored in
3320  * @src->dreg to memory whose address is stored at @dest->dreg.
3321  */
3322 void
3323 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
3324 {
3325         MonoInst *iargs [4];
3326         int n;
3327         guint32 align = 0;
3328         MonoMethod *memcpy_method;
3329         MonoInst *size_ins = NULL;
3330         MonoInst *memcpy_ins = NULL;
3331
3332         g_assert (klass);
3333         if (cfg->gshared)
3334                 klass = mono_class_from_mono_type (mini_get_underlying_type (&klass->byval_arg));
3335
3336         /*
3337          * This check breaks with spilled vars... need to handle it during verification anyway.
3338          * g_assert (klass && klass == src->klass && klass == dest->klass);
3339          */
3340
3341         if (mini_is_gsharedvt_klass (klass)) {
3342                 g_assert (!native);
3343                 size_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_VALUE_SIZE);
3344                 memcpy_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_MEMCPY);
3345         }
3346
3347         if (native)
3348                 n = mono_class_native_size (klass, &align);
3349         else
3350                 n = mono_class_value_size (klass, &align);
3351
3352         /* if native is true there should be no references in the struct */
3353         if (cfg->gen_write_barriers && (klass->has_references || size_ins) && !native) {
3354                 /* Avoid barriers when storing to the stack */
3355                 if (!((dest->opcode == OP_ADD_IMM && dest->sreg1 == cfg->frame_reg) ||
3356                           (dest->opcode == OP_LDADDR))) {
3357                         int context_used;
3358
3359                         iargs [0] = dest;
3360                         iargs [1] = src;
3361
3362                         context_used = mini_class_check_context_used (cfg, klass);
3363
3364                         /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
3365                         if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
3366                                 return;
3367                         } else if (context_used) {
3368                                 iargs [2] = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
3369                         }  else {
3370                                 iargs [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CLASS, klass);
3371                                 if (!cfg->compile_aot)
3372                                         mono_class_compute_gc_descriptor (klass);
3373                         }
3374
3375                         if (size_ins)
3376                                 mono_emit_jit_icall (cfg, mono_gsharedvt_value_copy, iargs);
3377                         else
3378                                 mono_emit_jit_icall (cfg, mono_value_copy, iargs);
3379                         return;
3380                 }
3381         }
3382
3383         if (!size_ins && (cfg->opt & MONO_OPT_INTRINS) && n <= sizeof (gpointer) * 8) {
3384                 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
3385                 mini_emit_memcpy (cfg, dest->dreg, 0, src->dreg, 0, n, align);
3386         } else {
3387                 iargs [0] = dest;
3388                 iargs [1] = src;
3389                 if (size_ins)
3390                         iargs [2] = size_ins;
3391                 else
3392                         EMIT_NEW_ICONST (cfg, iargs [2], n);
3393
3394                 memcpy_method = get_memcpy_method ();
3395                 if (memcpy_ins)
3396                         mono_emit_calli (cfg, mono_method_signature (memcpy_method), iargs, memcpy_ins, NULL, NULL);
3397                 else
3398                         mono_emit_method_call (cfg, memcpy_method, iargs, NULL);
3399         }
3400 }
3401
3402 static MonoMethod*
3403 get_memset_method (void)
3404 {
3405         static MonoMethod *memset_method = NULL;
3406         if (!memset_method) {
3407                 memset_method = mono_class_get_method_from_name (mono_defaults.string_class, "memset", 3);
3408                 if (!memset_method)
3409                         g_error ("Old corlib found. Install a new one");
3410         }
3411         return memset_method;
3412 }
3413
3414 void
3415 mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass)
3416 {
3417         MonoInst *iargs [3];
3418         int n;
3419         guint32 align;
3420         MonoMethod *memset_method;
3421         MonoInst *size_ins = NULL;
3422         MonoInst *bzero_ins = NULL;
3423         static MonoMethod *bzero_method;
3424
3425         /* FIXME: Optimize this for the case when dest is an LDADDR */
3426         mono_class_init (klass);
3427         if (mini_is_gsharedvt_klass (klass)) {
3428                 size_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_VALUE_SIZE);
3429                 bzero_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_BZERO);
3430                 if (!bzero_method)
3431                         bzero_method = mono_class_get_method_from_name (mono_defaults.string_class, "bzero_aligned_1", 2);
3432                 g_assert (bzero_method);
3433                 iargs [0] = dest;
3434                 iargs [1] = size_ins;
3435                 mono_emit_calli (cfg, mono_method_signature (bzero_method), iargs, bzero_ins, NULL, NULL);
3436                 return;
3437         }
3438
3439         klass = mono_class_from_mono_type (mini_get_underlying_type (&klass->byval_arg));
3440
3441         n = mono_class_value_size (klass, &align);
3442
3443         if (n <= sizeof (gpointer) * 8) {
3444                 mini_emit_memset (cfg, dest->dreg, 0, n, 0, align);
3445         }
3446         else {
3447                 memset_method = get_memset_method ();
3448                 iargs [0] = dest;
3449                 EMIT_NEW_ICONST (cfg, iargs [1], 0);
3450                 EMIT_NEW_ICONST (cfg, iargs [2], n);
3451                 mono_emit_method_call (cfg, memset_method, iargs, NULL);
3452         }
3453 }
3454
3455 /*
3456  * emit_get_rgctx:
3457  *
3458  *   Emit IR to return either the this pointer for instance method,
3459  * or the mrgctx for static methods.
3460  */
3461 static MonoInst*
3462 emit_get_rgctx (MonoCompile *cfg, MonoMethod *method, int context_used)
3463 {
3464         MonoInst *this_ins = NULL;
3465
3466         g_assert (cfg->gshared);
3467
3468         if (!(method->flags & METHOD_ATTRIBUTE_STATIC) &&
3469                         !(context_used & MONO_GENERIC_CONTEXT_USED_METHOD) &&
3470                         !method->klass->valuetype)
3471                 EMIT_NEW_ARGLOAD (cfg, this_ins, 0);
3472
3473         if (context_used & MONO_GENERIC_CONTEXT_USED_METHOD) {
3474                 MonoInst *mrgctx_loc, *mrgctx_var;
3475
3476                 g_assert (!this_ins);
3477                 g_assert (method->is_inflated && mono_method_get_context (method)->method_inst);
3478
3479                 mrgctx_loc = mono_get_vtable_var (cfg);
3480                 EMIT_NEW_TEMPLOAD (cfg, mrgctx_var, mrgctx_loc->inst_c0);
3481
3482                 return mrgctx_var;
3483         } else if (method->flags & METHOD_ATTRIBUTE_STATIC || method->klass->valuetype) {
3484                 MonoInst *vtable_loc, *vtable_var;
3485
3486                 g_assert (!this_ins);
3487
3488                 vtable_loc = mono_get_vtable_var (cfg);
3489                 EMIT_NEW_TEMPLOAD (cfg, vtable_var, vtable_loc->inst_c0);
3490
3491                 if (method->is_inflated && mono_method_get_context (method)->method_inst) {
3492                         MonoInst *mrgctx_var = vtable_var;
3493                         int vtable_reg;
3494
3495                         vtable_reg = alloc_preg (cfg);
3496                         EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, MONO_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
3497                         vtable_var->type = STACK_PTR;
3498                 }
3499
3500                 return vtable_var;
3501         } else {
3502                 MonoInst *ins;
3503                 int vtable_reg;
3504
3505                 vtable_reg = alloc_preg (cfg);
3506                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this_ins->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3507                 return ins;
3508         }
3509 }
3510
3511 static MonoJumpInfoRgctxEntry *
3512 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, MonoRgctxInfoType info_type)
3513 {
3514         MonoJumpInfoRgctxEntry *res = (MonoJumpInfoRgctxEntry *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
3515         res->method = method;
3516         res->in_mrgctx = in_mrgctx;
3517         res->data = (MonoJumpInfo *)mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
3518         res->data->type = patch_type;
3519         res->data->data.target = patch_data;
3520         res->info_type = info_type;
3521
3522         return res;
3523 }
3524
3525 static inline MonoInst*
3526 emit_rgctx_fetch_inline (MonoCompile *cfg, MonoInst *rgctx, MonoJumpInfoRgctxEntry *entry)
3527 {
3528         MonoInst *args [16];
3529         MonoInst *call;
3530
3531         // FIXME: No fastpath since the slot is not a compile time constant
3532         args [0] = rgctx;
3533         EMIT_NEW_AOTCONST (cfg, args [1], MONO_PATCH_INFO_RGCTX_SLOT_INDEX, entry);
3534         if (entry->in_mrgctx)
3535                 call = mono_emit_jit_icall (cfg, mono_fill_method_rgctx, args);
3536         else
3537                 call = mono_emit_jit_icall (cfg, mono_fill_class_rgctx, args);
3538         return call;
3539 #if 0
3540         /*
3541          * FIXME: This can be called during decompose, which is a problem since it creates
3542          * new bblocks.
3543          * Also, the fastpath doesn't work since the slot number is dynamically allocated.
3544          */
3545         int i, slot, depth, index, rgctx_reg, val_reg, res_reg;
3546         gboolean mrgctx;
3547         MonoBasicBlock *is_null_bb, *end_bb;
3548         MonoInst *res, *ins, *call;
3549         MonoInst *args[16];
3550
3551         slot = mini_get_rgctx_entry_slot (entry);
3552
3553         mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
3554         index = MONO_RGCTX_SLOT_INDEX (slot);
3555         if (mrgctx)
3556                 index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (gpointer);
3557         for (depth = 0; ; ++depth) {
3558                 int size = mono_class_rgctx_get_array_size (depth, mrgctx);
3559
3560                 if (index < size - 1)
3561                         break;
3562                 index -= size - 1;
3563         }
3564
3565         NEW_BBLOCK (cfg, end_bb);
3566         NEW_BBLOCK (cfg, is_null_bb);
3567
3568         if (mrgctx) {
3569                 rgctx_reg = rgctx->dreg;
3570         } else {
3571                 rgctx_reg = alloc_preg (cfg);
3572
3573                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, rgctx_reg, rgctx->dreg, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
3574                 // FIXME: Avoid this check by allocating the table when the vtable is created etc.
3575                 NEW_BBLOCK (cfg, is_null_bb);
3576
3577                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rgctx_reg, 0);
3578                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, is_null_bb);
3579         }
3580
3581         for (i = 0; i < depth; ++i) {
3582                 int array_reg = alloc_preg (cfg);
3583
3584                 /* load ptr to next array */
3585                 if (mrgctx && i == 0)
3586                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, rgctx_reg, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
3587                 else
3588                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, rgctx_reg, 0);
3589                 rgctx_reg = array_reg;
3590                 /* is the ptr null? */
3591                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rgctx_reg, 0);
3592                 /* if yes, jump to actual trampoline */
3593                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, is_null_bb);
3594         }
3595
3596         /* fetch slot */
3597         val_reg = alloc_preg (cfg);
3598         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, val_reg, rgctx_reg, (index + 1) * sizeof (gpointer));
3599         /* is the slot null? */
3600         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, val_reg, 0);
3601         /* if yes, jump to actual trampoline */
3602         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, is_null_bb);
3603
3604         /* Fastpath */
3605         res_reg = alloc_preg (cfg);
3606         MONO_INST_NEW (cfg, ins, OP_MOVE);
3607         ins->dreg = res_reg;
3608         ins->sreg1 = val_reg;
3609         MONO_ADD_INS (cfg->cbb, ins);
3610         res = ins;
3611         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3612
3613         /* Slowpath */
3614         MONO_START_BB (cfg, is_null_bb);
3615         args [0] = rgctx;
3616         EMIT_NEW_ICONST (cfg, args [1], index);
3617         if (mrgctx)
3618                 call = mono_emit_jit_icall (cfg, mono_fill_method_rgctx, args);
3619         else
3620                 call = mono_emit_jit_icall (cfg, mono_fill_class_rgctx, args);
3621         MONO_INST_NEW (cfg, ins, OP_MOVE);
3622         ins->dreg = res_reg;
3623         ins->sreg1 = call->dreg;
3624         MONO_ADD_INS (cfg->cbb, ins);
3625         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3626
3627         MONO_START_BB (cfg, end_bb);
3628
3629         return res;
3630 #endif
3631 }
3632
3633 /*
3634  * emit_rgctx_fetch:
3635  *
3636  *   Emit IR to load the value of the rgctx entry ENTRY from the rgctx
3637  * given by RGCTX.
3638  */
3639 static inline MonoInst*
3640 emit_rgctx_fetch (MonoCompile *cfg, MonoInst *rgctx, MonoJumpInfoRgctxEntry *entry)
3641 {
3642         if (cfg->llvm_only)
3643                 return emit_rgctx_fetch_inline (cfg, rgctx, entry);
3644         else
3645                 return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
3646 }
3647
3648 static MonoInst*
3649 emit_get_rgctx_klass (MonoCompile *cfg, int context_used,
3650                                           MonoClass *klass, MonoRgctxInfoType rgctx_type)
3651 {
3652         MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_CLASS, klass, rgctx_type);
3653         MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3654
3655         return emit_rgctx_fetch (cfg, rgctx, entry);
3656 }
3657
3658 static MonoInst*
3659 emit_get_rgctx_sig (MonoCompile *cfg, int context_used,
3660                                         MonoMethodSignature *sig, MonoRgctxInfoType rgctx_type)
3661 {
3662         MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_SIGNATURE, sig, rgctx_type);
3663         MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3664
3665         return emit_rgctx_fetch (cfg, rgctx, entry);
3666 }
3667
3668 static MonoInst*
3669 emit_get_rgctx_gsharedvt_call (MonoCompile *cfg, int context_used,
3670                                                            MonoMethodSignature *sig, MonoMethod *cmethod, MonoRgctxInfoType rgctx_type)
3671 {
3672         MonoJumpInfoGSharedVtCall *call_info;
3673         MonoJumpInfoRgctxEntry *entry;
3674         MonoInst *rgctx;
3675
3676         call_info = (MonoJumpInfoGSharedVtCall *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoGSharedVtCall));
3677         call_info->sig = sig;
3678         call_info->method = cmethod;
3679
3680         entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_CALL, call_info, rgctx_type);
3681         rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3682
3683         return emit_rgctx_fetch (cfg, rgctx, entry);
3684 }
3685
3686 /*
3687  * emit_get_rgctx_virt_method:
3688  *
3689  *   Return data for method VIRT_METHOD for a receiver of type KLASS.
3690  */
3691 static MonoInst*
3692 emit_get_rgctx_virt_method (MonoCompile *cfg, int context_used,
3693                                                         MonoClass *klass, MonoMethod *virt_method, MonoRgctxInfoType rgctx_type)
3694 {
3695         MonoJumpInfoVirtMethod *info;
3696         MonoJumpInfoRgctxEntry *entry;
3697         MonoInst *rgctx;
3698
3699         info = (MonoJumpInfoVirtMethod *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoVirtMethod));
3700         info->klass = klass;
3701         info->method = virt_method;
3702
3703         entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_VIRT_METHOD, info, rgctx_type);
3704         rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3705
3706         return emit_rgctx_fetch (cfg, rgctx, entry);
3707 }
3708
3709 static MonoInst*
3710 emit_get_rgctx_gsharedvt_method (MonoCompile *cfg, int context_used,
3711                                                                  MonoMethod *cmethod, MonoGSharedVtMethodInfo *info)
3712 {
3713         MonoJumpInfoRgctxEntry *entry;
3714         MonoInst *rgctx;
3715
3716         entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_GSHAREDVT_METHOD, info, MONO_RGCTX_INFO_METHOD_GSHAREDVT_INFO);
3717         rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3718
3719         return emit_rgctx_fetch (cfg, rgctx, entry);
3720 }
3721
3722 /*
3723  * emit_get_rgctx_method:
3724  *
3725  *   Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
3726  * normal constants, else emit a load from the rgctx.
3727  */
3728 static MonoInst*
3729 emit_get_rgctx_method (MonoCompile *cfg, int context_used,
3730                                            MonoMethod *cmethod, MonoRgctxInfoType rgctx_type)
3731 {
3732         if (!context_used) {
3733                 MonoInst *ins;
3734
3735                 switch (rgctx_type) {
3736                 case MONO_RGCTX_INFO_METHOD:
3737                         EMIT_NEW_METHODCONST (cfg, ins, cmethod);
3738                         return ins;
3739                 case MONO_RGCTX_INFO_METHOD_RGCTX:
3740                         EMIT_NEW_METHOD_RGCTX_CONST (cfg, ins, cmethod);
3741                         return ins;
3742                 default:
3743                         g_assert_not_reached ();
3744                 }
3745         } else {
3746                 MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_METHODCONST, cmethod, rgctx_type);
3747                 MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3748
3749                 return emit_rgctx_fetch (cfg, rgctx, entry);
3750         }
3751 }
3752
3753 static MonoInst*
3754 emit_get_rgctx_field (MonoCompile *cfg, int context_used,
3755                                           MonoClassField *field, MonoRgctxInfoType rgctx_type)
3756 {
3757         MonoJumpInfoRgctxEntry *entry = mono_patch_info_rgctx_entry_new (cfg->mempool, cfg->current_method, context_used & MONO_GENERIC_CONTEXT_USED_METHOD, MONO_PATCH_INFO_FIELD, field, rgctx_type);
3758         MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3759
3760         return emit_rgctx_fetch (cfg, rgctx, entry);
3761 }
3762
3763 static int
3764 get_gsharedvt_info_slot (MonoCompile *cfg, gpointer data, MonoRgctxInfoType rgctx_type)
3765 {
3766         MonoGSharedVtMethodInfo *info = cfg->gsharedvt_info;
3767         MonoRuntimeGenericContextInfoTemplate *template_;
3768         int i, idx;
3769
3770         g_assert (info);
3771
3772         for (i = 0; i < info->num_entries; ++i) {
3773                 MonoRuntimeGenericContextInfoTemplate *otemplate = &info->entries [i];
3774
3775                 if (otemplate->info_type == rgctx_type && otemplate->data == data && rgctx_type != MONO_RGCTX_INFO_LOCAL_OFFSET)
3776                         return i;
3777         }
3778
3779         if (info->num_entries == info->count_entries) {
3780                 MonoRuntimeGenericContextInfoTemplate *new_entries;
3781                 int new_count_entries = info->count_entries ? info->count_entries * 2 : 16;
3782
3783                 new_entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * new_count_entries);
3784
3785                 memcpy (new_entries, info->entries, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
3786                 info->entries = new_entries;
3787                 info->count_entries = new_count_entries;
3788         }
3789
3790         idx = info->num_entries;
3791         template_ = &info->entries [idx];
3792         template_->info_type = rgctx_type;
3793         template_->data = data;
3794
3795         info->num_entries ++;
3796
3797         return idx;
3798 }
3799
3800 /*
3801  * emit_get_gsharedvt_info:
3802  *
3803  *   This is similar to emit_get_rgctx_.., but loads the data from the gsharedvt info var instead of calling an rgctx fetch trampoline.
3804  */
3805 static MonoInst*
3806 emit_get_gsharedvt_info (MonoCompile *cfg, gpointer data, MonoRgctxInfoType rgctx_type)
3807 {
3808         MonoInst *ins;
3809         int idx, dreg;
3810
3811         idx = get_gsharedvt_info_slot (cfg, data, rgctx_type);
3812         /* Load info->entries [idx] */
3813         dreg = alloc_preg (cfg);
3814         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, cfg->gsharedvt_info_var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
3815
3816         return ins;
3817 }
3818
3819 static MonoInst*
3820 emit_get_gsharedvt_info_klass (MonoCompile *cfg, MonoClass *klass, MonoRgctxInfoType rgctx_type)
3821 {
3822         return emit_get_gsharedvt_info (cfg, &klass->byval_arg, rgctx_type);
3823 }
3824
3825 /*
3826  * On return the caller must check @klass for load errors.
3827  */
3828 static void
3829 emit_class_init (MonoCompile *cfg, MonoClass *klass)
3830 {
3831         MonoInst *vtable_arg;
3832         int context_used;
3833
3834         context_used = mini_class_check_context_used (cfg, klass);
3835
3836         if (context_used) {
3837                 vtable_arg = emit_get_rgctx_klass (cfg, context_used,
3838                                                                                    klass, MONO_RGCTX_INFO_VTABLE);
3839         } else {
3840                 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3841
3842                 if (!vtable)
3843                         return;
3844                 EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
3845         }
3846
3847         if (!COMPILE_LLVM (cfg) && cfg->backend->have_op_generic_class_init) {
3848                 MonoInst *ins;
3849
3850                 /*
3851                  * Using an opcode instead of emitting IR here allows the hiding of the call inside the opcode,
3852                  * so this doesn't have to clobber any regs and it doesn't break basic blocks.
3853                  */
3854                 MONO_INST_NEW (cfg, ins, OP_GENERIC_CLASS_INIT);
3855                 ins->sreg1 = vtable_arg->dreg;
3856                 MONO_ADD_INS (cfg->cbb, ins);
3857         } else {
3858                 static int byte_offset = -1;
3859                 static guint8 bitmask;
3860                 int bits_reg, inited_reg;
3861                 MonoBasicBlock *inited_bb;
3862                 MonoInst *args [16];
3863
3864                 if (byte_offset < 0)
3865                         mono_marshal_find_bitfield_offset (MonoVTable, initialized, &byte_offset, &bitmask);
3866
3867                 bits_reg = alloc_ireg (cfg);
3868                 inited_reg = alloc_ireg (cfg);
3869
3870                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, bits_reg, vtable_arg->dreg, byte_offset);
3871                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, inited_reg, bits_reg, bitmask);
3872
3873                 NEW_BBLOCK (cfg, inited_bb);
3874
3875                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, inited_reg, 0);
3876                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBNE_UN, inited_bb);
3877
3878                 args [0] = vtable_arg;
3879                 mono_emit_jit_icall (cfg, mono_generic_class_init, args);
3880
3881                 MONO_START_BB (cfg, inited_bb);
3882         }
3883 }
3884
3885 static void
3886 emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_loc, gboolean nonempty_stack)
3887 {
3888         MonoInst *ins;
3889
3890         if (cfg->gen_seq_points && cfg->method == method) {
3891                 NEW_SEQ_POINT (cfg, ins, ip - cfg->header->code, intr_loc);
3892                 if (nonempty_stack)
3893                         ins->flags |= MONO_INST_NONEMPTY_STACK;
3894                 MONO_ADD_INS (cfg->cbb, ins);
3895         }
3896 }
3897
3898 static void
3899 save_cast_details (MonoCompile *cfg, MonoClass *klass, int obj_reg, gboolean null_check)
3900 {
3901         if (mini_get_debug_options ()->better_cast_details) {
3902                 int vtable_reg = alloc_preg (cfg);
3903                 int klass_reg = alloc_preg (cfg);
3904                 MonoBasicBlock *is_null_bb = NULL;
3905                 MonoInst *tls_get;
3906                 int to_klass_reg, context_used;
3907
3908                 if (null_check) {
3909                         NEW_BBLOCK (cfg, is_null_bb);
3910
3911                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
3912                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, is_null_bb);
3913                 }
3914
3915                 tls_get = mono_get_jit_tls_intrinsic (cfg);
3916                 if (!tls_get) {
3917                         fprintf (stderr, "error: --debug=casts not supported on this platform.\n.");
3918                         exit (1);
3919                 }
3920
3921                 MONO_ADD_INS (cfg->cbb, tls_get);
3922                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3923                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3924
3925                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3926
3927                 context_used = mini_class_check_context_used (cfg, klass);
3928                 if (context_used) {
3929                         MonoInst *class_ins;
3930
3931                         class_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
3932                         to_klass_reg = class_ins->dreg;
3933                 } else {
3934                         to_klass_reg = alloc_preg (cfg);
3935                         MONO_EMIT_NEW_CLASSCONST (cfg, to_klass_reg, klass);
3936                 }
3937                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3938
3939                 if (null_check)
3940                         MONO_START_BB (cfg, is_null_bb);
3941         }
3942 }
3943
3944 static void
3945 reset_cast_details (MonoCompile *cfg)
3946 {
3947         /* Reset the variables holding the cast details */
3948         if (mini_get_debug_options ()->better_cast_details) {
3949                 MonoInst *tls_get = mono_get_jit_tls_intrinsic (cfg);
3950
3951                 MONO_ADD_INS (cfg->cbb, tls_get);
3952                 /* It is enough to reset the from field */
3953                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, MONO_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3954         }
3955 }
3956
3957 /*
3958  * On return the caller must check @array_class for load errors
3959  */
3960 static void
3961 mini_emit_check_array_type (MonoCompile *cfg, MonoInst *obj, MonoClass *array_class)
3962 {
3963         int vtable_reg = alloc_preg (cfg);
3964         int context_used;
3965
3966         context_used = mini_class_check_context_used (cfg, array_class);
3967
3968         save_cast_details (cfg, array_class, obj->dreg, FALSE);
3969
3970         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
3971
3972         if (cfg->opt & MONO_OPT_SHARED) {
3973                 int class_reg = alloc_preg (cfg);
3974                 MonoInst *ins;
3975
3976                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
3977                 ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_CLASS, array_class);
3978                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, class_reg, ins->dreg);
3979         } else if (context_used) {
3980                 MonoInst *vtable_ins;
3981
3982                 vtable_ins = emit_get_rgctx_klass (cfg, context_used, array_class, MONO_RGCTX_INFO_VTABLE);
3983                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, vtable_reg, vtable_ins->dreg);
3984         } else {
3985                 if (cfg->compile_aot) {
3986                         int vt_reg;
3987                         MonoVTable *vtable;
3988
3989                         if (!(vtable = mono_class_vtable (cfg->domain, array_class)))
3990                                 return;
3991                         vt_reg = alloc_preg (cfg);
3992                         MONO_EMIT_NEW_VTABLECONST (cfg, vt_reg, vtable);
3993                         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, vtable_reg, vt_reg);
3994                 } else {
3995                         MonoVTable *vtable;
3996                         if (!(vtable = mono_class_vtable (cfg->domain, array_class)))
3997                                 return;
3998                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, vtable);
3999                 }
4000         }
4001
4002         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "ArrayTypeMismatchException");
4003
4004         reset_cast_details (cfg);
4005 }
4006
4007 /**
4008  * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
4009  * generic code is generated.
4010  */
4011 static MonoInst*
4012 handle_unbox_nullable (MonoCompile* cfg, MonoInst* val, MonoClass* klass, int context_used)
4013 {
4014         MonoMethod* method = mono_class_get_method_from_name (klass, "Unbox", 1);
4015
4016         if (context_used) {
4017                 MonoInst *rgctx, *addr;
4018
4019                 /* FIXME: What if the class is shared?  We might not
4020                    have to get the address of the method from the
4021                    RGCTX. */
4022                 addr = emit_get_rgctx_method (cfg, context_used, method,
4023                                                                           MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4024                 if (cfg->llvm_only && cfg->gsharedvt) {
4025                         return emit_llvmonly_calli (cfg, mono_method_signature (method), &val, addr);
4026                 } else {
4027                         rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
4028
4029                         return mono_emit_calli (cfg, mono_method_signature (method), &val, addr, NULL, rgctx);
4030                 }
4031         } else {
4032                 gboolean pass_vtable, pass_mrgctx;
4033                 MonoInst *rgctx_arg = NULL;
4034
4035                 check_method_sharing (cfg, method, &pass_vtable, &pass_mrgctx);
4036                 g_assert (!pass_mrgctx);
4037
4038                 if (pass_vtable) {
4039                         MonoVTable *vtable = mono_class_vtable (cfg->domain, method->klass);
4040
4041                         g_assert (vtable);
4042                         EMIT_NEW_VTABLECONST (cfg, rgctx_arg, vtable);
4043                 }
4044
4045                 return mono_emit_method_call_full (cfg, method, NULL, FALSE, &val, NULL, NULL, rgctx_arg);
4046         }
4047 }
4048
4049 static MonoInst*
4050 handle_unbox (MonoCompile *cfg, MonoClass *klass, MonoInst **sp, int context_used)
4051 {
4052         MonoInst *add;
4053         int obj_reg;
4054         int vtable_reg = alloc_dreg (cfg ,STACK_PTR);
4055         int klass_reg = alloc_dreg (cfg ,STACK_PTR);
4056         int eclass_reg = alloc_dreg (cfg ,STACK_PTR);
4057         int rank_reg = alloc_dreg (cfg ,STACK_I4);
4058
4059         obj_reg = sp [0]->dreg;
4060         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4061         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4062
4063         /* FIXME: generics */
4064         g_assert (klass->rank == 0);
4065
4066         // Check rank == 0
4067         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, 0);
4068         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
4069
4070         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4071         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, element_class));
4072
4073         if (context_used) {
4074                 MonoInst *element_class;
4075
4076                 /* This assertion is from the unboxcast insn */
4077                 g_assert (klass->rank == 0);
4078
4079                 element_class = emit_get_rgctx_klass (cfg, context_used,
4080                                 klass, MONO_RGCTX_INFO_ELEMENT_KLASS);
4081
4082                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, eclass_reg, element_class->dreg);
4083                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
4084         } else {
4085                 save_cast_details (cfg, klass->element_class, obj_reg, FALSE);
4086                 mini_emit_class_check (cfg, eclass_reg, klass->element_class);
4087                 reset_cast_details (cfg);
4088         }
4089
4090         NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), obj_reg, sizeof (MonoObject));
4091         MONO_ADD_INS (cfg->cbb, add);
4092         add->type = STACK_MP;
4093         add->klass = klass;
4094
4095         return add;
4096 }
4097
4098 static MonoInst*
4099 handle_unbox_gsharedvt (MonoCompile *cfg, MonoClass *klass, MonoInst *obj)
4100 {
4101         MonoInst *addr, *klass_inst, *is_ref, *args[16];
4102         MonoBasicBlock *is_ref_bb, *is_nullable_bb, *end_bb;
4103         MonoInst *ins;
4104         int dreg, addr_reg;
4105
4106         klass_inst = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_KLASS);
4107
4108         /* obj */
4109         args [0] = obj;
4110
4111         /* klass */
4112         args [1] = klass_inst;
4113
4114         /* CASTCLASS */
4115         obj = mono_emit_jit_icall (cfg, mono_object_castclass_unbox, args);
4116
4117         NEW_BBLOCK (cfg, is_ref_bb);
4118         NEW_BBLOCK (cfg, is_nullable_bb);
4119         NEW_BBLOCK (cfg, end_bb);
4120         is_ref = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_CLASS_BOX_TYPE);
4121         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
4122         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_ref_bb);
4123
4124         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4125         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_nullable_bb);
4126
4127         /* This will contain either the address of the unboxed vtype, or an address of the temporary where the ref is stored */
4128         addr_reg = alloc_dreg (cfg, STACK_MP);
4129
4130         /* Non-ref case */
4131         /* UNBOX */
4132         NEW_BIALU_IMM (cfg, addr, OP_ADD_IMM, addr_reg, obj->dreg, sizeof (MonoObject));
4133         MONO_ADD_INS (cfg->cbb, addr);
4134
4135         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4136
4137         /* Ref case */
4138         MONO_START_BB (cfg, is_ref_bb);
4139
4140         /* Save the ref to a temporary */
4141         dreg = alloc_ireg (cfg);
4142         EMIT_NEW_VARLOADA_VREG (cfg, addr, dreg, &klass->byval_arg);
4143         addr->dreg = addr_reg;
4144         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, addr->dreg, 0, obj->dreg);
4145         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4146
4147         /* Nullable case */
4148         MONO_START_BB (cfg, is_nullable_bb);
4149
4150         {
4151                 MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
4152                 MonoInst *unbox_call;
4153                 MonoMethodSignature *unbox_sig;
4154
4155                 unbox_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4156                 unbox_sig->ret = &klass->byval_arg;
4157                 unbox_sig->param_count = 1;
4158                 unbox_sig->params [0] = &mono_defaults.object_class->byval_arg;
4159
4160                 if (cfg->llvm_only)
4161                         unbox_call = emit_llvmonly_calli (cfg, unbox_sig, &obj, addr);
4162                 else
4163                         unbox_call = mono_emit_calli (cfg, unbox_sig, &obj, addr, NULL, NULL);
4164
4165                 EMIT_NEW_VARLOADA_VREG (cfg, addr, unbox_call->dreg, &klass->byval_arg);
4166                 addr->dreg = addr_reg;
4167         }
4168
4169         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4170
4171         /* End */
4172         MONO_START_BB (cfg, end_bb);
4173
4174         /* LDOBJ */
4175         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr_reg, 0);
4176
4177         return ins;
4178 }
4179
4180 /*
4181  * Returns NULL and set the cfg exception on error.
4182  */
4183 static MonoInst*
4184 handle_alloc (MonoCompile *cfg, MonoClass *klass, gboolean for_box, int context_used)
4185 {
4186         MonoInst *iargs [2];
4187         void *alloc_ftn;
4188
4189         if (context_used) {
4190                 MonoInst *data;
4191                 MonoRgctxInfoType rgctx_info;
4192                 MonoInst *iargs [2];
4193                 gboolean known_instance_size = !mini_is_gsharedvt_klass (klass);
4194
4195                 MonoMethod *managed_alloc = mono_gc_get_managed_allocator (klass, for_box, known_instance_size);
4196
4197                 if (cfg->opt & MONO_OPT_SHARED)
4198                         rgctx_info = MONO_RGCTX_INFO_KLASS;
4199                 else
4200                         rgctx_info = MONO_RGCTX_INFO_VTABLE;
4201                 data = emit_get_rgctx_klass (cfg, context_used, klass, rgctx_info);
4202
4203                 if (cfg->opt & MONO_OPT_SHARED) {
4204                         EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
4205                         iargs [1] = data;
4206                         alloc_ftn = ves_icall_object_new;
4207                 } else {
4208                         iargs [0] = data;
4209                         alloc_ftn = ves_icall_object_new_specific;
4210                 }
4211
4212                 if (managed_alloc && !(cfg->opt & MONO_OPT_SHARED)) {
4213                         if (known_instance_size) {
4214                                 int size = mono_class_instance_size (klass);
4215                                 if (size < sizeof (MonoObject))
4216                                         g_error ("Invalid size %d for class %s", size, mono_type_get_full_name (klass));
4217
4218                                 EMIT_NEW_ICONST (cfg, iargs [1], mono_gc_get_aligned_size_for_allocator (size));
4219                         }
4220                         return mono_emit_method_call (cfg, managed_alloc, iargs, NULL);
4221                 }
4222
4223                 return mono_emit_jit_icall (cfg, alloc_ftn, iargs);
4224         }
4225
4226         if (cfg->opt & MONO_OPT_SHARED) {
4227                 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
4228                 EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
4229
4230                 alloc_ftn = ves_icall_object_new;
4231         } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
4232                 /* This happens often in argument checking code, eg. throw new FooException... */
4233                 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
4234                 EMIT_NEW_ICONST (cfg, iargs [0], mono_metadata_token_index (klass->type_token));
4235                 return mono_emit_jit_icall (cfg, mono_helper_newobj_mscorlib, iargs);
4236         } else {
4237                 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
4238                 MonoMethod *managed_alloc = NULL;
4239                 gboolean pass_lw;
4240
4241                 if (!vtable) {
4242                         mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
4243                         cfg->exception_ptr = klass;
4244                         return NULL;
4245                 }
4246
4247                 managed_alloc = mono_gc_get_managed_allocator (klass, for_box, TRUE);
4248
4249                 if (managed_alloc) {
4250                         int size = mono_class_instance_size (klass);
4251                         if (size < sizeof (MonoObject))
4252                                 g_error ("Invalid size %d for class %s", size, mono_type_get_full_name (klass));
4253
4254                         EMIT_NEW_VTABLECONST (cfg, iargs [0], vtable);
4255                         EMIT_NEW_ICONST (cfg, iargs [1], mono_gc_get_aligned_size_for_allocator (size));
4256                         return mono_emit_method_call (cfg, managed_alloc, iargs, NULL);
4257                 }
4258                 alloc_ftn = mono_class_get_allocation_ftn (vtable, for_box, &pass_lw);
4259                 if (pass_lw) {
4260                         guint32 lw = vtable->klass->instance_size;
4261                         lw = ((lw + (sizeof (gpointer) - 1)) & ~(sizeof (gpointer) - 1)) / sizeof (gpointer);
4262                         EMIT_NEW_ICONST (cfg, iargs [0], lw);
4263                         EMIT_NEW_VTABLECONST (cfg, iargs [1], vtable);
4264                 }
4265                 else {
4266                         EMIT_NEW_VTABLECONST (cfg, iargs [0], vtable);
4267                 }
4268         }
4269
4270         return mono_emit_jit_icall (cfg, alloc_ftn, iargs);
4271 }
4272
4273 /*
4274  * Returns NULL and set the cfg exception on error.
4275  */
4276 static MonoInst*
4277 handle_box (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used)
4278 {
4279         MonoInst *alloc, *ins;
4280
4281         if (mono_class_is_nullable (klass)) {
4282                 MonoMethod* method = mono_class_get_method_from_name (klass, "Box", 1);
4283
4284                 if (context_used) {
4285                         if (cfg->llvm_only && cfg->gsharedvt) {
4286                                 MonoInst *addr = emit_get_rgctx_method (cfg, context_used, method,
4287                                                                                                                 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4288                                 return emit_llvmonly_calli (cfg, mono_method_signature (method), &val, addr);
4289                         } else {
4290                                 /* FIXME: What if the class is shared?  We might not
4291                                    have to get the method address from the RGCTX. */
4292                                 MonoInst *addr = emit_get_rgctx_method (cfg, context_used, method,
4293                                                                                                                 MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
4294                                 MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
4295
4296                                 return mono_emit_calli (cfg, mono_method_signature (method), &val, addr, NULL, rgctx);
4297                         }
4298                 } else {
4299                         gboolean pass_vtable, pass_mrgctx;
4300                         MonoInst *rgctx_arg = NULL;
4301
4302                         check_method_sharing (cfg, method, &pass_vtable, &pass_mrgctx);
4303                         g_assert (!pass_mrgctx);
4304
4305                         if (pass_vtable) {
4306                                 MonoVTable *vtable = mono_class_vtable (cfg->domain, method->klass);
4307
4308                                 g_assert (vtable);
4309                                 EMIT_NEW_VTABLECONST (cfg, rgctx_arg, vtable);
4310                         }
4311
4312                         return mono_emit_method_call_full (cfg, method, NULL, FALSE, &val, NULL, NULL, rgctx_arg);
4313                 }
4314         }
4315
4316         if (mini_is_gsharedvt_klass (klass)) {
4317                 MonoBasicBlock *is_ref_bb, *is_nullable_bb, *end_bb;
4318                 MonoInst *res, *is_ref, *src_var, *addr;
4319                 int dreg;
4320
4321                 dreg = alloc_ireg (cfg);
4322
4323                 NEW_BBLOCK (cfg, is_ref_bb);
4324                 NEW_BBLOCK (cfg, is_nullable_bb);
4325                 NEW_BBLOCK (cfg, end_bb);
4326                 is_ref = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_CLASS_BOX_TYPE);
4327                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
4328                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_ref_bb);
4329
4330                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, is_ref->dreg, MONO_GSHAREDVT_BOX_TYPE_NULLABLE);
4331                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_nullable_bb);
4332
4333                 /* Non-ref case */
4334                 alloc = handle_alloc (cfg, klass, TRUE, context_used);
4335                 if (!alloc)
4336                         return NULL;
4337                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4338                 ins->opcode = OP_STOREV_MEMBASE;
4339
4340                 EMIT_NEW_UNALU (cfg, res, OP_MOVE, dreg, alloc->dreg);
4341                 res->type = STACK_OBJ;
4342                 res->klass = klass;
4343                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4344
4345                 /* Ref case */
4346                 MONO_START_BB (cfg, is_ref_bb);
4347
4348                 /* val is a vtype, so has to load the value manually */
4349                 src_var = get_vreg_to_inst (cfg, val->dreg);
4350                 if (!src_var)
4351                         src_var = mono_compile_create_var_for_vreg (cfg, &klass->byval_arg, OP_LOCAL, val->dreg);
4352                 EMIT_NEW_VARLOADA (cfg, addr, src_var, src_var->inst_vtype);
4353                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, addr->dreg, 0);
4354                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4355
4356                 /* Nullable case */
4357                 MONO_START_BB (cfg, is_nullable_bb);
4358
4359                 {
4360                         MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass,
4361                                                                                                         MONO_RGCTX_INFO_NULLABLE_CLASS_BOX);
4362                         MonoInst *box_call;
4363                         MonoMethodSignature *box_sig;
4364
4365                         /*
4366                          * klass is Nullable<T>, need to call Nullable<T>.Box () using a gsharedvt signature, but we cannot
4367                          * construct that method at JIT time, so have to do things by hand.
4368                          */
4369                         box_sig = (MonoMethodSignature *)mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
4370                         box_sig->ret = &mono_defaults.object_class->byval_arg;
4371                         box_sig->param_count = 1;
4372                         box_sig->params [0] = &klass->byval_arg;
4373
4374                         if (cfg->llvm_only)
4375                                 box_call = emit_llvmonly_calli (cfg, box_sig, &val, addr);
4376                         else
4377                                 box_call = mono_emit_calli (cfg, box_sig, &val, addr, NULL, NULL);
4378                         EMIT_NEW_UNALU (cfg, res, OP_MOVE, dreg, box_call->dreg);
4379                         res->type = STACK_OBJ;
4380                         res->klass = klass;
4381                 }
4382
4383                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4384
4385                 MONO_START_BB (cfg, end_bb);
4386
4387                 return res;
4388         } else {
4389                 alloc = handle_alloc (cfg, klass, TRUE, context_used);
4390                 if (!alloc)
4391                         return NULL;
4392
4393                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
4394                 return alloc;
4395         }
4396 }
4397
4398 static gboolean
4399 mini_class_has_reference_variant_generic_argument (MonoCompile *cfg, MonoClass *klass, int context_used)
4400 {
4401         int i;
4402         MonoGenericContainer *container;
4403         MonoGenericInst *ginst;
4404
4405         if (klass->generic_class) {
4406                 container = klass->generic_class->container_class->generic_container;
4407                 ginst = klass->generic_class->context.class_inst;
4408         } else if (klass->generic_container && context_used) {
4409                 container = klass->generic_container;
4410                 ginst = container->context.class_inst;
4411         } else {
4412                 return FALSE;
4413         }
4414
4415         for (i = 0; i < container->type_argc; ++i) {
4416                 MonoType *type;
4417                 if (!(mono_generic_container_get_param_info (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)))
4418                         continue;
4419                 type = ginst->type_argv [i];
4420                 if (mini_type_is_reference (type))
4421                         return TRUE;
4422         }
4423         return FALSE;
4424 }
4425
4426 static GHashTable* direct_icall_type_hash;
4427
4428 static gboolean
4429 icall_is_direct_callable (MonoCompile *cfg, MonoMethod *cmethod)
4430 {
4431         /* LLVM on amd64 can't handle calls to non-32 bit addresses */
4432         if (!direct_icalls_enabled (cfg))
4433                 return FALSE;
4434
4435         /*
4436          * An icall is directly callable if it doesn't directly or indirectly call mono_raise_exception ().
4437          * Whitelist a few icalls for now.
4438          */
4439         if (!direct_icall_type_hash) {
4440                 GHashTable *h = g_hash_table_new (g_str_hash, g_str_equal);
4441
4442                 g_hash_table_insert (h, (char*)"Decimal", GUINT_TO_POINTER (1));
4443                 g_hash_table_insert (h, (char*)"Number", GUINT_TO_POINTER (1));
4444                 g_hash_table_insert (h, (char*)"Buffer", GUINT_TO_POINTER (1));
4445                 g_hash_table_insert (h, (char*)"Monitor", GUINT_TO_POINTER (1));
4446                 mono_memory_barrier ();
4447                 direct_icall_type_hash = h;
4448         }
4449
4450         if (cmethod->klass == mono_defaults.math_class)
4451                 return TRUE;
4452         /* No locking needed */
4453         if (cmethod->klass->image == mono_defaults.corlib && g_hash_table_lookup (direct_icall_type_hash, cmethod->klass->name))
4454                 return TRUE;
4455         return FALSE;
4456 }
4457
4458 #define is_complex_isinst(klass) ((klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || (klass->flags & TYPE_ATTRIBUTE_SEALED) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
4459
4460 static MonoInst*
4461 emit_castclass_with_cache (MonoCompile *cfg, MonoClass *klass, MonoInst **args)
4462 {
4463         MonoMethod *mono_castclass;
4464         MonoInst *res;
4465
4466         mono_castclass = mono_marshal_get_castclass_with_cache ();
4467
4468         save_cast_details (cfg, klass, args [0]->dreg, TRUE);
4469         res = mono_emit_method_call (cfg, mono_castclass, args, NULL);
4470         reset_cast_details (cfg);
4471
4472         return res;
4473 }
4474
4475 static int
4476 get_castclass_cache_idx (MonoCompile *cfg)
4477 {
4478         /* Each CASTCLASS_CACHE patch needs a unique index which identifies the call site */
4479         cfg->castclass_cache_index ++;
4480         return (cfg->method_index << 16) | cfg->castclass_cache_index;
4481 }
4482
4483 static MonoInst*
4484 emit_castclass_with_cache_nonshared (MonoCompile *cfg, MonoInst *obj, MonoClass *klass)
4485 {
4486         MonoInst *args [3];
4487         int idx;
4488
4489         /* obj */
4490         args [0] = obj;
4491
4492         /* klass */
4493         EMIT_NEW_CLASSCONST (cfg, args [1], klass);
4494
4495         /* inline cache*/
4496         idx = get_castclass_cache_idx (cfg);
4497         args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
4498
4499         /*The wrapper doesn't inline well so the bloat of inlining doesn't pay off.*/
4500         return emit_castclass_with_cache (cfg, klass, args);
4501 }
4502
4503 /*
4504  * Returns NULL and set the cfg exception on error.
4505  */
4506 static MonoInst*
4507 handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, guint8 *ip, int *inline_costs)
4508 {
4509         MonoBasicBlock *is_null_bb;
4510         int obj_reg = src->dreg;
4511         int vtable_reg = alloc_preg (cfg);
4512         int context_used;
4513         MonoInst *klass_inst = NULL, *res;
4514
4515         context_used = mini_class_check_context_used (cfg, klass);
4516
4517         if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
4518                 res = emit_castclass_with_cache_nonshared (cfg, src, klass);
4519                 (*inline_costs) += 2;
4520                 return res;
4521         } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
4522                 MonoMethod *mono_castclass;
4523                 MonoInst *iargs [1];
4524                 int costs;
4525
4526                 mono_castclass = mono_marshal_get_castclass (klass);
4527                 iargs [0] = src;
4528
4529                 save_cast_details (cfg, klass, src->dreg, TRUE);
4530                 costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass),
4531                                                            iargs, ip, cfg->real_offset, TRUE);
4532                 reset_cast_details (cfg);
4533                 CHECK_CFG_EXCEPTION;
4534                 g_assert (costs > 0);
4535
4536                 cfg->real_offset += 5;
4537
4538                 (*inline_costs) += costs;
4539
4540                 return src;
4541         }
4542
4543         if (context_used) {
4544                 MonoInst *args [3];
4545
4546                 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4547                         MonoInst *cache_ins;
4548
4549                         cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
4550
4551                         /* obj */
4552                         args [0] = src;
4553
4554                         /* klass - it's the second element of the cache entry*/
4555                         EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4556
4557                         /* cache */
4558                         args [2] = cache_ins;
4559
4560                         return emit_castclass_with_cache (cfg, klass, args);
4561                 }
4562
4563                 klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
4564         }
4565
4566         NEW_BBLOCK (cfg, is_null_bb);
4567
4568         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
4569         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, is_null_bb);
4570
4571         save_cast_details (cfg, klass, obj_reg, FALSE);
4572
4573         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
4574                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4575                 mini_emit_iface_cast (cfg, vtable_reg, klass, NULL, NULL);
4576         } else {
4577                 int klass_reg = alloc_preg (cfg);
4578
4579                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4580
4581                 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4582                         /* the remoting code is broken, access the class for now */
4583                         if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4584                                 MonoVTable *vt = mono_class_vtable (cfg->domain, klass);
4585                                 if (!vt) {
4586                                         mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
4587                                         cfg->exception_ptr = klass;
4588                                         return NULL;
4589                                 }
4590                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, vt);
4591                         } else {
4592                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4593                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
4594                         }
4595                         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
4596                 } else {
4597                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4598                         mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, klass_inst, is_null_bb);
4599                 }
4600         }
4601
4602         MONO_START_BB (cfg, is_null_bb);
4603
4604         reset_cast_details (cfg);
4605
4606         return src;
4607
4608 exception_exit:
4609         return NULL;
4610 }
4611
4612 /*
4613  * Returns NULL and set the cfg exception on error.
4614  */
4615 static MonoInst*
4616 handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_used)
4617 {
4618         MonoInst *ins;
4619         MonoBasicBlock *is_null_bb, *false_bb, *end_bb;
4620         int obj_reg = src->dreg;
4621         int vtable_reg = alloc_preg (cfg);
4622         int res_reg = alloc_ireg_ref (cfg);
4623         MonoInst *klass_inst = NULL;
4624
4625         if (context_used) {
4626                 MonoInst *args [3];
4627
4628                 if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
4629                         MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
4630                         MonoInst *cache_ins;
4631
4632                         cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
4633
4634                         /* obj */
4635                         args [0] = src;
4636
4637                         /* klass - it's the second element of the cache entry*/
4638                         EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
4639
4640                         /* cache */
4641                         args [2] = cache_ins;
4642
4643                         return mono_emit_method_call (cfg, mono_isinst, args, NULL);
4644                 }
4645
4646                 klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
4647         }
4648
4649         NEW_BBLOCK (cfg, is_null_bb);
4650         NEW_BBLOCK (cfg, false_bb);
4651         NEW_BBLOCK (cfg, end_bb);
4652
4653         /* Do the assignment at the beginning, so the other assignment can be if converted */
4654         EMIT_NEW_UNALU (cfg, ins, OP_MOVE, res_reg, obj_reg);
4655         ins->type = STACK_OBJ;
4656         ins->klass = klass;
4657
4658         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
4659         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_null_bb);
4660
4661         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4662
4663         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
4664                 g_assert (!context_used);
4665                 /* the is_null_bb target simply copies the input register to the output */
4666                 mini_emit_iface_cast (cfg, vtable_reg, klass, false_bb, is_null_bb);
4667         } else {
4668                 int klass_reg = alloc_preg (cfg);
4669
4670                 if (klass->rank) {
4671                         int rank_reg = alloc_preg (cfg);
4672                         int eclass_reg = alloc_preg (cfg);
4673
4674                         g_assert (!context_used);
4675                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
4676                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
4677                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb);
4678                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4679                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class));
4680                         if (klass->cast_class == mono_defaults.object_class) {
4681                                 int parent_reg = alloc_preg (cfg);
4682                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent));
4683                                 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
4684                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb);
4685                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb);
4686                         } else if (klass->cast_class == mono_defaults.enum_class->parent) {
4687                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
4688                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb);
4689                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb);
4690                         } else if (klass->cast_class == mono_defaults.enum_class) {
4691                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb);
4692                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb);
4693                         } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
4694                                 mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb);
4695                         } else {
4696                                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
4697                                         /* Check that the object is a vector too */
4698                                         int bounds_reg = alloc_preg (cfg);
4699                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg, obj_reg, MONO_STRUCT_OFFSET (MonoArray, bounds));
4700                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, bounds_reg, 0);
4701                                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb);
4702                                 }
4703
4704                                 /* the is_null_bb target simply copies the input register to the output */
4705                                 mini_emit_isninst_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb);
4706                         }
4707                 } else if (mono_class_is_nullable (klass)) {
4708                         g_assert (!context_used);
4709                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4710                         /* the is_null_bb target simply copies the input register to the output */
4711                         mini_emit_isninst_cast (cfg, klass_reg, klass->cast_class, false_bb, is_null_bb);
4712                 } else {
4713                         if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
4714                                 g_assert (!context_used);
4715                                 /* the remoting code is broken, access the class for now */
4716                                 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
4717                                         MonoVTable *vt = mono_class_vtable (cfg->domain, klass);
4718                                         if (!vt) {
4719                                                 mono_cfg_set_exception (cfg, MONO_EXCEPTION_TYPE_LOAD);
4720                                                 cfg->exception_ptr = klass;
4721                                                 return NULL;
4722                                         }
4723                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, vt);
4724                                 } else {
4725                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4726                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
4727                                 }
4728                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb);
4729                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, is_null_bb);
4730                         } else {
4731                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4732                                 /* the is_null_bb target simply copies the input register to the output */
4733                                 mini_emit_isninst_cast_inst (cfg, klass_reg, klass, klass_inst, false_bb, is_null_bb);
4734                         }
4735                 }
4736         }
4737
4738         MONO_START_BB (cfg, false_bb);
4739
4740         MONO_EMIT_NEW_PCONST (cfg, res_reg, 0);
4741         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4742
4743         MONO_START_BB (cfg, is_null_bb);
4744
4745         MONO_START_BB (cfg, end_bb);
4746
4747         return ins;
4748 }
4749
4750 static MonoInst*
4751 handle_cisinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src)
4752 {
4753         /* This opcode takes as input an object reference and a class, and returns:
4754         0) if the object is an instance of the class,
4755         1) if the object is not instance of the class,
4756         2) if the object is a proxy whose type cannot be determined */
4757
4758         MonoInst *ins;
4759 #ifndef DISABLE_REMOTING
4760         MonoBasicBlock *true_bb, *false_bb, *false2_bb, *end_bb, *no_proxy_bb, *interface_fail_bb;
4761 #else
4762         MonoBasicBlock *true_bb, *false_bb, *end_bb;
4763 #endif
4764         int obj_reg = src->dreg;
4765         int dreg = alloc_ireg (cfg);
4766         int tmp_reg;
4767 #ifndef DISABLE_REMOTING
4768         int klass_reg = alloc_preg (cfg);
4769 #endif
4770
4771         NEW_BBLOCK (cfg, true_bb);
4772         NEW_BBLOCK (cfg, false_bb);
4773         NEW_BBLOCK (cfg, end_bb);
4774 #ifndef DISABLE_REMOTING
4775         NEW_BBLOCK (cfg, false2_bb);
4776         NEW_BBLOCK (cfg, no_proxy_bb);
4777 #endif
4778
4779         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
4780         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, false_bb);
4781
4782         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
4783 #ifndef DISABLE_REMOTING
4784                 NEW_BBLOCK (cfg, interface_fail_bb);
4785 #endif
4786
4787                 tmp_reg = alloc_preg (cfg);
4788                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4789 #ifndef DISABLE_REMOTING
4790                 mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, true_bb);
4791                 MONO_START_BB (cfg, interface_fail_bb);
4792                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4793
4794                 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
4795
4796                 tmp_reg = alloc_preg (cfg);
4797                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4798                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
4799                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false2_bb);
4800 #else
4801                 mini_emit_iface_cast (cfg, tmp_reg, klass, false_bb, true_bb);
4802 #endif
4803         } else {
4804 #ifndef DISABLE_REMOTING
4805                 tmp_reg = alloc_preg (cfg);
4806                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4807                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4808
4809                 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4810                 tmp_reg = alloc_preg (cfg);
4811                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4812                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4813
4814                 tmp_reg = alloc_preg (cfg);
4815                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4816                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
4817                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, no_proxy_bb);
4818
4819                 mini_emit_isninst_cast (cfg, klass_reg, klass, false2_bb, true_bb);
4820                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false2_bb);
4821
4822                 MONO_START_BB (cfg, no_proxy_bb);
4823
4824                 mini_emit_isninst_cast (cfg, klass_reg, klass, false_bb, true_bb);
4825 #else
4826                 g_error ("transparent proxy support is disabled while trying to JIT code that uses it");
4827 #endif
4828         }
4829
4830         MONO_START_BB (cfg, false_bb);
4831
4832         MONO_EMIT_NEW_ICONST (cfg, dreg, 1);
4833         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4834
4835 #ifndef DISABLE_REMOTING
4836         MONO_START_BB (cfg, false2_bb);
4837
4838         MONO_EMIT_NEW_ICONST (cfg, dreg, 2);
4839         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4840 #endif
4841
4842         MONO_START_BB (cfg, true_bb);
4843
4844         MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
4845
4846         MONO_START_BB (cfg, end_bb);
4847
4848         /* FIXME: */
4849         MONO_INST_NEW (cfg, ins, OP_ICONST);
4850         ins->dreg = dreg;
4851         ins->type = STACK_I4;
4852
4853         return ins;
4854 }
4855
4856 static MonoInst*
4857 handle_ccastclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src)
4858 {
4859         /* This opcode takes as input an object reference and a class, and returns:
4860         0) if the object is an instance of the class,
4861         1) if the object is a proxy whose type cannot be determined
4862         an InvalidCastException exception is thrown otherwhise*/
4863
4864         MonoInst *ins;
4865 #ifndef DISABLE_REMOTING
4866         MonoBasicBlock *end_bb, *ok_result_bb, *no_proxy_bb, *interface_fail_bb, *fail_1_bb;
4867 #else
4868         MonoBasicBlock *ok_result_bb;
4869 #endif
4870         int obj_reg = src->dreg;
4871         int dreg = alloc_ireg (cfg);
4872         int tmp_reg = alloc_preg (cfg);
4873
4874 #ifndef DISABLE_REMOTING
4875         int klass_reg = alloc_preg (cfg);
4876         NEW_BBLOCK (cfg, end_bb);
4877 #endif
4878
4879         NEW_BBLOCK (cfg, ok_result_bb);
4880
4881         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
4882         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, ok_result_bb);
4883
4884         save_cast_details (cfg, klass, obj_reg, FALSE);
4885
4886         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
4887 #ifndef DISABLE_REMOTING
4888                 NEW_BBLOCK (cfg, interface_fail_bb);
4889
4890                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4891                 mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, ok_result_bb);
4892                 MONO_START_BB (cfg, interface_fail_bb);
4893                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4894
4895                 mini_emit_class_check (cfg, klass_reg, mono_defaults.transparent_proxy_class);
4896
4897                 tmp_reg = alloc_preg (cfg);
4898                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4899                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
4900                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "InvalidCastException");
4901
4902                 MONO_EMIT_NEW_ICONST (cfg, dreg, 1);
4903                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4904 #else
4905                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4906                 mini_emit_iface_cast (cfg, tmp_reg, klass, NULL, NULL);
4907                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, ok_result_bb);
4908 #endif
4909         } else {
4910 #ifndef DISABLE_REMOTING
4911                 NEW_BBLOCK (cfg, no_proxy_bb);
4912
4913                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
4914                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoVTable, klass));
4915                 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
4916
4917                 tmp_reg = alloc_preg (cfg);
4918                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
4919                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, MONO_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
4920
4921                 tmp_reg = alloc_preg (cfg);
4922                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, MONO_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
4923                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
4924                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, no_proxy_bb);
4925
4926                 NEW_BBLOCK (cfg, fail_1_bb);
4927
4928                 mini_emit_isninst_cast (cfg, klass_reg, klass, fail_1_bb, ok_result_bb);
4929
4930                 MONO_START_BB (cfg, fail_1_bb);
4931
4932                 MONO_EMIT_NEW_ICONST (cfg, dreg, 1);
4933                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4934
4935                 MONO_START_BB (cfg, no_proxy_bb);
4936
4937                 mini_emit_castclass (cfg, obj_reg, klass_reg, klass, ok_result_bb);
4938 #else
4939                 g_error ("Transparent proxy support is disabled while trying to JIT code that uses it");
4940 #endif
4941         }
4942
4943         MONO_START_BB (cfg, ok_result_bb);
4944
4945         MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
4946
4947 #ifndef DISABLE_REMOTING
4948         MONO_START_BB (cfg, end_bb);
4949 #endif
4950
4951         /* FIXME: */
4952         MONO_INST_NEW (cfg, ins, OP_ICONST);
4953         ins->dreg = dreg;
4954         ins->type = STACK_I4;
4955
4956         return ins;
4957 }
4958
4959 static G_GNUC_UNUSED MonoInst*
4960 handle_enum_has_flag (MonoCompile *cfg, MonoClass *klass, MonoInst *enum_this, MonoInst *enum_flag)
4961 {
4962         MonoType *enum_type = mono_type_get_underlying_type (&klass->byval_arg);
4963         guint32 load_opc = mono_type_to_load_membase (cfg, enum_type);
4964         gboolean is_i4;
4965
4966         switch (enum_type->type) {
4967         case MONO_TYPE_I8:
4968         case MONO_TYPE_U8:
4969 #if SIZEOF_REGISTER == 8
4970         case MONO_TYPE_I:
4971         case MONO_TYPE_U:
4972 #endif
4973                 is_i4 = FALSE;
4974                 break;
4975         default:
4976                 is_i4 = TRUE;
4977                 break;
4978         }
4979
4980         {
4981                 MonoInst *load, *and_, *cmp, *ceq;
4982                 int enum_reg = is_i4 ? alloc_ireg (cfg) : alloc_lreg (cfg);
4983                 int and_reg = is_i4 ? alloc_ireg (cfg) : alloc_lreg (cfg);
4984                 int dest_reg = alloc_ireg (cfg);
4985
4986                 EMIT_NEW_LOAD_MEMBASE (cfg, load, load_opc, enum_reg, enum_this->dreg, 0);
4987                 EMIT_NEW_BIALU (cfg, and_, is_i4 ? OP_IAND : OP_LAND, and_reg, enum_reg, enum_flag->dreg);
4988                 EMIT_NEW_BIALU (cfg, cmp, is_i4 ? OP_ICOMPARE : OP_LCOMPARE, -1, and_reg, enum_flag->dreg);
4989                 EMIT_NEW_UNALU (cfg, ceq, is_i4 ? OP_ICEQ : OP_LCEQ, dest_reg, -1);
4990
4991                 ceq->type = STACK_I4;
4992
4993                 if (!is_i4) {
4994                         load = mono_decompose_opcode (cfg, load);
4995                         and_ = mono_decompose_opcode (cfg, and_);
4996                         cmp = mono_decompose_opcode (cfg, cmp);
4997                         ceq = mono_decompose_opcode (cfg, ceq);
4998                 }
4999
5000                 return ceq;
5001         }
5002 }
5003
5004 /*
5005  * Returns NULL and set the cfg exception on error.
5006  */
5007 static G_GNUC_UNUSED MonoInst*
5008 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used, gboolean virtual_)
5009 {
5010         MonoInst *ptr;
5011         int dreg;
5012         gpointer trampoline;
5013         MonoInst *obj, *method_ins, *tramp_ins;
5014         MonoDomain *domain;
5015         guint8 **code_slot;
5016
5017         if (virtual_ && !cfg->llvm_only) {
5018                 MonoMethod *invoke = mono_get_delegate_invoke (klass);
5019                 g_assert (invoke);
5020
5021                 if (!mono_get_delegate_virtual_invoke_impl (mono_method_signature (invoke), context_used ? NULL : method))
5022                         return NULL;
5023         }
5024
5025         obj = handle_alloc (cfg, klass, FALSE, mono_class_check_context_used (klass));
5026         if (!obj)
5027                 return NULL;
5028
5029         /* Inline the contents of mono_delegate_ctor */
5030
5031         /* Set target field */
5032         /* Optimize away setting of NULL target */
5033         if (!(target->opcode == OP_PCONST && target->inst_p0 == 0)) {
5034                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
5035                 if (cfg->gen_write_barriers) {
5036                         dreg = alloc_preg (cfg);
5037                         EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, target));
5038                         emit_write_barrier (cfg, ptr, target);
5039                 }
5040         }
5041
5042         /* Set method field */
5043         method_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD);
5044         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
5045
5046         /*
5047          * To avoid looking up the compiled code belonging to the target method
5048          * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
5049          * store it, and we fill it after the method has been compiled.
5050          */
5051         if (!method->dynamic && !(cfg->opt & MONO_OPT_SHARED)) {
5052                 MonoInst *code_slot_ins;
5053
5054                 if (context_used) {
5055                         code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
5056                 } else {
5057                         domain = mono_domain_get ();
5058                         mono_domain_lock (domain);
5059                         if (!domain_jit_info (domain)->method_code_hash)
5060                                 domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL);
5061                         code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
5062                         if (!code_slot) {
5063                                 code_slot = (guint8 **)mono_domain_alloc0 (domain, sizeof (gpointer));
5064                                 g_hash_table_insert (domain_jit_info (domain)->method_code_hash, method, code_slot);
5065                         }
5066                         mono_domain_unlock (domain);
5067
5068                         code_slot_ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_METHOD_CODE_SLOT, method);
5069                 }
5070                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
5071         }
5072
5073         if (cfg->llvm_only) {
5074                 MonoInst *args [16];
5075
5076                 if (virtual_) {
5077                         args [0] = obj;
5078                         args [1] = target;
5079                         args [2] = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD);
5080                         mono_emit_jit_icall (cfg, mono_llvmonly_init_delegate_virtual, args);
5081                 } else {
5082                         args [0] = obj;
5083                         mono_emit_jit_icall (cfg, mono_llvmonly_init_delegate, args);
5084                 }
5085
5086                 return obj;
5087         }
5088
5089         if (cfg->compile_aot) {
5090                 MonoDelegateClassMethodPair *del_tramp;
5091
5092                 del_tramp = (MonoDelegateClassMethodPair *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoDelegateClassMethodPair));
5093                 del_tramp->klass = klass;
5094                 del_tramp->method = context_used ? NULL : method;
5095                 del_tramp->is_virtual = virtual_;
5096                 EMIT_NEW_AOTCONST (cfg, tramp_ins, MONO_PATCH_INFO_DELEGATE_TRAMPOLINE, del_tramp);
5097         } else {
5098                 if (virtual_)
5099                         trampoline = mono_create_delegate_virtual_trampoline (cfg->domain, klass, context_used ? NULL : method);
5100                 else
5101                         trampoline = mono_create_delegate_trampoline_info (cfg->domain, klass, context_used ? NULL : method);
5102                 EMIT_NEW_PCONST (cfg, tramp_ins, trampoline);
5103         }
5104
5105         /* Set invoke_impl field */
5106         if (virtual_) {
5107                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
5108         } else {
5109                 dreg = alloc_preg (cfg);
5110                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, invoke_impl));
5111                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl), dreg);
5112
5113                 dreg = alloc_preg (cfg);
5114                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, tramp_ins->dreg, MONO_STRUCT_OFFSET (MonoDelegateTrampInfo, method_ptr));
5115                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr), dreg);
5116         }
5117
5118         dreg = alloc_preg (cfg);
5119         MONO_EMIT_NEW_ICONST (cfg, dreg, virtual_ ? 1 : 0);
5120         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, obj->dreg, MONO_STRUCT_OFFSET (MonoDelegate, method_is_virtual), dreg);
5121
5122         /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
5123
5124         return obj;
5125 }
5126
5127 static MonoInst*
5128 handle_array_new (MonoCompile *cfg, int rank, MonoInst **sp, unsigned char *ip)
5129 {
5130         MonoJitICallInfo *info;
5131
5132         /* Need to register the icall so it gets an icall wrapper */
5133         info = mono_get_array_new_va_icall (rank);
5134
5135         cfg->flags |= MONO_CFG_HAS_VARARGS;
5136
5137         /* mono_array_new_va () needs a vararg calling convention */
5138         cfg->exception_message = g_strdup ("array-new");
5139         cfg->disable_llvm = TRUE;
5140
5141         /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
5142         return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, sp);
5143 }
5144
5145 /*
5146  * handle_constrained_gsharedvt_call:
5147  *
5148  *   Handle constrained calls where the receiver is a gsharedvt type.
5149  * Return the instruction representing the call. Set the cfg exception on failure.
5150  */
5151 static MonoInst*
5152 handle_constrained_gsharedvt_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp, MonoClass *constrained_class,
5153                                                                    gboolean *ref_emit_widen)
5154 {
5155         MonoInst *ins = NULL;
5156         gboolean emit_widen = *ref_emit_widen;
5157
5158         /*
5159          * Constrained calls need to behave differently at runtime dependending on whenever the receiver is instantiated as ref type or as a vtype.
5160          * This is hard to do with the current call code, since we would have to emit a branch and two different calls. So instead, we
5161          * pack the arguments into an array, and do the rest of the work in in an icall.
5162          */
5163         if (((cmethod->klass == mono_defaults.object_class) || (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) || (!cmethod->klass->valuetype && cmethod->klass->image != mono_defaults.corlib)) &&
5164                 (MONO_TYPE_IS_VOID (fsig->ret) || MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_IS_REFERENCE (fsig->ret) || MONO_TYPE_ISSTRUCT (fsig->ret) || mini_is_gsharedvt_type (fsig->ret)) &&
5165                 (fsig->param_count == 0 || (!fsig->hasthis && fsig->param_count == 1) || (fsig->param_count == 1 && (MONO_TYPE_IS_REFERENCE (fsig->params [0]) || fsig->params [0]->byref || mini_is_gsharedvt_type (fsig->params [0]))))) {
5166                 MonoInst *args [16];
5167
5168                 /*
5169                  * This case handles calls to
5170                  * - object:ToString()/Equals()/GetHashCode(),
5171                  * - System.IComparable<T>:CompareTo()
5172                  * - System.IEquatable<T>:Equals ()
5173                  * plus some simple interface calls enough to support AsyncTaskMethodBuilder.
5174                  */
5175
5176                 args [0] = sp [0];
5177                 if (mono_method_check_context_used (cmethod))
5178                         args [1] = emit_get_rgctx_method (cfg, mono_method_check_context_used (cmethod), cmethod, MONO_RGCTX_INFO_METHOD);
5179                 else
5180                         EMIT_NEW_METHODCONST (cfg, args [1], cmethod);
5181                 args [2] = emit_get_rgctx_klass (cfg, mono_class_check_context_used (constrained_class), constrained_class, MONO_RGCTX_INFO_KLASS);
5182
5183                 /* !fsig->hasthis is for the wrapper for the Object.GetType () icall */
5184                 if (fsig->hasthis && fsig->param_count) {
5185                         /* Pass the arguments using a localloc-ed array using the format expected by runtime_invoke () */
5186                         MONO_INST_NEW (cfg, ins, OP_LOCALLOC_IMM);
5187                         ins->dreg = alloc_preg (cfg);
5188                         ins->inst_imm = fsig->param_count * sizeof (mgreg_t);
5189                         MONO_ADD_INS (cfg->cbb, ins);
5190                         args [4] = ins;
5191
5192                         if (mini_is_gsharedvt_type (fsig->params [0])) {
5193                                 int addr_reg, deref_arg_reg;
5194
5195                                 ins = emit_get_gsharedvt_info_klass (cfg, mono_class_from_mono_type (fsig->params [0]), MONO_RGCTX_INFO_CLASS_BOX_TYPE);
5196                                 deref_arg_reg = alloc_preg (cfg);
5197                                 /* deref_arg = BOX_TYPE != MONO_GSHAREDVT_BOX_TYPE_VTYPE */
5198                                 EMIT_NEW_BIALU_IMM (cfg, args [3], OP_ISUB_IMM, deref_arg_reg, ins->dreg, 1);
5199
5200                                 EMIT_NEW_VARLOADA_VREG (cfg, ins, sp [1]->dreg, fsig->params [0]);
5201                                 addr_reg = ins->dreg;
5202                                 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, args [4]->dreg, 0, addr_reg);
5203                         } else {
5204                                 EMIT_NEW_ICONST (cfg, args [3], 0);
5205                                 EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STORE_MEMBASE_REG, args [4]->dreg, 0, sp [1]->dreg);
5206                         }
5207                 } else {
5208                         EMIT_NEW_ICONST (cfg, args [3], 0);
5209                         EMIT_NEW_ICONST (cfg, args [4], 0);
5210                 }
5211                 ins = mono_emit_jit_icall (cfg, mono_gsharedvt_constrained_call, args);
5212                 emit_widen = FALSE;
5213
5214                 if (mini_is_gsharedvt_type (fsig->ret)) {
5215                         ins = handle_unbox_gsharedvt (cfg, mono_class_from_mono_type (fsig->ret), ins);
5216                 } else if (MONO_TYPE_IS_PRIMITIVE (fsig->ret) || MONO_TYPE_ISSTRUCT (fsig->ret)) {
5217                         MonoInst *add;
5218
5219                         /* Unbox */
5220                         NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_MP), ins->dreg, sizeof (MonoObject));
5221                         MONO_ADD_INS (cfg->cbb, add);
5222                         /* Load value */
5223                         NEW_LOAD_MEMBASE_TYPE (cfg, ins, fsig->ret, add->dreg, 0);
5224                         MONO_ADD_INS (cfg->cbb, ins);
5225                         /* ins represents the call result */
5226                 }
5227         } else {
5228                 GSHAREDVT_FAILURE (CEE_CALLVIRT);
5229         }
5230
5231         *ref_emit_widen = emit_widen;
5232
5233         return ins;
5234
5235  exception_exit:
5236         return NULL;
5237 }
5238
5239 static void
5240 mono_emit_load_got_addr (MonoCompile *cfg)
5241 {
5242         MonoInst *getaddr, *dummy_use;
5243
5244         if (!cfg->got_var || cfg->got_var_allocated)
5245                 return;
5246
5247         MONO_INST_NEW (cfg, getaddr, OP_LOAD_GOTADDR);
5248         getaddr->cil_code = cfg->header->code;
5249         getaddr->dreg = cfg->got_var->dreg;
5250
5251         /* Add it to the start of the first bblock */
5252         if (cfg->bb_entry->code) {
5253                 getaddr->next = cfg->bb_entry->code;
5254                 cfg->bb_entry->code = getaddr;
5255         }
5256         else
5257                 MONO_ADD_INS (cfg->bb_entry, getaddr);
5258
5259         cfg->got_var_allocated = TRUE;
5260
5261         /*
5262          * Add a dummy use to keep the got_var alive, since real uses might
5263          * only be generated by the back ends.
5264          * Add it to end_bblock, so the variable's lifetime covers the whole
5265          * method.
5266          * It would be better to make the usage of the got var explicit in all
5267          * cases when the backend needs it (i.e. calls, throw etc.), so this
5268          * wouldn't be needed.
5269          */
5270         NEW_DUMMY_USE (cfg, dummy_use, cfg->got_var);
5271         MONO_ADD_INS (cfg->bb_exit, dummy_use);
5272 }
5273
5274 static int inline_limit;
5275 static gboolean inline_limit_inited;
5276
5277 static gboolean
5278 mono_method_check_inlining (MonoCompile *cfg, MonoMethod *method)
5279 {
5280         MonoMethodHeaderSummary header;
5281         MonoVTable *vtable;
5282 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5283         MonoMethodSignature *sig = mono_method_signature (method);
5284         int i;
5285 #endif
5286
5287         if (cfg->disable_inline)
5288                 return FALSE;
5289         if (cfg->gshared)
5290                 return FALSE;
5291
5292         if (cfg->inline_depth > 10)
5293                 return FALSE;
5294
5295         if (!mono_method_get_header_summary (method, &header))
5296                 return FALSE;
5297
5298         /*runtime, icall and pinvoke are checked by summary call*/
5299         if ((method->iflags & METHOD_IMPL_ATTRIBUTE_NOINLINING) ||
5300             (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) ||
5301             (mono_class_is_marshalbyref (method->klass)) ||
5302             header.has_clauses)
5303                 return FALSE;
5304
5305         /* also consider num_locals? */
5306         /* Do the size check early to avoid creating vtables */
5307         if (!inline_limit_inited) {
5308                 if (g_getenv ("MONO_INLINELIMIT"))
5309                         inline_limit = atoi (g_getenv ("MONO_INLINELIMIT"));
5310                 else
5311                         inline_limit = INLINE_LENGTH_LIMIT;
5312                 inline_limit_inited = TRUE;
5313         }
5314         if (header.code_size >= inline_limit && !(method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))
5315                 return FALSE;
5316
5317         /*
5318          * if we can initialize the class of the method right away, we do,
5319          * otherwise we don't allow inlining if the class needs initialization,
5320          * since it would mean inserting a call to mono_runtime_class_init()
5321          * inside the inlined code
5322          */
5323         if (!(cfg->opt & MONO_OPT_SHARED)) {
5324                 /* The AggressiveInlining hint is a good excuse to force that cctor to run. */
5325                 if (method->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING) {
5326                         vtable = mono_class_vtable (cfg->domain, method->klass);
5327                         if (!vtable)
5328                                 return FALSE;
5329                         if (!cfg->compile_aot) {
5330                                 MonoError error;
5331                                 if (!mono_runtime_class_init_full (vtable, &error))
5332                                         mono_error_raise_exception (&error); /* FIXME don't raise here */
5333                         }
5334                 } else if (method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT) {
5335                         if (cfg->run_cctors && method->klass->has_cctor) {
5336                                 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
5337                                 if (!method->klass->runtime_info)
5338                                         /* No vtable created yet */
5339                                         return FALSE;
5340                                 vtable = mono_class_vtable (cfg->domain, method->klass);
5341                                 if (!vtable)
5342                                         return FALSE;
5343                                 /* This makes so that inline cannot trigger */
5344                                 /* .cctors: too many apps depend on them */
5345                                 /* running with a specific order... */
5346                                 if (! vtable->initialized)
5347                                         return FALSE;
5348                                 MonoError error;
5349                                 if (!mono_runtime_class_init_full (vtable, &error))
5350                                         mono_error_raise_exception (&error); /* FIXME don't raise here */
5351                         }
5352                 } else if (mono_class_needs_cctor_run (method->klass, NULL)) {
5353                         if (!method->klass->runtime_info)
5354                                 /* No vtable created yet */
5355                                 return FALSE;
5356                         vtable = mono_class_vtable (cfg->domain, method->klass);
5357                         if (!vtable)
5358                                 return FALSE;
5359                         if (!vtable->initialized)
5360                                 return FALSE;
5361                 }
5362         } else {
5363                 /*
5364                  * If we're compiling for shared code
5365                  * the cctor will need to be run at aot method load time, for example,
5366                  * or at the end of the compilation of the inlining method.
5367                  */
5368                 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
5369                         return FALSE;
5370         }
5371
5372 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
5373         if (mono_arch_is_soft_float ()) {
5374                 /* FIXME: */
5375                 if (sig->ret && sig->ret->type == MONO_TYPE_R4)
5376                         return FALSE;
5377                 for (i = 0; i < sig->param_count; ++i)
5378                         if (!sig->params [i]->byref && sig->params [i]->type == MONO_TYPE_R4)
5379                                 return FALSE;
5380         }
5381 #endif
5382
5383         if (g_list_find (cfg->dont_inline, method))
5384                 return FALSE;
5385
5386         return TRUE;
5387 }
5388
5389 static gboolean
5390 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoClass *klass, MonoVTable *vtable)
5391 {
5392         if (!cfg->compile_aot) {
5393                 g_assert (vtable);
5394                 if (vtable->initialized)
5395                         return FALSE;
5396         }
5397
5398         if (klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT) {
5399                 if (cfg->method == method)
5400                         return FALSE;
5401         }
5402
5403         if (!mono_class_needs_cctor_run (klass, method))
5404                 return FALSE;
5405
5406         if (! (method->flags & METHOD_ATTRIBUTE_STATIC) && (klass == method->klass))
5407                 /* The initialization is already done before the method is called */
5408                 return FALSE;
5409
5410         return TRUE;
5411 }
5412
5413 static MonoInst*
5414 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
5415 {
5416         MonoInst *ins;
5417         guint32 size;
5418         int mult_reg, add_reg, array_reg, index_reg, index2_reg;
5419         int context_used;
5420
5421         if (mini_is_gsharedvt_variable_klass (klass)) {
5422                 size = -1;
5423         } else {
5424                 mono_class_init (klass);
5425                 size = mono_class_array_element_size (klass);
5426         }
5427
5428         mult_reg = alloc_preg (cfg);
5429         array_reg = arr->dreg;
5430         index_reg = index->dreg;
5431
5432 #if SIZEOF_REGISTER == 8
5433         /* The array reg is 64 bits but the index reg is only 32 */
5434         if (COMPILE_LLVM (cfg)) {
5435                 /* Not needed */
5436                 index2_reg = index_reg;
5437         } else {
5438                 index2_reg = alloc_preg (cfg);
5439                 MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, index2_reg, index_reg);
5440         }
5441 #else
5442         if (index->type == STACK_I8) {
5443                 index2_reg = alloc_preg (cfg);
5444                 MONO_EMIT_NEW_UNALU (cfg, OP_LCONV_TO_I4, index2_reg, index_reg);
5445         } else {
5446                 index2_reg = index_reg;
5447         }
5448 #endif
5449
5450         if (bcheck)
5451                 MONO_EMIT_BOUNDS_CHECK (cfg, array_reg, MonoArray, max_length, index2_reg);
5452
5453 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5454         if (size == 1 || size == 2 || size == 4 || size == 8) {
5455                 static const int fast_log2 [] = { 1, 0, 1, -1, 2, -1, -1, -1, 3 };
5456
5457                 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], MONO_STRUCT_OFFSET (MonoArray, vector));
5458                 ins->klass = mono_class_get_element_class (klass);
5459                 ins->type = STACK_MP;
5460
5461                 return ins;
5462         }
5463 #endif
5464
5465         add_reg = alloc_ireg_mp (cfg);
5466
5467         if (size == -1) {
5468                 MonoInst *rgctx_ins;
5469
5470                 /* gsharedvt */
5471                 g_assert (cfg->gshared);
5472                 context_used = mini_class_check_context_used (cfg, klass);
5473                 g_assert (context_used);
5474                 rgctx_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE);
5475                 MONO_EMIT_NEW_BIALU (cfg, OP_IMUL, mult_reg, index2_reg, rgctx_ins->dreg);
5476         } else {
5477                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_MUL_IMM, mult_reg, index2_reg, size);
5478         }
5479         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, array_reg, mult_reg);
5480         NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5481         ins->klass = mono_class_get_element_class (klass);
5482         ins->type = STACK_MP;
5483         MONO_ADD_INS (cfg->cbb, ins);
5484
5485         return ins;
5486 }
5487
5488 static MonoInst*
5489 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
5490 {
5491         int bounds_reg = alloc_preg (cfg);
5492         int add_reg = alloc_ireg_mp (cfg);
5493         int mult_reg = alloc_preg (cfg);
5494         int mult2_reg = alloc_preg (cfg);
5495         int low1_reg = alloc_preg (cfg);
5496         int low2_reg = alloc_preg (cfg);
5497         int high1_reg = alloc_preg (cfg);
5498         int high2_reg = alloc_preg (cfg);
5499         int realidx1_reg = alloc_preg (cfg);
5500         int realidx2_reg = alloc_preg (cfg);
5501         int sum_reg = alloc_preg (cfg);
5502         int index1, index2, tmpreg;
5503         MonoInst *ins;
5504         guint32 size;
5505
5506         mono_class_init (klass);
5507         size = mono_class_array_element_size (klass);
5508
5509         index1 = index_ins1->dreg;
5510         index2 = index_ins2->dreg;
5511
5512 #if SIZEOF_REGISTER == 8
5513         /* The array reg is 64 bits but the index reg is only 32 */
5514         if (COMPILE_LLVM (cfg)) {
5515                 /* Not needed */
5516         } else {
5517                 tmpreg = alloc_preg (cfg);
5518                 MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, tmpreg, index1);
5519                 index1 = tmpreg;
5520                 tmpreg = alloc_preg (cfg);
5521                 MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, tmpreg, index2);
5522                 index2 = tmpreg;
5523         }
5524 #else
5525         // FIXME: Do we need to do something here for i8 indexes, like in ldelema_1_ins ?
5526         tmpreg = -1;
5527 #endif
5528
5529         /* range checking */
5530         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg,
5531                                        arr->dreg, MONO_STRUCT_OFFSET (MonoArray, bounds));
5532
5533         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, low1_reg,
5534                                        bounds_reg, MONO_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
5535         MONO_EMIT_NEW_BIALU (cfg, OP_PSUB, realidx1_reg, index1, low1_reg);
5536         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, high1_reg,
5537                                        bounds_reg, MONO_STRUCT_OFFSET (MonoArrayBounds, length));
5538         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, high1_reg, realidx1_reg);
5539         MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException");
5540
5541         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, low2_reg,
5542                                        bounds_reg, sizeof (MonoArrayBounds) + MONO_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
5543         MONO_EMIT_NEW_BIALU (cfg, OP_PSUB, realidx2_reg, index2, low2_reg);
5544         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, high2_reg,
5545                                        bounds_reg, sizeof (MonoArrayBounds) + MONO_STRUCT_OFFSET (MonoArrayBounds, length));
5546         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, high2_reg, realidx2_reg);
5547         MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException");
5548
5549         MONO_EMIT_NEW_BIALU (cfg, OP_PMUL, mult_reg, high2_reg, realidx1_reg);
5550         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, sum_reg, mult_reg, realidx2_reg);
5551         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PMUL_IMM, mult2_reg, sum_reg, size);
5552         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, mult2_reg, arr->dreg);
5553         NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, MONO_STRUCT_OFFSET (MonoArray, vector));
5554
5555         ins->type = STACK_MP;
5556         ins->klass = klass;
5557         MONO_ADD_INS (cfg->cbb, ins);
5558
5559         return ins;
5560 }
5561
5562 static MonoInst*
5563 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
5564 {
5565         int rank;
5566         MonoInst *addr;
5567         MonoMethod *addr_method;
5568         int element_size;
5569         MonoClass *eclass = cmethod->klass->element_class;
5570
5571         rank = mono_method_signature (cmethod)->param_count - (is_set? 1: 0);
5572
5573         if (rank == 1)
5574                 return mini_emit_ldelema_1_ins (cfg, eclass, sp [0], sp [1], TRUE);
5575
5576         /* emit_ldelema_2 depends on OP_LMUL */
5577         if (!cfg->backend->emulate_mul_div && rank == 2 && (cfg->opt & MONO_OPT_INTRINS) && !mini_is_gsharedvt_variable_klass (eclass)) {
5578                 return mini_emit_ldelema_2_ins (cfg, eclass, sp [0], sp [1], sp [2]);
5579         }
5580
5581         if (mini_is_gsharedvt_variable_klass (eclass))
5582                 element_size = 0;
5583         else
5584                 element_size = mono_class_array_element_size (eclass);
5585         addr_method = mono_marshal_get_array_address (rank, element_size);
5586         addr = mono_emit_method_call (cfg, addr_method, sp, NULL);
5587
5588         return addr;
5589 }
5590
5591 static MonoBreakPolicy
5592 always_insert_breakpoint (MonoMethod *method)
5593 {
5594         return MONO_BREAK_POLICY_ALWAYS;
5595 }
5596
5597 static MonoBreakPolicyFunc break_policy_func = always_insert_breakpoint;
5598
5599 /**
5600  * mono_set_break_policy:
5601  * policy_callback: the new callback function
5602  *
5603  * Allow embedders to decide wherther to actually obey breakpoint instructions
5604  * (both break IL instructions and Debugger.Break () method calls), for example
5605  * to not allow an app to be aborted by a perfectly valid IL opcode when executing
5606  * untrusted or semi-trusted code.
5607  *
5608  * @policy_callback will be called every time a break point instruction needs to
5609  * be inserted with the method argument being the method that calls Debugger.Break()
5610  * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
5611  * if it wants the breakpoint to not be effective in the given method.
5612  * #MONO_BREAK_POLICY_ALWAYS is the default.
5613  */
5614 void
5615 mono_set_break_policy (MonoBreakPolicyFunc policy_callback)
5616 {
5617         if (policy_callback)
5618                 break_policy_func = policy_callback;
5619         else
5620                 break_policy_func = always_insert_breakpoint;
5621 }
5622
5623 static gboolean
5624 should_insert_brekpoint (MonoMethod *method) {
5625         switch (break_policy_func (method)) {
5626         case MONO_BREAK_POLICY_ALWAYS:
5627                 return TRUE;
5628         case MONO_BREAK_POLICY_NEVER:
5629                 return FALSE;
5630         case MONO_BREAK_POLICY_ON_DBG:
5631                 g_warning ("mdb no longer supported");
5632                 return FALSE;
5633         default:
5634                 g_warning ("Incorrect value returned from break policy callback");
5635                 return FALSE;
5636         }
5637 }
5638
5639 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
5640 static MonoInst*
5641 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5642 {
5643         MonoInst *addr, *store, *load;
5644         MonoClass *eklass = mono_class_from_mono_type (fsig->params [2]);
5645
5646         /* the bounds check is already done by the callers */
5647         addr = mini_emit_ldelema_1_ins (cfg, eklass, args [0], args [1], FALSE);
5648         if (is_set) {
5649                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, &eklass->byval_arg, args [2]->dreg, 0);
5650                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, &eklass->byval_arg, addr->dreg, 0, load->dreg);
5651                 if (mini_type_is_reference (fsig->params [2]))
5652                         emit_write_barrier (cfg, addr, load);
5653         } else {
5654                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, &eklass->byval_arg, addr->dreg, 0);
5655                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, &eklass->byval_arg, args [2]->dreg, 0, load->dreg);
5656         }
5657         return store;
5658 }
5659
5660
5661 static gboolean
5662 generic_class_is_reference_type (MonoCompile *cfg, MonoClass *klass)
5663 {
5664         return mini_type_is_reference (&klass->byval_arg);
5665 }
5666
5667 static MonoInst*
5668 emit_array_store (MonoCompile *cfg, MonoClass *klass, MonoInst **sp, gboolean safety_checks)
5669 {
5670         if (safety_checks && generic_class_is_reference_type (cfg, klass) &&
5671                 !(sp [2]->opcode == OP_PCONST && sp [2]->inst_p0 == NULL)) {
5672                 MonoClass *obj_array = mono_array_class_get_cached (mono_defaults.object_class, 1);
5673                 MonoMethod *helper = mono_marshal_get_virtual_stelemref (obj_array);
5674                 MonoInst *iargs [3];
5675
5676                 if (!helper->slot)
5677                         mono_class_setup_vtable (obj_array);
5678                 g_assert (helper->slot);
5679
5680                 if (sp [0]->type != STACK_OBJ)
5681                         return NULL;
5682                 if (sp [2]->type != STACK_OBJ)
5683                         return NULL;
5684
5685                 iargs [2] = sp [2];
5686                 iargs [1] = sp [1];
5687                 iargs [0] = sp [0];
5688
5689                 return mono_emit_method_call (cfg, helper, iargs, sp [0]);
5690         } else {
5691                 MonoInst *ins;
5692
5693                 if (mini_is_gsharedvt_variable_klass (klass)) {
5694                         MonoInst *addr;
5695
5696                         // FIXME-VT: OP_ICONST optimization
5697                         addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
5698                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0, sp [2]->dreg);
5699                         ins->opcode = OP_STOREV_MEMBASE;
5700                 } else if (sp [1]->opcode == OP_ICONST) {
5701                         int array_reg = sp [0]->dreg;
5702                         int index_reg = sp [1]->dreg;
5703                         int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
5704
5705                         if (SIZEOF_REGISTER == 8 && COMPILE_LLVM (cfg))
5706                                 MONO_EMIT_NEW_UNALU (cfg, OP_ZEXT_I4, index_reg, index_reg);
5707
5708                         if (safety_checks)
5709                                 MONO_EMIT_BOUNDS_CHECK (cfg, array_reg, MonoArray, max_length, index_reg);
5710                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, array_reg, offset, sp [2]->dreg);
5711                 } else {
5712                         MonoInst *addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], safety_checks);
5713                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0, sp [2]->dreg);
5714                         if (generic_class_is_reference_type (cfg, klass))
5715                                 emit_write_barrier (cfg, addr, sp [2]);
5716                 }
5717                 return ins;
5718         }
5719 }
5720
5721 static MonoInst*
5722 emit_array_unsafe_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
5723 {
5724         MonoClass *eklass;
5725
5726         if (is_set)
5727                 eklass = mono_class_from_mono_type (fsig->params [2]);
5728         else
5729                 eklass = mono_class_from_mono_type (fsig->ret);
5730
5731         if (is_set) {
5732                 return emit_array_store (cfg, eklass, args, FALSE);
5733         } else {
5734                 MonoInst *ins, *addr = mini_emit_ldelema_1_ins (cfg, eklass, args [0], args [1], FALSE);
5735                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &eklass->byval_arg, addr->dreg, 0);
5736                 return ins;
5737         }
5738 }
5739
5740 static gboolean
5741 is_unsafe_mov_compatible (MonoCompile *cfg, MonoClass *param_klass, MonoClass *return_klass)
5742 {
5743         uint32_t align;
5744         int param_size, return_size;
5745
5746         param_klass = mono_class_from_mono_type (mini_get_underlying_type (&param_klass->byval_arg));
5747         return_klass = mono_class_from_mono_type (mini_get_underlying_type (&return_klass->byval_arg));
5748
5749         if (cfg->verbose_level > 3)
5750                 printf ("[UNSAFE-MOV-INTRISIC] %s <- %s\n", return_klass->name, param_klass->name);
5751
5752         //Don't allow mixing reference types with value types
5753         if (param_klass->valuetype != return_klass->valuetype) {
5754                 if (cfg->verbose_level > 3)
5755                         printf ("[UNSAFE-MOV-INTRISIC]\tone of the args is a valuetype and the other is not\n");
5756                 return FALSE;
5757         }
5758
5759         if (!param_klass->valuetype) {
5760                 if (cfg->verbose_level > 3)
5761                         printf ("[UNSAFE-MOV-INTRISIC]\targs are reference types\n");
5762                 return TRUE;
5763         }
5764
5765         //That are blitable
5766         if (param_klass->has_references || return_klass->has_references)
5767                 return FALSE;
5768
5769         /* Avoid mixing structs and primitive types/enums, they need to be handled differently in the JIT */
5770         if ((MONO_TYPE_ISSTRUCT (&param_klass->byval_arg) && !MONO_TYPE_ISSTRUCT (&return_klass->byval_arg)) ||
5771                 (!MONO_TYPE_ISSTRUCT (&param_klass->byval_arg) && MONO_TYPE_ISSTRUCT (&return_klass->byval_arg))) {
5772                         if (cfg->verbose_level > 3)
5773                                 printf ("[UNSAFE-MOV-INTRISIC]\tmixing structs and scalars\n");
5774                 return FALSE;
5775         }
5776
5777         if (param_klass->byval_arg.type == MONO_TYPE_R4 || param_klass->byval_arg.type == MONO_TYPE_R8 ||
5778                 return_klass->byval_arg.type == MONO_TYPE_R4 || return_klass->byval_arg.type == MONO_TYPE_R8) {
5779                 if (cfg->verbose_level > 3)
5780                         printf ("[UNSAFE-MOV-INTRISIC]\tfloat or double are not supported\n");
5781                 return FALSE;
5782         }
5783
5784         param_size = mono_class_value_size (param_klass, &align);
5785         return_size = mono_class_value_size (return_klass, &align);
5786
5787         //We can do it if sizes match
5788         if (param_size == return_size) {
5789                 if (cfg->verbose_level > 3)
5790                         printf ("[UNSAFE-MOV-INTRISIC]\tsame size\n");
5791                 return TRUE;
5792         }
5793
5794         //No simple way to handle struct if sizes don't match
5795         if (MONO_TYPE_ISSTRUCT (&param_klass->byval_arg)) {
5796                 if (cfg->verbose_level > 3)
5797                         printf ("[UNSAFE-MOV-INTRISIC]\tsize mismatch and type is a struct\n");
5798                 return FALSE;
5799         }
5800
5801         /*
5802          * Same reg size category.
5803          * A quick note on why we don't require widening here.
5804          * The intrinsic is "R Array.UnsafeMov<S,R> (S s)".
5805          *
5806          * Since the source value comes from a function argument, the JIT will already have
5807          * the value in a VREG and performed any widening needed before (say, when loading from a field).
5808          */
5809         if (param_size <= 4 && return_size <= 4) {
5810                 if (cfg->verbose_level > 3)
5811                         printf ("[UNSAFE-MOV-INTRISIC]\tsize mismatch but both are of the same reg class\n");
5812                 return TRUE;
5813         }
5814
5815         return FALSE;
5816 }
5817
5818 static MonoInst*
5819 emit_array_unsafe_mov (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args)
5820 {
5821         MonoClass *param_klass = mono_class_from_mono_type (fsig->params [0]);
5822         MonoClass *return_klass = mono_class_from_mono_type (fsig->ret);
5823
5824         if (mini_is_gsharedvt_variable_type (fsig->ret))
5825                 return NULL;
5826
5827         //Valuetypes that are semantically equivalent or numbers than can be widened to
5828         if (is_unsafe_mov_compatible (cfg, param_klass, return_klass))
5829                 return args [0];
5830
5831         //Arrays of valuetypes that are semantically equivalent
5832         if (param_klass->rank == 1 && return_klass->rank == 1 && is_unsafe_mov_compatible (cfg, param_klass->element_class, return_klass->element_class))
5833                 return args [0];
5834
5835         return NULL;
5836 }
5837
5838 static MonoInst*
5839 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5840 {
5841 #ifdef MONO_ARCH_SIMD_INTRINSICS
5842         MonoInst *ins = NULL;
5843
5844         if (cfg->opt & MONO_OPT_SIMD) {
5845                 ins = mono_emit_simd_intrinsics (cfg, cmethod, fsig, args);
5846                 if (ins)
5847                         return ins;
5848         }
5849 #endif
5850
5851         return mono_emit_native_types_intrinsics (cfg, cmethod, fsig, args);
5852 }
5853
5854 static MonoInst*
5855 emit_memory_barrier (MonoCompile *cfg, int kind)
5856 {
5857         MonoInst *ins = NULL;
5858         MONO_INST_NEW (cfg, ins, OP_MEMORY_BARRIER);
5859         MONO_ADD_INS (cfg->cbb, ins);
5860         ins->backend.memory_barrier_kind = kind;
5861
5862         return ins;
5863 }
5864
5865 static MonoInst*
5866 llvm_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5867 {
5868         MonoInst *ins = NULL;
5869         int opcode = 0;
5870
5871         /* The LLVM backend supports these intrinsics */
5872         if (cmethod->klass == mono_defaults.math_class) {
5873                 if (strcmp (cmethod->name, "Sin") == 0) {
5874                         opcode = OP_SIN;
5875                 } else if (strcmp (cmethod->name, "Cos") == 0) {
5876                         opcode = OP_COS;
5877                 } else if (strcmp (cmethod->name, "Sqrt") == 0) {
5878                         opcode = OP_SQRT;
5879                 } else if (strcmp (cmethod->name, "Abs") == 0 && fsig->params [0]->type == MONO_TYPE_R8) {
5880                         opcode = OP_ABS;
5881                 }
5882
5883                 if (opcode && fsig->param_count == 1) {
5884                         MONO_INST_NEW (cfg, ins, opcode);
5885                         ins->type = STACK_R8;
5886                         ins->dreg = mono_alloc_freg (cfg);
5887                         ins->sreg1 = args [0]->dreg;
5888                         MONO_ADD_INS (cfg->cbb, ins);
5889                 }
5890
5891                 opcode = 0;
5892                 if (cfg->opt & MONO_OPT_CMOV) {
5893                         if (strcmp (cmethod->name, "Min") == 0) {
5894                                 if (fsig->params [0]->type == MONO_TYPE_I4)
5895                                         opcode = OP_IMIN;
5896                                 if (fsig->params [0]->type == MONO_TYPE_U4)
5897                                         opcode = OP_IMIN_UN;
5898                                 else if (fsig->params [0]->type == MONO_TYPE_I8)
5899                                         opcode = OP_LMIN;
5900                                 else if (fsig->params [0]->type == MONO_TYPE_U8)
5901                                         opcode = OP_LMIN_UN;
5902                         } else if (strcmp (cmethod->name, "Max") == 0) {
5903                                 if (fsig->params [0]->type == MONO_TYPE_I4)
5904                                         opcode = OP_IMAX;
5905                                 if (fsig->params [0]->type == MONO_TYPE_U4)
5906                                         opcode = OP_IMAX_UN;
5907                                 else if (fsig->params [0]->type == MONO_TYPE_I8)
5908                                         opcode = OP_LMAX;
5909                                 else if (fsig->params [0]->type == MONO_TYPE_U8)
5910                                         opcode = OP_LMAX_UN;
5911                         }
5912                 }
5913
5914                 if (opcode && fsig->param_count == 2) {
5915                         MONO_INST_NEW (cfg, ins, opcode);
5916                         ins->type = fsig->params [0]->type == MONO_TYPE_I4 ? STACK_I4 : STACK_I8;
5917                         ins->dreg = mono_alloc_ireg (cfg);
5918                         ins->sreg1 = args [0]->dreg;
5919                         ins->sreg2 = args [1]->dreg;
5920                         MONO_ADD_INS (cfg->cbb, ins);
5921                 }
5922         }
5923
5924         return ins;
5925 }
5926
5927 static MonoInst*
5928 mini_emit_inst_for_sharable_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5929 {
5930         if (cmethod->klass == mono_defaults.array_class) {
5931                 if (strcmp (cmethod->name, "UnsafeStore") == 0)
5932                         return emit_array_unsafe_access (cfg, fsig, args, TRUE);
5933                 else if (strcmp (cmethod->name, "UnsafeLoad") == 0)
5934                         return emit_array_unsafe_access (cfg, fsig, args, FALSE);
5935                 else if (strcmp (cmethod->name, "UnsafeMov") == 0)
5936                         return emit_array_unsafe_mov (cfg, fsig, args);
5937         }
5938
5939         return NULL;
5940 }
5941
5942 static MonoInst*
5943 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5944 {
5945         MonoInst *ins = NULL;
5946
5947          MonoClass *runtime_helpers_class = mono_class_get_runtime_helpers_class ();
5948
5949         if (cmethod->klass == mono_defaults.string_class) {
5950                 if (strcmp (cmethod->name, "get_Chars") == 0 && fsig->param_count + fsig->hasthis == 2) {
5951                         int dreg = alloc_ireg (cfg);
5952                         int index_reg = alloc_preg (cfg);
5953                         int add_reg = alloc_preg (cfg);
5954
5955 #if SIZEOF_REGISTER == 8
5956                         if (COMPILE_LLVM (cfg)) {
5957                                 MONO_EMIT_NEW_UNALU (cfg, OP_ZEXT_I4, index_reg, args [1]->dreg);
5958                         } else {
5959                                 /* The array reg is 64 bits but the index reg is only 32 */
5960                                 MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, index_reg, args [1]->dreg);
5961                         }
5962 #else
5963                         index_reg = args [1]->dreg;
5964 #endif
5965                         MONO_EMIT_BOUNDS_CHECK (cfg, args [0]->dreg, MonoString, length, index_reg);
5966
5967 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5968                         EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, MONO_STRUCT_OFFSET (MonoString, chars));
5969                         add_reg = ins->dreg;
5970                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU2_MEMBASE, dreg,
5971                                                                    add_reg, 0);
5972 #else
5973                         int mult_reg = alloc_preg (cfg);
5974                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, mult_reg, index_reg, 1);
5975                         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, mult_reg, args [0]->dreg);
5976                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU2_MEMBASE, dreg,
5977                                                                    add_reg, MONO_STRUCT_OFFSET (MonoString, chars));
5978 #endif
5979                         type_from_op (cfg, ins, NULL, NULL);
5980                         return ins;
5981                 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
5982                         int dreg = alloc_ireg (cfg);
5983                         /* Decompose later to allow more optimizations */
5984                         EMIT_NEW_UNALU (cfg, ins, OP_STRLEN, dreg, args [0]->dreg);
5985                         ins->type = STACK_I4;
5986                         ins->flags |= MONO_INST_FAULT;
5987                         cfg->cbb->has_array_access = TRUE;
5988                         cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
5989
5990                         return ins;
5991                 } else
5992                         return NULL;
5993         } else if (cmethod->klass == mono_defaults.object_class) {
5994                 if (strcmp (cmethod->name, "GetType") == 0 && fsig->param_count + fsig->hasthis == 1) {
5995                         int dreg = alloc_ireg_ref (cfg);
5996                         int vt_reg = alloc_preg (cfg);
5997                         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
5998                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, type));
5999                         type_from_op (cfg, ins, NULL, NULL);
6000
6001                         return ins;
6002                 } else if (!cfg->backend->emulate_mul_div && strcmp (cmethod->name, "InternalGetHashCode") == 0 && fsig->param_count == 1 && !mono_gc_is_moving ()) {
6003                         int dreg = alloc_ireg (cfg);
6004                         int t1 = alloc_ireg (cfg);
6005
6006                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, t1, args [0]->dreg, 3);
6007                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_MUL_IMM, dreg, t1, 2654435761u);
6008                         ins->type = STACK_I4;
6009
6010                         return ins;
6011                 } else if (strcmp (cmethod->name, ".ctor") == 0 && fsig->param_count == 0) {
6012                         MONO_INST_NEW (cfg, ins, OP_NOP);
6013                         MONO_ADD_INS (cfg->cbb, ins);
6014                         return ins;
6015                 } else
6016                         return NULL;
6017         } else if (cmethod->klass == mono_defaults.array_class) {
6018                 if (strcmp (cmethod->name, "GetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6019                         return emit_array_generic_access (cfg, fsig, args, FALSE);
6020                 else if (strcmp (cmethod->name, "SetGenericValueImpl") == 0 && fsig->param_count + fsig->hasthis == 3 && !cfg->gsharedvt)
6021                         return emit_array_generic_access (cfg, fsig, args, TRUE);
6022
6023 #ifndef MONO_BIG_ARRAYS
6024                 /*
6025                  * This is an inline version of GetLength/GetLowerBound(0) used frequently in
6026                  * Array methods.
6027                  */
6028                 else if (((strcmp (cmethod->name, "GetLength") == 0 && fsig->param_count + fsig->hasthis == 2) ||
6029                          (strcmp (cmethod->name, "GetLowerBound") == 0 && fsig->param_count + fsig->hasthis == 2)) &&
6030                          args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
6031                         int dreg = alloc_ireg (cfg);
6032                         int bounds_reg = alloc_ireg_mp (cfg);
6033                         MonoBasicBlock *end_bb, *szarray_bb;
6034                         gboolean get_length = strcmp (cmethod->name, "GetLength") == 0;
6035
6036                         NEW_BBLOCK (cfg, end_bb);
6037                         NEW_BBLOCK (cfg, szarray_bb);
6038
6039                         EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, ins, OP_LOAD_MEMBASE, bounds_reg,
6040                                                                                  args [0]->dreg, MONO_STRUCT_OFFSET (MonoArray, bounds));
6041                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, bounds_reg, 0);
6042                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, szarray_bb);
6043                         /* Non-szarray case */
6044                         if (get_length)
6045                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, dreg,
6046                                                                            bounds_reg, MONO_STRUCT_OFFSET (MonoArrayBounds, length));
6047                         else
6048                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, dreg,
6049                                                                            bounds_reg, MONO_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
6050                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
6051                         MONO_START_BB (cfg, szarray_bb);
6052                         /* Szarray case */
6053                         if (get_length)
6054                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, dreg,
6055                                                                            args [0]->dreg, MONO_STRUCT_OFFSET (MonoArray, max_length));
6056                         else
6057                                 MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
6058                         MONO_START_BB (cfg, end_bb);
6059
6060                         EMIT_NEW_UNALU (cfg, ins, OP_MOVE, dreg, dreg);
6061                         ins->type = STACK_I4;
6062
6063                         return ins;
6064                 }
6065 #endif
6066
6067                 if (cmethod->name [0] != 'g')
6068                         return NULL;
6069
6070                 if (strcmp (cmethod->name, "get_Rank") == 0 && fsig->param_count + fsig->hasthis == 1) {
6071                         int dreg = alloc_ireg (cfg);
6072                         int vtable_reg = alloc_preg (cfg);
6073                         MONO_EMIT_NEW_LOAD_MEMBASE_OP_FAULT (cfg, OP_LOAD_MEMBASE, vtable_reg,
6074                                                                                                  args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable));
6075                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU1_MEMBASE, dreg,
6076                                                                    vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank));
6077                         type_from_op (cfg, ins, NULL, NULL);
6078
6079                         return ins;
6080                 } else if (strcmp (cmethod->name, "get_Length") == 0 && fsig->param_count + fsig->hasthis == 1) {
6081                         int dreg = alloc_ireg (cfg);
6082
6083                         EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, ins, OP_LOADI4_MEMBASE, dreg,
6084                                                                                  args [0]->dreg, MONO_STRUCT_OFFSET (MonoArray, max_length));
6085                         type_from_op (cfg, ins, NULL, NULL);
6086
6087                         return ins;
6088                 } else
6089                         return NULL;
6090         } else if (cmethod->klass == runtime_helpers_class) {
6091                 if (strcmp (cmethod->name, "get_OffsetToStringData") == 0 && fsig->param_count == 0) {
6092                         EMIT_NEW_ICONST (cfg, ins, MONO_STRUCT_OFFSET (MonoString, chars));
6093                         return ins;
6094                 } else
6095                         return NULL;
6096         } else if (cmethod->klass == mono_defaults.monitor_class) {
6097                 gboolean is_enter = FALSE;
6098                 gboolean is_v4 = FALSE;
6099
6100                 if (!strcmp (cmethod->name, "enter_with_atomic_var") && mono_method_signature (cmethod)->param_count == 2) {
6101                         is_enter = TRUE;
6102                         is_v4 = TRUE;
6103                 }
6104                 if (!strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1)
6105                         is_enter = TRUE;
6106
6107                 if (is_enter) {
6108                         /*
6109                          * To make async stack traces work, icalls which can block should have a wrapper.
6110                          * For Monitor.Enter, emit two calls: a fastpath which doesn't have a wrapper, and a slowpath, which does.
6111                          */
6112                         MonoBasicBlock *end_bb;
6113
6114                         NEW_BBLOCK (cfg, end_bb);
6115
6116                         ins = mono_emit_jit_icall (cfg, is_v4 ? (gpointer)mono_monitor_enter_v4_fast : (gpointer)mono_monitor_enter_fast, args);
6117                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, ins->dreg, 0);
6118                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBNE_UN, end_bb);
6119                         ins = mono_emit_jit_icall (cfg, is_v4 ? (gpointer)mono_monitor_enter_v4 : (gpointer)mono_monitor_enter, args);
6120                         MONO_START_BB (cfg, end_bb);
6121                         return ins;
6122                 }
6123         } else if (cmethod->klass == mono_defaults.thread_class) {
6124                 if (strcmp (cmethod->name, "SpinWait_nop") == 0 && fsig->param_count == 0) {
6125                         MONO_INST_NEW (cfg, ins, OP_RELAXED_NOP);
6126                         MONO_ADD_INS (cfg->cbb, ins);
6127                         return ins;
6128                 } else if (strcmp (cmethod->name, "MemoryBarrier") == 0 && fsig->param_count == 0) {
6129                         return emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
6130                 } else if (!strcmp (cmethod->name, "VolatileRead") && fsig->param_count == 1) {
6131                         guint32 opcode = 0;
6132                         gboolean is_ref = mini_type_is_reference (fsig->params [0]);
6133
6134                         if (fsig->params [0]->type == MONO_TYPE_I1)
6135                                 opcode = OP_LOADI1_MEMBASE;
6136                         else if (fsig->params [0]->type == MONO_TYPE_U1)
6137                                 opcode = OP_LOADU1_MEMBASE;
6138                         else if (fsig->params [0]->type == MONO_TYPE_I2)
6139                                 opcode = OP_LOADI2_MEMBASE;
6140                         else if (fsig->params [0]->type == MONO_TYPE_U2)
6141                                 opcode = OP_LOADU2_MEMBASE;
6142                         else if (fsig->params [0]->type == MONO_TYPE_I4)
6143                                 opcode = OP_LOADI4_MEMBASE;
6144                         else if (fsig->params [0]->type == MONO_TYPE_U4)
6145                                 opcode = OP_LOADU4_MEMBASE;
6146                         else if (fsig->params [0]->type == MONO_TYPE_I8 || fsig->params [0]->type == MONO_TYPE_U8)
6147                                 opcode = OP_LOADI8_MEMBASE;
6148                         else if (fsig->params [0]->type == MONO_TYPE_R4)
6149                                 opcode = OP_LOADR4_MEMBASE;
6150                         else if (fsig->params [0]->type == MONO_TYPE_R8)
6151                                 opcode = OP_LOADR8_MEMBASE;
6152                         else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6153                                 opcode = OP_LOAD_MEMBASE;
6154
6155                         if (opcode) {
6156                                 MONO_INST_NEW (cfg, ins, opcode);
6157                                 ins->inst_basereg = args [0]->dreg;
6158                                 ins->inst_offset = 0;
6159                                 MONO_ADD_INS (cfg->cbb, ins);
6160
6161                                 switch (fsig->params [0]->type) {
6162                                 case MONO_TYPE_I1:
6163                                 case MONO_TYPE_U1:
6164                                 case MONO_TYPE_I2:
6165                                 case MONO_TYPE_U2:
6166                                 case MONO_TYPE_I4:
6167                                 case MONO_TYPE_U4:
6168                                         ins->dreg = mono_alloc_ireg (cfg);
6169                                         ins->type = STACK_I4;
6170                                         break;
6171                                 case MONO_TYPE_I8:
6172                                 case MONO_TYPE_U8:
6173                                         ins->dreg = mono_alloc_lreg (cfg);
6174                                         ins->type = STACK_I8;
6175                                         break;
6176                                 case MONO_TYPE_I:
6177                                 case MONO_TYPE_U:
6178                                         ins->dreg = mono_alloc_ireg (cfg);
6179 #if SIZEOF_REGISTER == 8
6180                                         ins->type = STACK_I8;
6181 #else
6182                                         ins->type = STACK_I4;
6183 #endif
6184                                         break;
6185                                 case MONO_TYPE_R4:
6186                                 case MONO_TYPE_R8:
6187                                         ins->dreg = mono_alloc_freg (cfg);
6188                                         ins->type = STACK_R8;
6189                                         break;
6190                                 default:
6191                                         g_assert (mini_type_is_reference (fsig->params [0]));
6192                                         ins->dreg = mono_alloc_ireg_ref (cfg);
6193                                         ins->type = STACK_OBJ;
6194                                         break;
6195                                 }
6196
6197                                 if (opcode == OP_LOADI8_MEMBASE)
6198                                         ins = mono_decompose_opcode (cfg, ins);
6199
6200                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
6201
6202                                 return ins;
6203                         }
6204                 } else if (!strcmp (cmethod->name, "VolatileWrite") && fsig->param_count == 2) {
6205                         guint32 opcode = 0;
6206                         gboolean is_ref = mini_type_is_reference (fsig->params [0]);
6207
6208                         if (fsig->params [0]->type == MONO_TYPE_I1 || fsig->params [0]->type == MONO_TYPE_U1)
6209                                 opcode = OP_STOREI1_MEMBASE_REG;
6210                         else if (fsig->params [0]->type == MONO_TYPE_I2 || fsig->params [0]->type == MONO_TYPE_U2)
6211                                 opcode = OP_STOREI2_MEMBASE_REG;
6212                         else if (fsig->params [0]->type == MONO_TYPE_I4 || fsig->params [0]->type == MONO_TYPE_U4)
6213                                 opcode = OP_STOREI4_MEMBASE_REG;
6214                         else if (fsig->params [0]->type == MONO_TYPE_I8 || fsig->params [0]->type == MONO_TYPE_U8)
6215                                 opcode = OP_STOREI8_MEMBASE_REG;
6216                         else if (fsig->params [0]->type == MONO_TYPE_R4)
6217                                 opcode = OP_STORER4_MEMBASE_REG;
6218                         else if (fsig->params [0]->type == MONO_TYPE_R8)
6219                                 opcode = OP_STORER8_MEMBASE_REG;
6220                         else if (is_ref || fsig->params [0]->type == MONO_TYPE_I || fsig->params [0]->type == MONO_TYPE_U)
6221                                 opcode = OP_STORE_MEMBASE_REG;
6222
6223                         if (opcode) {
6224                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
6225
6226                                 MONO_INST_NEW (cfg, ins, opcode);
6227                                 ins->sreg1 = args [1]->dreg;
6228                                 ins->inst_destbasereg = args [0]->dreg;
6229                                 ins->inst_offset = 0;
6230                                 MONO_ADD_INS (cfg->cbb, ins);
6231
6232                                 if (opcode == OP_STOREI8_MEMBASE_REG)
6233                                         ins = mono_decompose_opcode (cfg, ins);
6234
6235                                 return ins;
6236                         }
6237                 }
6238         } else if (cmethod->klass->image == mono_defaults.corlib &&
6239                            (strcmp (cmethod->klass->name_space, "System.Threading") == 0) &&
6240                            (strcmp (cmethod->klass->name, "Interlocked") == 0)) {
6241                 ins = NULL;
6242
6243 #if SIZEOF_REGISTER == 8
6244                 if (!cfg->llvm_only && strcmp (cmethod->name, "Read") == 0 && fsig->param_count == 1 && (fsig->params [0]->type == MONO_TYPE_I8)) {
6245                         if (!cfg->llvm_only && mono_arch_opcode_supported (OP_ATOMIC_LOAD_I8)) {
6246                                 MONO_INST_NEW (cfg, ins, OP_ATOMIC_LOAD_I8);
6247                                 ins->dreg = mono_alloc_preg (cfg);
6248                                 ins->sreg1 = args [0]->dreg;
6249                                 ins->type = STACK_I8;
6250                                 ins->backend.memory_barrier_kind = MONO_MEMORY_BARRIER_SEQ;
6251                                 MONO_ADD_INS (cfg->cbb, ins);
6252                         } else {
6253                                 MonoInst *load_ins;
6254
6255                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
6256
6257                                 /* 64 bit reads are already atomic */
6258                                 MONO_INST_NEW (cfg, load_ins, OP_LOADI8_MEMBASE);
6259                                 load_ins->dreg = mono_alloc_preg (cfg);
6260                                 load_ins->inst_basereg = args [0]->dreg;
6261                                 load_ins->inst_offset = 0;
6262                                 load_ins->type = STACK_I8;
6263                                 MONO_ADD_INS (cfg->cbb, load_ins);
6264
6265                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
6266
6267                                 ins = load_ins;
6268                         }
6269                 }
6270 #endif
6271
6272                 if (strcmp (cmethod->name, "Increment") == 0 && fsig->param_count == 1) {
6273                         MonoInst *ins_iconst;
6274                         guint32 opcode = 0;
6275
6276                         if (fsig->params [0]->type == MONO_TYPE_I4) {
6277                                 opcode = OP_ATOMIC_ADD_I4;
6278                                 cfg->has_atomic_add_i4 = TRUE;
6279                         }
6280 #if SIZEOF_REGISTER == 8
6281                         else if (fsig->params [0]->type == MONO_TYPE_I8)
6282                                 opcode = OP_ATOMIC_ADD_I8;
6283 #endif
6284                         if (opcode) {
6285                                 if (!mono_arch_opcode_supported (opcode))
6286                                         return NULL;
6287                                 MONO_INST_NEW (cfg, ins_iconst, OP_ICONST);
6288                                 ins_iconst->inst_c0 = 1;
6289                                 ins_iconst->dreg = mono_alloc_ireg (cfg);
6290                                 MONO_ADD_INS (cfg->cbb, ins_iconst);
6291
6292                                 MONO_INST_NEW (cfg, ins, opcode);
6293                                 ins->dreg = mono_alloc_ireg (cfg);
6294                                 ins->inst_basereg = args [0]->dreg;
6295                                 ins->inst_offset = 0;
6296                                 ins->sreg2 = ins_iconst->dreg;
6297                                 ins->type = (opcode == OP_ATOMIC_ADD_I4) ? STACK_I4 : STACK_I8;
6298                                 MONO_ADD_INS (cfg->cbb, ins);
6299                         }
6300                 } else if (strcmp (cmethod->name, "Decrement") == 0 && fsig->param_count == 1) {
6301                         MonoInst *ins_iconst;
6302                         guint32 opcode = 0;
6303
6304                         if (fsig->params [0]->type == MONO_TYPE_I4) {
6305                                 opcode = OP_ATOMIC_ADD_I4;
6306                                 cfg->has_atomic_add_i4 = TRUE;
6307                         }
6308 #if SIZEOF_REGISTER == 8
6309                         else if (fsig->params [0]->type == MONO_TYPE_I8)
6310                                 opcode = OP_ATOMIC_ADD_I8;
6311 #endif
6312                         if (opcode) {
6313                                 if (!mono_arch_opcode_supported (opcode))
6314                                         return NULL;
6315                                 MONO_INST_NEW (cfg, ins_iconst, OP_ICONST);
6316                                 ins_iconst->inst_c0 = -1;
6317                                 ins_iconst->dreg = mono_alloc_ireg (cfg);
6318                                 MONO_ADD_INS (cfg->cbb, ins_iconst);
6319
6320                                 MONO_INST_NEW (cfg, ins, opcode);
6321                                 ins->dreg = mono_alloc_ireg (cfg);
6322                                 ins->inst_basereg = args [0]->dreg;
6323                                 ins->inst_offset = 0;
6324                                 ins->sreg2 = ins_iconst->dreg;
6325                                 ins->type = (opcode == OP_ATOMIC_ADD_I4) ? STACK_I4 : STACK_I8;
6326                                 MONO_ADD_INS (cfg->cbb, ins);
6327                         }
6328                 } else if (strcmp (cmethod->name, "Add") == 0 && fsig->param_count == 2) {
6329                         guint32 opcode = 0;
6330
6331                         if (fsig->params [0]->type == MONO_TYPE_I4) {
6332                                 opcode = OP_ATOMIC_ADD_I4;
6333                                 cfg->has_atomic_add_i4 = TRUE;
6334                         }
6335 #if SIZEOF_REGISTER == 8
6336                         else if (fsig->params [0]->type == MONO_TYPE_I8)
6337                                 opcode = OP_ATOMIC_ADD_I8;
6338 #endif
6339                         if (opcode) {
6340                                 if (!mono_arch_opcode_supported (opcode))
6341                                         return NULL;
6342                                 MONO_INST_NEW (cfg, ins, opcode);
6343                                 ins->dreg = mono_alloc_ireg (cfg);
6344                                 ins->inst_basereg = args [0]->dreg;
6345                                 ins->inst_offset = 0;
6346                                 ins->sreg2 = args [1]->dreg;
6347                                 ins->type = (opcode == OP_ATOMIC_ADD_I4) ? STACK_I4 : STACK_I8;
6348                                 MONO_ADD_INS (cfg->cbb, ins);
6349                         }
6350                 }
6351                 else if (strcmp (cmethod->name, "Exchange") == 0 && fsig->param_count == 2) {
6352                         MonoInst *f2i = NULL, *i2f;
6353                         guint32 opcode, f2i_opcode, i2f_opcode;
6354                         gboolean is_ref = mini_type_is_reference (fsig->params [0]);
6355                         gboolean is_float = fsig->params [0]->type == MONO_TYPE_R4 || fsig->params [0]->type == MONO_TYPE_R8;
6356
6357                         if (fsig->params [0]->type == MONO_TYPE_I4 ||
6358                             fsig->params [0]->type == MONO_TYPE_R4) {
6359                                 opcode = OP_ATOMIC_EXCHANGE_I4;
6360                                 f2i_opcode = OP_MOVE_F_TO_I4;
6361                                 i2f_opcode = OP_MOVE_I4_TO_F;
6362                                 cfg->has_atomic_exchange_i4 = TRUE;
6363                         }
6364 #if SIZEOF_REGISTER == 8
6365                         else if (is_ref ||
6366                                  fsig->params [0]->type == MONO_TYPE_I8 ||
6367                                  fsig->params [0]->type == MONO_TYPE_R8 ||
6368                                  fsig->params [0]->type == MONO_TYPE_I) {
6369                                 opcode = OP_ATOMIC_EXCHANGE_I8;
6370                                 f2i_opcode = OP_MOVE_F_TO_I8;
6371                                 i2f_opcode = OP_MOVE_I8_TO_F;
6372                         }
6373 #else
6374                         else if (is_ref || fsig->params [0]->type == MONO_TYPE_I) {
6375                                 opcode = OP_ATOMIC_EXCHANGE_I4;
6376                                 cfg->has_atomic_exchange_i4 = TRUE;
6377                         }
6378 #endif
6379                         else
6380                                 return NULL;
6381
6382                         if (!mono_arch_opcode_supported (opcode))
6383                                 return NULL;
6384
6385                         if (is_float) {
6386                                 /* TODO: Decompose these opcodes instead of bailing here. */
6387                                 if (COMPILE_SOFT_FLOAT (cfg))
6388                                         return NULL;
6389
6390                                 MONO_INST_NEW (cfg, f2i, f2i_opcode);
6391                                 f2i->dreg = mono_alloc_ireg (cfg);
6392                                 f2i->sreg1 = args [1]->dreg;
6393                                 if (f2i_opcode == OP_MOVE_F_TO_I4)
6394                                         f2i->backend.spill_var = mini_get_int_to_float_spill_area (cfg);
6395                                 MONO_ADD_INS (cfg->cbb, f2i);
6396                         }
6397
6398                         MONO_INST_NEW (cfg, ins, opcode);
6399                         ins->dreg = is_ref ? mono_alloc_ireg_ref (cfg) : mono_alloc_ireg (cfg);
6400                         ins->inst_basereg = args [0]->dreg;
6401                         ins->inst_offset = 0;
6402                         ins->sreg2 = is_float ? f2i->dreg : args [1]->dreg;
6403                         MONO_ADD_INS (cfg->cbb, ins);
6404
6405                         switch (fsig->params [0]->type) {
6406                         case MONO_TYPE_I4:
6407                                 ins->type = STACK_I4;
6408                                 break;
6409                         case MONO_TYPE_I8:
6410                                 ins->type = STACK_I8;
6411                                 break;
6412                         case MONO_TYPE_I:
6413 #if SIZEOF_REGISTER == 8
6414                                 ins->type = STACK_I8;
6415 #else
6416                                 ins->type = STACK_I4;
6417 #endif
6418                                 break;
6419                         case MONO_TYPE_R4:
6420                         case MONO_TYPE_R8:
6421                                 ins->type = STACK_R8;
6422                                 break;
6423                         default:
6424                                 g_assert (mini_type_is_reference (fsig->params [0]));
6425                                 ins->type = STACK_OBJ;
6426                                 break;
6427                         }
6428
6429                         if (is_float) {
6430                                 MONO_INST_NEW (cfg, i2f, i2f_opcode);
6431                                 i2f->dreg = mono_alloc_freg (cfg);
6432                                 i2f->sreg1 = ins->dreg;
6433                                 i2f->type = STACK_R8;
6434                                 if (i2f_opcode == OP_MOVE_I4_TO_F)
6435                                         i2f->backend.spill_var = mini_get_int_to_float_spill_area (cfg);
6436                                 MONO_ADD_INS (cfg->cbb, i2f);
6437
6438                                 ins = i2f;
6439                         }
6440
6441                         if (cfg->gen_write_barriers && is_ref)
6442                                 emit_write_barrier (cfg, args [0], args [1]);
6443                 }
6444                 else if ((strcmp (cmethod->name, "CompareExchange") == 0) && fsig->param_count == 3) {
6445                         MonoInst *f2i_new = NULL, *f2i_cmp = NULL, *i2f;
6446                         guint32 opcode, f2i_opcode, i2f_opcode;
6447                         gboolean is_ref = mini_type_is_reference (fsig->params [1]);
6448                         gboolean is_float = fsig->params [1]->type == MONO_TYPE_R4 || fsig->params [1]->type == MONO_TYPE_R8;
6449
6450                         if (fsig->params [1]->type == MONO_TYPE_I4 ||
6451                             fsig->params [1]->type == MONO_TYPE_R4) {
6452                                 opcode = OP_ATOMIC_CAS_I4;
6453                                 f2i_opcode = OP_MOVE_F_TO_I4;
6454                                 i2f_opcode = OP_MOVE_I4_TO_F;
6455                                 cfg->has_atomic_cas_i4 = TRUE;
6456                         }
6457 #if SIZEOF_REGISTER == 8
6458                         else if (is_ref ||
6459                                  fsig->params [1]->type == MONO_TYPE_I8 ||
6460                                  fsig->params [1]->type == MONO_TYPE_R8 ||
6461                                  fsig->params [1]->type == MONO_TYPE_I) {
6462                                 opcode = OP_ATOMIC_CAS_I8;
6463                                 f2i_opcode = OP_MOVE_F_TO_I8;
6464                                 i2f_opcode = OP_MOVE_I8_TO_F;
6465                         }
6466 #else
6467                         else if (is_ref || fsig->params [1]->type == MONO_TYPE_I) {
6468                                 opcode = OP_ATOMIC_CAS_I4;
6469                                 cfg->has_atomic_cas_i4 = TRUE;
6470                         }
6471 #endif
6472                         else
6473                                 return NULL;
6474
6475                         if (!mono_arch_opcode_supported (opcode))
6476                                 return NULL;
6477
6478                         if (is_float) {
6479                                 /* TODO: Decompose these opcodes instead of bailing here. */
6480                                 if (COMPILE_SOFT_FLOAT (cfg))
6481                                         return NULL;
6482
6483                                 MONO_INST_NEW (cfg, f2i_new, f2i_opcode);
6484                                 f2i_new->dreg = mono_alloc_ireg (cfg);
6485                                 f2i_new->sreg1 = args [1]->dreg;
6486                                 if (f2i_opcode == OP_MOVE_F_TO_I4)
6487                                         f2i_new->backend.spill_var = mini_get_int_to_float_spill_area (cfg);
6488                                 MONO_ADD_INS (cfg->cbb, f2i_new);
6489
6490                                 MONO_INST_NEW (cfg, f2i_cmp, f2i_opcode);
6491                                 f2i_cmp->dreg = mono_alloc_ireg (cfg);
6492                                 f2i_cmp->sreg1 = args [2]->dreg;
6493                                 if (f2i_opcode == OP_MOVE_F_TO_I4)
6494                                         f2i_cmp->backend.spill_var = mini_get_int_to_float_spill_area (cfg);
6495                                 MONO_ADD_INS (cfg->cbb, f2i_cmp);
6496                         }
6497
6498                         MONO_INST_NEW (cfg, ins, opcode);
6499                         ins->dreg = is_ref ? alloc_ireg_ref (cfg) : alloc_ireg (cfg);
6500                         ins->sreg1 = args [0]->dreg;
6501                         ins->sreg2 = is_float ? f2i_new->dreg : args [1]->dreg;
6502                         ins->sreg3 = is_float ? f2i_cmp->dreg : args [2]->dreg;
6503                         MONO_ADD_INS (cfg->cbb, ins);
6504
6505                         switch (fsig->params [1]->type) {
6506                         case MONO_TYPE_I4:
6507                                 ins->type = STACK_I4;
6508                                 break;
6509                         case MONO_TYPE_I8:
6510                                 ins->type = STACK_I8;
6511                                 break;
6512                         case MONO_TYPE_I:
6513 #if SIZEOF_REGISTER == 8
6514                                 ins->type = STACK_I8;
6515 #else
6516                                 ins->type = STACK_I4;
6517 #endif
6518                                 break;
6519                         case MONO_TYPE_R4:
6520                                 ins->type = cfg->r4_stack_type;
6521                                 break;
6522                         case MONO_TYPE_R8:
6523                                 ins->type = STACK_R8;
6524                                 break;
6525                         default:
6526                                 g_assert (mini_type_is_reference (fsig->params [1]));
6527                                 ins->type = STACK_OBJ;
6528                                 break;
6529                         }
6530
6531                         if (is_float) {
6532                                 MONO_INST_NEW (cfg, i2f, i2f_opcode);
6533                                 i2f->dreg = mono_alloc_freg (cfg);
6534                                 i2f->sreg1 = ins->dreg;
6535                                 i2f->type = STACK_R8;
6536                                 if (i2f_opcode == OP_MOVE_I4_TO_F)
6537                                         i2f->backend.spill_var = mini_get_int_to_float_spill_area (cfg);
6538                                 MONO_ADD_INS (cfg->cbb, i2f);
6539
6540                                 ins = i2f;
6541                         }
6542
6543                         if (cfg->gen_write_barriers && is_ref)
6544                                 emit_write_barrier (cfg, args [0], args [1]);
6545                 }
6546                 else if ((strcmp (cmethod->name, "CompareExchange") == 0) && fsig->param_count == 4 &&
6547                          fsig->params [1]->type == MONO_TYPE_I4) {
6548                         MonoInst *cmp, *ceq;
6549
6550                         if (!mono_arch_opcode_supported (OP_ATOMIC_CAS_I4))
6551                                 return NULL;
6552
6553                         /* int32 r = CAS (location, value, comparand); */
6554                         MONO_INST_NEW (cfg, ins, OP_ATOMIC_CAS_I4);
6555                         ins->dreg = alloc_ireg (cfg);
6556                         ins->sreg1 = args [0]->dreg;
6557                         ins->sreg2 = args [1]->dreg;
6558                         ins->sreg3 = args [2]->dreg;
6559                         ins->type = STACK_I4;
6560                         MONO_ADD_INS (cfg->cbb, ins);
6561
6562                         /* bool result = r == comparand; */
6563                         MONO_INST_NEW (cfg, cmp, OP_ICOMPARE);
6564                         cmp->sreg1 = ins->dreg;
6565                         cmp->sreg2 = args [2]->dreg;
6566                         cmp->type = STACK_I4;
6567                         MONO_ADD_INS (cfg->cbb, cmp);
6568
6569                         MONO_INST_NEW (cfg, ceq, OP_ICEQ);
6570                         ceq->dreg = alloc_ireg (cfg);
6571                         ceq->type = STACK_I4;
6572                         MONO_ADD_INS (cfg->cbb, ceq);
6573
6574                         /* *success = result; */
6575                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, args [3]->dreg, 0, ceq->dreg);
6576
6577                         cfg->has_atomic_cas_i4 = TRUE;
6578                 }
6579                 else if (strcmp (cmethod->name, "MemoryBarrier") == 0 && fsig->param_count == 0)
6580                         ins = emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
6581
6582                 if (ins)
6583                         return ins;
6584         } else if (cmethod->klass->image == mono_defaults.corlib &&
6585                            (strcmp (cmethod->klass->name_space, "System.Threading") == 0) &&
6586                            (strcmp (cmethod->klass->name, "Volatile") == 0)) {
6587                 ins = NULL;
6588
6589                 if (!cfg->llvm_only && !strcmp (cmethod->name, "Read") && fsig->param_count == 1) {
6590                         guint32 opcode = 0;
6591                         MonoType *t = fsig->params [0];
6592                         gboolean is_ref;
6593                         gboolean is_float = t->type == MONO_TYPE_R4 || t->type == MONO_TYPE_R8;
6594
6595                         g_assert (t->byref);
6596                         /* t is a byref type, so the reference check is more complicated */
6597                         is_ref = mini_type_is_reference (&mono_class_from_mono_type (t)->byval_arg);
6598                         if (t->type == MONO_TYPE_I1)
6599                                 opcode = OP_ATOMIC_LOAD_I1;
6600                         else if (t->type == MONO_TYPE_U1 || t->type == MONO_TYPE_BOOLEAN)
6601                                 opcode = OP_ATOMIC_LOAD_U1;
6602                         else if (t->type == MONO_TYPE_I2)
6603                                 opcode = OP_ATOMIC_LOAD_I2;
6604                         else if (t->type == MONO_TYPE_U2)
6605                                 opcode = OP_ATOMIC_LOAD_U2;
6606                         else if (t->type == MONO_TYPE_I4)
6607                                 opcode = OP_ATOMIC_LOAD_I4;
6608                         else if (t->type == MONO_TYPE_U4)
6609                                 opcode = OP_ATOMIC_LOAD_U4;
6610                         else if (t->type == MONO_TYPE_R4)
6611                                 opcode = OP_ATOMIC_LOAD_R4;
6612                         else if (t->type == MONO_TYPE_R8)
6613                                 opcode = OP_ATOMIC_LOAD_R8;
6614 #if SIZEOF_REGISTER == 8
6615                         else if (t->type == MONO_TYPE_I8 || t->type == MONO_TYPE_I)
6616                                 opcode = OP_ATOMIC_LOAD_I8;
6617                         else if (is_ref || t->type == MONO_TYPE_U8 || t->type == MONO_TYPE_U)
6618                                 opcode = OP_ATOMIC_LOAD_U8;
6619 #else
6620                         else if (t->type == MONO_TYPE_I)
6621                                 opcode = OP_ATOMIC_LOAD_I4;
6622                         else if (is_ref || t->type == MONO_TYPE_U)
6623                                 opcode = OP_ATOMIC_LOAD_U4;
6624 #endif
6625
6626                         if (opcode) {
6627                                 if (!mono_arch_opcode_supported (opcode))
6628                                         return NULL;
6629
6630                                 MONO_INST_NEW (cfg, ins, opcode);
6631                                 ins->dreg = is_ref ? mono_alloc_ireg_ref (cfg) : (is_float ? mono_alloc_freg (cfg) : mono_alloc_ireg (cfg));
6632                                 ins->sreg1 = args [0]->dreg;
6633                                 ins->backend.memory_barrier_kind = MONO_MEMORY_BARRIER_ACQ;
6634                                 MONO_ADD_INS (cfg->cbb, ins);
6635
6636                                 switch (t->type) {
6637                                 case MONO_TYPE_BOOLEAN:
6638                                 case MONO_TYPE_I1:
6639                                 case MONO_TYPE_U1:
6640                                 case MONO_TYPE_I2:
6641                                 case MONO_TYPE_U2:
6642                                 case MONO_TYPE_I4:
6643                                 case MONO_TYPE_U4:
6644                                         ins->type = STACK_I4;
6645                                         break;
6646                                 case MONO_TYPE_I8:
6647                                 case MONO_TYPE_U8:
6648                                         ins->type = STACK_I8;
6649                                         break;
6650                                 case MONO_TYPE_I:
6651                                 case MONO_TYPE_U:
6652 #if SIZEOF_REGISTER == 8
6653                                         ins->type = STACK_I8;
6654 #else
6655                                         ins->type = STACK_I4;
6656 #endif
6657                                         break;
6658                                 case MONO_TYPE_R4:
6659                                         ins->type = cfg->r4_stack_type;
6660                                         break;
6661                                 case MONO_TYPE_R8:
6662                                         ins->type = STACK_R8;
6663                                         break;
6664                                 default:
6665                                         g_assert (is_ref);
6666                                         ins->type = STACK_OBJ;
6667                                         break;
6668                                 }
6669                         }
6670                 }
6671
6672                 if (!cfg->llvm_only && !strcmp (cmethod->name, "Write") && fsig->param_count == 2) {
6673                         guint32 opcode = 0;
6674                         MonoType *t = fsig->params [0];
6675                         gboolean is_ref;
6676
6677                         g_assert (t->byref);
6678                         is_ref = mini_type_is_reference (&mono_class_from_mono_type (t)->byval_arg);
6679                         if (t->type == MONO_TYPE_I1)
6680                                 opcode = OP_ATOMIC_STORE_I1;
6681                         else if (t->type == MONO_TYPE_U1 || t->type == MONO_TYPE_BOOLEAN)
6682                                 opcode = OP_ATOMIC_STORE_U1;
6683                         else if (t->type == MONO_TYPE_I2)
6684                                 opcode = OP_ATOMIC_STORE_I2;
6685                         else if (t->type == MONO_TYPE_U2)
6686                                 opcode = OP_ATOMIC_STORE_U2;
6687                         else if (t->type == MONO_TYPE_I4)
6688                                 opcode = OP_ATOMIC_STORE_I4;
6689                         else if (t->type == MONO_TYPE_U4)
6690                                 opcode = OP_ATOMIC_STORE_U4;
6691                         else if (t->type == MONO_TYPE_R4)
6692                                 opcode = OP_ATOMIC_STORE_R4;
6693                         else if (t->type == MONO_TYPE_R8)
6694                                 opcode = OP_ATOMIC_STORE_R8;
6695 #if SIZEOF_REGISTER == 8
6696                         else if (t->type == MONO_TYPE_I8 || t->type == MONO_TYPE_I)
6697                                 opcode = OP_ATOMIC_STORE_I8;
6698                         else if (is_ref || t->type == MONO_TYPE_U8 || t->type == MONO_TYPE_U)
6699                                 opcode = OP_ATOMIC_STORE_U8;
6700 #else
6701                         else if (t->type == MONO_TYPE_I)
6702                                 opcode = OP_ATOMIC_STORE_I4;
6703                         else if (is_ref || t->type == MONO_TYPE_U)
6704                                 opcode = OP_ATOMIC_STORE_U4;
6705 #endif
6706
6707                         if (opcode) {
6708                                 if (!mono_arch_opcode_supported (opcode))
6709                                         return NULL;
6710
6711                                 MONO_INST_NEW (cfg, ins, opcode);
6712                                 ins->dreg = args [0]->dreg;
6713                                 ins->sreg1 = args [1]->dreg;
6714                                 ins->backend.memory_barrier_kind = MONO_MEMORY_BARRIER_REL;
6715                                 MONO_ADD_INS (cfg->cbb, ins);
6716
6717                                 if (cfg->gen_write_barriers && is_ref)
6718                                         emit_write_barrier (cfg, args [0], args [1]);
6719                         }
6720                 }
6721
6722                 if (ins)
6723                         return ins;
6724         } else if (cmethod->klass->image == mono_defaults.corlib &&
6725                            (strcmp (cmethod->klass->name_space, "System.Diagnostics") == 0) &&
6726                            (strcmp (cmethod->klass->name, "Debugger") == 0)) {
6727                 if (!strcmp (cmethod->name, "Break") && fsig->param_count == 0) {
6728                         if (should_insert_brekpoint (cfg->method)) {
6729                                 ins = mono_emit_jit_icall (cfg, mono_debugger_agent_user_break, NULL);
6730                         } else {
6731                                 MONO_INST_NEW (cfg, ins, OP_NOP);
6732                                 MONO_ADD_INS (cfg->cbb, ins);
6733                         }
6734                         return ins;
6735                 }
6736         } else if (cmethod->klass->image == mono_defaults.corlib &&
6737                    (strcmp (cmethod->klass->name_space, "System") == 0) &&
6738                    (strcmp (cmethod->klass->name, "Environment") == 0)) {
6739                 if (!strcmp (cmethod->name, "get_IsRunningOnWindows") && fsig->param_count == 0) {
6740 #ifdef TARGET_WIN32
6741                         EMIT_NEW_ICONST (cfg, ins, 1);
6742 #else
6743                         EMIT_NEW_ICONST (cfg, ins, 0);
6744 #endif
6745                 }
6746         } else if (cmethod->klass->image == mono_defaults.corlib &&
6747                            (strcmp (cmethod->klass->name_space, "System.Reflection") == 0) &&
6748                            (strcmp (cmethod->klass->name, "Assembly") == 0)) {
6749                 if (cfg->llvm_only && !strcmp (cmethod->name, "GetExecutingAssembly")) {
6750                         /* No stack walks are currently available, so implement this as an intrinsic */
6751                         MonoInst *assembly_ins;
6752
6753                         EMIT_NEW_AOTCONST (cfg, assembly_ins, MONO_PATCH_INFO_IMAGE, cfg->method->klass->image);
6754                         ins = mono_emit_jit_icall (cfg, mono_get_assembly_object, &assembly_ins);
6755                         return ins;
6756                 }
6757         } else if (cmethod->klass->image == mono_defaults.corlib &&
6758                            (strcmp (cmethod->klass->name_space, "System.Reflection") == 0) &&
6759                            (strcmp (cmethod->klass->name, "MethodBase") == 0)) {
6760                 if (cfg->llvm_only && !strcmp (cmethod->name, "GetCurrentMethod")) {
6761                         /* No stack walks are currently available, so implement this as an intrinsic */
6762                         MonoInst *method_ins;
6763                         MonoMethod *declaring = cfg->method;
6764
6765                         /* This returns the declaring generic method */
6766                         if (declaring->is_inflated)
6767                                 declaring = ((MonoMethodInflated*)cfg->method)->declaring;
6768                         EMIT_NEW_AOTCONST (cfg, method_ins, MONO_PATCH_INFO_METHODCONST, declaring);
6769                         ins = mono_emit_jit_icall (cfg, mono_get_method_object, &method_ins);
6770                         cfg->no_inline = TRUE;
6771                         if (cfg->method != cfg->current_method)
6772                                 inline_failure (cfg, "MethodBase:GetCurrentMethod ()");
6773                         return ins;
6774                 }
6775         } else if (cmethod->klass == mono_defaults.math_class) {
6776                 /*
6777                  * There is general branchless code for Min/Max, but it does not work for
6778                  * all inputs:
6779                  * http://everything2.com/?node_id=1051618
6780                  */
6781         } else if (((!strcmp (cmethod->klass->image->assembly->aname.name, "MonoMac") ||
6782                     !strcmp (cmethod->klass->image->assembly->aname.name, "monotouch")) &&
6783                                 !strcmp (cmethod->klass->name_space, "XamCore.ObjCRuntime") &&
6784                                 !strcmp (cmethod->klass->name, "Selector")) ||
6785                            (!strcmp (cmethod->klass->image->assembly->aname.name, "Xamarin.iOS") &&
6786                                 !strcmp (cmethod->klass->name_space, "ObjCRuntime") &&
6787                                 !strcmp (cmethod->klass->name, "Selector"))
6788                            ) {
6789                 if (cfg->backend->have_objc_get_selector &&
6790                         !strcmp (cmethod->name, "GetHandle") && fsig->param_count == 1 &&
6791                     (args [0]->opcode == OP_GOT_ENTRY || args [0]->opcode == OP_AOTCONST) &&
6792                     cfg->compile_aot && !cfg->llvm_only) {
6793                         MonoInst *pi;
6794                         MonoJumpInfoToken *ji;
6795                         MonoString *s;
6796
6797                         // FIXME: llvmonly
6798
6799                         cfg->exception_message = g_strdup ("GetHandle");
6800                         cfg->disable_llvm = TRUE;
6801
6802                         if (args [0]->opcode == OP_GOT_ENTRY) {
6803                                 pi = (MonoInst *)args [0]->inst_p1;
6804                                 g_assert (pi->opcode == OP_PATCH_INFO);
6805                                 g_assert (GPOINTER_TO_INT (pi->inst_p1) == MONO_PATCH_INFO_LDSTR);
6806                                 ji = (MonoJumpInfoToken *)pi->inst_p0;
6807                         } else {
6808                                 g_assert (GPOINTER_TO_INT (args [0]->inst_p1) == MONO_PATCH_INFO_LDSTR);
6809                                 ji = (MonoJumpInfoToken *)args [0]->inst_p0;
6810                         }
6811
6812                         NULLIFY_INS (args [0]);
6813
6814                         // FIXME: Ugly
6815                         s = mono_ldstr (cfg->domain, ji->image, mono_metadata_token_index (ji->token));
6816                         MONO_INST_NEW (cfg, ins, OP_OBJC_GET_SELECTOR);
6817                         ins->dreg = mono_alloc_ireg (cfg);
6818                         // FIXME: Leaks
6819                         ins->inst_p0 = mono_string_to_utf8 (s);
6820                         MONO_ADD_INS (cfg->cbb, ins);
6821                         return ins;
6822                 }
6823         }
6824
6825 #ifdef MONO_ARCH_SIMD_INTRINSICS
6826         if (cfg->opt & MONO_OPT_SIMD) {
6827                 ins = mono_emit_simd_intrinsics (cfg, cmethod, fsig, args);
6828                 if (ins)
6829                         return ins;
6830         }
6831 #endif
6832
6833         ins = mono_emit_native_types_intrinsics (cfg, cmethod, fsig, args);
6834         if (ins)
6835                 return ins;
6836
6837         if (COMPILE_LLVM (cfg)) {
6838                 ins = llvm_emit_inst_for_method (cfg, cmethod, fsig, args);
6839                 if (ins)
6840                         return ins;
6841         }
6842
6843         return mono_arch_emit_inst_for_method (cfg, cmethod, fsig, args);
6844 }
6845
6846 /*
6847  * This entry point could be used later for arbitrary method
6848  * redirection.
6849  */
6850 inline static MonoInst*
6851 mini_redirect_call (MonoCompile *cfg, MonoMethod *method,
6852                                         MonoMethodSignature *signature, MonoInst **args, MonoInst *this_ins)
6853 {
6854         if (method->klass == mono_defaults.string_class) {
6855                 /* managed string allocation support */
6856                 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && !(cfg->opt & MONO_OPT_SHARED)) {
6857                         MonoInst *iargs [2];
6858                         MonoVTable *vtable = mono_class_vtable (cfg->domain, method->klass);
6859                         MonoMethod *managed_alloc = NULL;
6860
6861                         g_assert (vtable); /*Should not fail since it System.String*/
6862 #ifndef MONO_CROSS_COMPILE
6863                         managed_alloc = mono_gc_get_managed_allocator (method->klass, FALSE, FALSE);
6864 #endif
6865                         if (!managed_alloc)
6866                                 return NULL;
6867                         EMIT_NEW_VTABLECONST (cfg, iargs [0], vtable);
6868                         iargs [1] = args [0];
6869                         return mono_emit_method_call (cfg, managed_alloc, iargs, this_ins);
6870                 }
6871         }
6872         return NULL;
6873 }
6874
6875 static void
6876 mono_save_args (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **sp)
6877 {
6878         MonoInst *store, *temp;
6879         int i;
6880
6881         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
6882                 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
6883
6884                 /*
6885                  * FIXME: We should use *args++ = sp [0], but that would mean the arg
6886                  * would be different than the MonoInst's used to represent arguments, and
6887                  * the ldelema implementation can't deal with that.
6888                  * Solution: When ldelema is used on an inline argument, create a var for
6889                  * it, emit ldelema on that var, and emit the saving code below in
6890                  * inline_method () if needed.
6891                  */
6892                 temp = mono_compile_create_var (cfg, argtype, OP_LOCAL);
6893                 cfg->args [i] = temp;
6894                 /* This uses cfg->args [i] which is set by the preceeding line */
6895                 EMIT_NEW_ARGSTORE (cfg, store, i, *sp);
6896                 store->cil_code = sp [0]->cil_code;
6897                 sp++;
6898         }
6899 }
6900
6901 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
6902 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
6903
6904 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
6905 static gboolean
6906 check_inline_called_method_name_limit (MonoMethod *called_method)
6907 {
6908         int strncmp_result;
6909         static const char *limit = NULL;
6910
6911         if (limit == NULL) {
6912                 const char *limit_string = g_getenv ("MONO_INLINE_CALLED_METHOD_NAME_LIMIT");
6913
6914                 if (limit_string != NULL)
6915                         limit = limit_string;
6916                 else
6917                         limit = "";
6918         }
6919
6920         if (limit [0] != '\0') {
6921                 char *called_method_name = mono_method_full_name (called_method, TRUE);
6922
6923                 strncmp_result = strncmp (called_method_name, limit, strlen (limit));
6924                 g_free (called_method_name);
6925
6926                 //return (strncmp_result <= 0);
6927                 return (strncmp_result == 0);
6928         } else {
6929                 return TRUE;
6930         }
6931 }
6932 #endif
6933
6934 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
6935 static gboolean
6936 check_inline_caller_method_name_limit (MonoMethod *caller_method)
6937 {
6938         int strncmp_result;
6939         static const char *limit = NULL;
6940
6941         if (limit == NULL) {
6942                 const char *limit_string = g_getenv ("MONO_INLINE_CALLER_METHOD_NAME_LIMIT");
6943                 if (limit_string != NULL) {
6944                         limit = limit_string;
6945                 } else {
6946                         limit = "";
6947                 }
6948         }
6949
6950         if (limit [0] != '\0') {
6951                 char *caller_method_name = mono_method_full_name (caller_method, TRUE);
6952
6953                 strncmp_result = strncmp (caller_method_name, limit, strlen (limit));
6954                 g_free (caller_method_name);
6955
6956                 //return (strncmp_result <= 0);
6957                 return (strncmp_result == 0);
6958         } else {
6959                 return TRUE;
6960         }
6961 }
6962 #endif
6963
6964 static void
6965 emit_init_rvar (MonoCompile *cfg, int dreg, MonoType *rtype)
6966 {
6967         static double r8_0 = 0.0;
6968         static float r4_0 = 0.0;
6969         MonoInst *ins;
6970         int t;
6971
6972         rtype = mini_get_underlying_type (rtype);
6973         t = rtype->type;
6974
6975         if (rtype->byref) {
6976                 MONO_EMIT_NEW_PCONST (cfg, dreg, NULL);
6977         } else if (t >= MONO_TYPE_BOOLEAN && t <= MONO_TYPE_U4) {
6978                 MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
6979         } else if (t == MONO_TYPE_I8 || t == MONO_TYPE_U8) {
6980                 MONO_EMIT_NEW_I8CONST (cfg, dreg, 0);
6981         } else if (cfg->r4fp && t == MONO_TYPE_R4) {
6982                 MONO_INST_NEW (cfg, ins, OP_R4CONST);
6983                 ins->type = STACK_R4;
6984                 ins->inst_p0 = (void*)&r4_0;
6985                 ins->dreg = dreg;
6986                 MONO_ADD_INS (cfg->cbb, ins);
6987         } else if (t == MONO_TYPE_R4 || t == MONO_TYPE_R8) {
6988                 MONO_INST_NEW (cfg, ins, OP_R8CONST);
6989                 ins->type = STACK_R8;
6990                 ins->inst_p0 = (void*)&r8_0;
6991                 ins->dreg = dreg;
6992                 MONO_ADD_INS (cfg->cbb, ins);
6993         } else if ((t == MONO_TYPE_VALUETYPE) || (t == MONO_TYPE_TYPEDBYREF) ||
6994                    ((t == MONO_TYPE_GENERICINST) && mono_type_generic_inst_is_valuetype (rtype))) {
6995                 MONO_EMIT_NEW_VZERO (cfg, dreg, mono_class_from_mono_type (rtype));
6996         } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (rtype)) {
6997                 MONO_EMIT_NEW_VZERO (cfg, dreg, mono_class_from_mono_type (rtype));
6998         } else {
6999                 MONO_EMIT_NEW_PCONST (cfg, dreg, NULL);
7000         }
7001 }
7002
7003 static void
7004 emit_dummy_init_rvar (MonoCompile *cfg, int dreg, MonoType *rtype)
7005 {
7006         int t;
7007
7008         rtype = mini_get_underlying_type (rtype);
7009         t = rtype->type;
7010
7011         if (rtype->byref) {
7012                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_PCONST);
7013         } else if (t >= MONO_TYPE_BOOLEAN && t <= MONO_TYPE_U4) {
7014                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_ICONST);
7015         } else if (t == MONO_TYPE_I8 || t == MONO_TYPE_U8) {
7016                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_I8CONST);
7017         } else if (cfg->r4fp && t == MONO_TYPE_R4) {
7018                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_R4CONST);
7019         } else if (t == MONO_TYPE_R4 || t == MONO_TYPE_R8) {
7020                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_R8CONST);
7021         } else if ((t == MONO_TYPE_VALUETYPE) || (t == MONO_TYPE_TYPEDBYREF) ||
7022                    ((t == MONO_TYPE_GENERICINST) && mono_type_generic_inst_is_valuetype (rtype))) {
7023                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_VZERO);
7024         } else if (((t == MONO_TYPE_VAR) || (t == MONO_TYPE_MVAR)) && mini_type_var_is_vt (rtype)) {
7025                 MONO_EMIT_NEW_DUMMY_INIT (cfg, dreg, OP_DUMMY_VZERO);
7026         } else {
7027                 emit_init_rvar (cfg, dreg, rtype);
7028         }
7029 }
7030
7031 /* If INIT is FALSE, emit dummy initialization statements to keep the IR valid */
7032 static void
7033 emit_init_local (MonoCompile *cfg, int local, MonoType *type, gboolean init)
7034 {
7035         MonoInst *var = cfg->locals [local];
7036         if (COMPILE_SOFT_FLOAT (cfg)) {
7037                 MonoInst *store;
7038                 int reg = alloc_dreg (cfg, (MonoStackType)var->type);
7039                 emit_init_rvar (cfg, reg, type);
7040                 EMIT_NEW_LOCSTORE (cfg, store, local, cfg->cbb->last_ins);
7041         } else {
7042                 if (init)
7043                         emit_init_rvar (cfg, var->dreg, type);
7044                 else
7045                         emit_dummy_init_rvar (cfg, var->dreg, type);
7046         }
7047 }
7048
7049 /*
7050  * inline_method:
7051  *
7052  *   Return the cost of inlining CMETHOD.
7053  */
7054 static int
7055 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
7056                            guchar *ip, guint real_offset, gboolean inline_always)
7057 {
7058         MonoInst *ins, *rvar = NULL;
7059         MonoMethodHeader *cheader;
7060         MonoBasicBlock *ebblock, *sbblock;
7061         int i, costs;
7062         MonoMethod *prev_inlined_method;
7063         MonoInst **prev_locals, **prev_args;
7064         MonoType **prev_arg_types;
7065         guint prev_real_offset;
7066         GHashTable *prev_cbb_hash;
7067         MonoBasicBlock **prev_cil_offset_to_bb;
7068         MonoBasicBlock *prev_cbb;
7069         unsigned char* prev_cil_start;
7070         guint32 prev_cil_offset_to_bb_len;
7071         MonoMethod *prev_current_method;
7072         MonoGenericContext *prev_generic_context;
7073         gboolean ret_var_set, prev_ret_var_set, prev_disable_inline, virtual_ = FALSE;
7074
7075         g_assert (cfg->exception_type == MONO_EXCEPTION_NONE);
7076
7077 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
7078         if ((! inline_always) && ! check_inline_called_method_name_limit (cmethod))
7079                 return 0;
7080 #endif
7081 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
7082         if ((! inline_always) && ! check_inline_caller_method_name_limit (cfg->method))
7083                 return 0;
7084 #endif
7085
7086         if (!fsig)
7087                 fsig = mono_method_signature (cmethod);
7088
7089         if (cfg->verbose_level > 2)
7090                 printf ("INLINE START %p %s -> %s\n", cmethod,  mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7091
7092         if (!cmethod->inline_info) {
7093                 cfg->stat_inlineable_methods++;
7094                 cmethod->inline_info = 1;
7095         }
7096
7097         /* allocate local variables */
7098         cheader = mono_method_get_header (cmethod);
7099
7100         if (cheader == NULL || mono_loader_get_last_error ()) {
7101                 if (cheader)
7102                         mono_metadata_free_mh (cheader);
7103                 if (inline_always && mono_loader_get_last_error ()) {
7104                         mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
7105                         mono_error_set_from_loader_error (&cfg->error);
7106                 }
7107
7108                 mono_loader_clear_error ();
7109                 return 0;
7110         }
7111
7112         /*Must verify before creating locals as it can cause the JIT to assert.*/
7113         if (mono_compile_is_broken (cfg, cmethod, FALSE)) {
7114                 mono_metadata_free_mh (cheader);
7115                 return 0;
7116         }
7117
7118         /* allocate space to store the return value */
7119         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
7120                 rvar = mono_compile_create_var (cfg, fsig->ret, OP_LOCAL);
7121         }
7122
7123         prev_locals = cfg->locals;
7124         cfg->locals = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
7125         for (i = 0; i < cheader->num_locals; ++i)
7126                 cfg->locals [i] = mono_compile_create_var (cfg, cheader->locals [i], OP_LOCAL);
7127
7128         /* allocate start and end blocks */
7129         /* This is needed so if the inline is aborted, we can clean up */
7130         NEW_BBLOCK (cfg, sbblock);
7131         sbblock->real_offset = real_offset;
7132
7133         NEW_BBLOCK (cfg, ebblock);
7134         ebblock->block_num = cfg->num_bblocks++;
7135         ebblock->real_offset = real_offset;
7136
7137         prev_args = cfg->args;
7138         prev_arg_types = cfg->arg_types;
7139         prev_inlined_method = cfg->inlined_method;
7140         cfg->inlined_method = cmethod;
7141         cfg->ret_var_set = FALSE;
7142         cfg->inline_depth ++;
7143         prev_real_offset = cfg->real_offset;
7144         prev_cbb_hash = cfg->cbb_hash;
7145         prev_cil_offset_to_bb = cfg->cil_offset_to_bb;
7146         prev_cil_offset_to_bb_len = cfg->cil_offset_to_bb_len;
7147         prev_cil_start = cfg->cil_start;
7148         prev_cbb = cfg->cbb;
7149         prev_current_method = cfg->current_method;
7150         prev_generic_context = cfg->generic_context;
7151         prev_ret_var_set = cfg->ret_var_set;
7152         prev_disable_inline = cfg->disable_inline;
7153
7154         if (ip && *ip == CEE_CALLVIRT && !(cmethod->flags & METHOD_ATTRIBUTE_STATIC))
7155                 virtual_ = TRUE;
7156
7157         costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, sp, real_offset, virtual_);
7158
7159         ret_var_set = cfg->ret_var_set;
7160
7161         cfg->inlined_method = prev_inlined_method;
7162         cfg->real_offset = prev_real_offset;
7163         cfg->cbb_hash = prev_cbb_hash;
7164         cfg->cil_offset_to_bb = prev_cil_offset_to_bb;
7165         cfg->cil_offset_to_bb_len = prev_cil_offset_to_bb_len;
7166         cfg->cil_start = prev_cil_start;
7167         cfg->locals = prev_locals;
7168         cfg->args = prev_args;
7169         cfg->arg_types = prev_arg_types;
7170         cfg->current_method = prev_current_method;
7171         cfg->generic_context = prev_generic_context;
7172         cfg->ret_var_set = prev_ret_var_set;
7173         cfg->disable_inline = prev_disable_inline;
7174         cfg->inline_depth --;
7175
7176         if ((costs >= 0 && costs < 60) || inline_always || (costs >= 0 && (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_AGGRESSIVE_INLINING))) {
7177                 if (cfg->verbose_level > 2)
7178                         printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
7179
7180                 cfg->stat_inlined_methods++;
7181
7182                 /* always add some code to avoid block split failures */
7183                 MONO_INST_NEW (cfg, ins, OP_NOP);
7184                 MONO_ADD_INS (prev_cbb, ins);
7185
7186                 prev_cbb->next_bb = sbblock;
7187                 link_bblock (cfg, prev_cbb, sbblock);
7188
7189                 /*
7190                  * Get rid of the begin and end bblocks if possible to aid local
7191                  * optimizations.
7192                  */
7193                 mono_merge_basic_blocks (cfg, prev_cbb, sbblock);
7194
7195                 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
7196                         mono_merge_basic_blocks (cfg, prev_cbb, prev_cbb->out_bb [0]);
7197
7198                 if ((ebblock->in_count == 1) && ebblock->in_bb [0]->out_count == 1) {
7199                         MonoBasicBlock *prev = ebblock->in_bb [0];
7200
7201                         if (prev->next_bb == ebblock) {
7202                                 mono_merge_basic_blocks (cfg, prev, ebblock);
7203                                 cfg->cbb = prev;
7204                                 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
7205                                         mono_merge_basic_blocks (cfg, prev_cbb, prev);
7206                                         cfg->cbb = prev_cbb;
7207                                 }
7208                         } else {
7209                                 /* There could be a bblock after 'prev', and making 'prev' the current bb could cause problems */
7210                                 cfg->cbb = ebblock;
7211                         }
7212                 } else {
7213                         /*
7214                          * Its possible that the rvar is set in some prev bblock, but not in others.
7215                          * (#1835).
7216                          */
7217                         if (rvar) {
7218                                 MonoBasicBlock *bb;
7219
7220                                 for (i = 0; i < ebblock->in_count; ++i) {
7221                                         bb = ebblock->in_bb [i];
7222
7223                                         if (bb->last_ins && bb->last_ins->opcode == OP_NOT_REACHED) {
7224                                                 cfg->cbb = bb;
7225
7226                                                 emit_init_rvar (cfg, rvar->dreg, fsig->ret);
7227                                         }
7228                                 }
7229                         }
7230
7231                         cfg->cbb = ebblock;
7232                 }
7233
7234                 if (rvar) {
7235                         /*
7236                          * If the inlined method contains only a throw, then the ret var is not
7237                          * set, so set it to a dummy value.
7238                          */
7239                         if (!ret_var_set)
7240                                 emit_init_rvar (cfg, rvar->dreg, fsig->ret);
7241
7242                         EMIT_NEW_TEMPLOAD (cfg, ins, rvar->inst_c0);
7243                         *sp++ = ins;
7244                 }
7245                 cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, cheader);
7246                 return costs + 1;
7247         } else {
7248                 if (cfg->verbose_level > 2)
7249                         printf ("INLINE ABORTED %s (cost %d)\n", mono_method_full_name (cmethod, TRUE), costs);
7250                 cfg->exception_type = MONO_EXCEPTION_NONE;
7251                 mono_loader_clear_error ();
7252
7253                 /* This gets rid of the newly added bblocks */
7254                 cfg->cbb = prev_cbb;
7255         }
7256         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, cheader);
7257         return 0;
7258 }
7259
7260 /*
7261  * Some of these comments may well be out-of-date.
7262  * Design decisions: we do a single pass over the IL code (and we do bblock
7263  * splitting/merging in the few cases when it's required: a back jump to an IL
7264  * address that was not already seen as bblock starting point).
7265  * Code is validated as we go (full verification is still better left to metadata/verify.c).
7266  * Complex operations are decomposed in simpler ones right away. We need to let the
7267  * arch-specific code peek and poke inside this process somehow (except when the
7268  * optimizations can take advantage of the full semantic info of coarse opcodes).
7269  * All the opcodes of the form opcode.s are 'normalized' to opcode.
7270  * MonoInst->opcode initially is the IL opcode or some simplification of that
7271  * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
7272  * opcode with value bigger than OP_LAST.
7273  * At this point the IR can be handed over to an interpreter, a dumb code generator
7274  * or to the optimizing code generator that will translate it to SSA form.
7275  *
7276  * Profiling directed optimizations.
7277  * We may compile by default with few or no optimizations and instrument the code
7278  * or the user may indicate what methods to optimize the most either in a config file
7279  * or through repeated runs where the compiler applies offline the optimizations to
7280  * each method and then decides if it was worth it.
7281  */
7282
7283 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
7284 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
7285 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
7286 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
7287 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
7288 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
7289 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
7290 #define CHECK_TYPELOAD(klass) if (!(klass) || mono_class_has_failure (klass)) TYPE_LOAD_ERROR ((klass))
7291
7292 /* offset from br.s -> br like opcodes */
7293 #define BIG_BRANCH_OFFSET 13
7294
7295 static gboolean
7296 ip_in_bb (MonoCompile *cfg, MonoBasicBlock *bb, const guint8* ip)
7297 {
7298         MonoBasicBlock *b = cfg->cil_offset_to_bb [ip - cfg->cil_start];
7299
7300         return b == NULL || b == bb;
7301 }
7302
7303 static int
7304 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
7305 {
7306         unsigned char *ip = start;
7307         unsigned char *target;
7308         int i;
7309         guint cli_addr;
7310         MonoBasicBlock *bblock;
7311         const MonoOpcode *opcode;
7312
7313         while (ip < end) {
7314                 cli_addr = ip - start;
7315                 i = mono_opcode_value ((const guint8 **)&ip, end);
7316                 if (i < 0)
7317                         UNVERIFIED;
7318                 opcode = &mono_opcodes [i];
7319                 switch (opcode->argument) {
7320                 case MonoInlineNone:
7321                         ip++;
7322                         break;
7323                 case MonoInlineString:
7324                 case MonoInlineType:
7325                 case MonoInlineField:
7326                 case MonoInlineMethod:
7327                 case MonoInlineTok:
7328                 case MonoInlineSig:
7329                 case MonoShortInlineR:
7330                 case MonoInlineI:
7331                         ip += 5;
7332                         break;
7333                 case MonoInlineVar:
7334                         ip += 3;
7335                         break;
7336                 case MonoShortInlineVar:
7337                 case MonoShortInlineI:
7338                         ip += 2;
7339                         break;
7340                 case MonoShortInlineBrTarget:
7341                         target = start + cli_addr + 2 + (signed char)ip [1];
7342                         GET_BBLOCK (cfg, bblock, target);
7343                         ip += 2;
7344                         if (ip < end)
7345                                 GET_BBLOCK (cfg, bblock, ip);
7346                         break;
7347                 case MonoInlineBrTarget:
7348                         target = start + cli_addr + 5 + (gint32)read32 (ip + 1);
7349                         GET_BBLOCK (cfg, bblock, target);
7350                         ip += 5;
7351                         if (ip < end)
7352                                 GET_BBLOCK (cfg, bblock, ip);
7353                         break;
7354                 case MonoInlineSwitch: {
7355                         guint32 n = read32 (ip + 1);
7356                         guint32 j;
7357                         ip += 5;
7358                         cli_addr += 5 + 4 * n;
7359                         target = start + cli_addr;
7360                         GET_BBLOCK (cfg, bblock, target);
7361
7362                         for (j = 0; j < n; ++j) {
7363                                 target = start + cli_addr + (gint32)read32 (ip);
7364                                 GET_BBLOCK (cfg, bblock, target);
7365                                 ip += 4;
7366                         }
7367                         break;
7368                 }
7369                 case MonoInlineR:
7370                 case MonoInlineI8:
7371                         ip += 9;
7372                         break;
7373                 default:
7374                         g_assert_not_reached ();
7375                 }
7376
7377                 if (i == CEE_THROW) {
7378                         unsigned char *bb_start = ip - 1;
7379
7380                         /* Find the start of the bblock containing the throw */
7381                         bblock = NULL;
7382                         while ((bb_start >= start) && !bblock) {
7383                                 bblock = cfg->cil_offset_to_bb [(bb_start) - start];
7384                                 bb_start --;
7385                         }
7386                         if (bblock)
7387                                 bblock->out_of_line = 1;
7388                 }
7389         }
7390         return 0;
7391 unverified:
7392 exception_exit:
7393         *pos = ip;
7394         return 1;
7395 }
7396
7397 static inline MonoMethod *
7398 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error)
7399 {
7400         MonoMethod *method;
7401
7402         mono_error_init (error);
7403
7404         if (m->wrapper_type != MONO_WRAPPER_NONE) {
7405                 method = (MonoMethod *)mono_method_get_wrapper_data (m, token);
7406                 if (context) {
7407                         method = mono_class_inflate_generic_method_checked (method, context, error);
7408                 }
7409         } else {
7410                 method = mono_get_method_checked (m->klass->image, token, klass, context, error);
7411         }
7412
7413         return method;
7414 }
7415
7416 static inline MonoMethod *
7417 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
7418 {
7419         MonoError error;
7420         MonoMethod *method = mini_get_method_allow_open (m, token, klass, context, cfg ? &cfg->error : &error);
7421
7422         if (method && cfg && !cfg->gshared && mono_class_is_open_constructed_type (&method->klass->byval_arg)) {
7423                 mono_error_set_bad_image (&cfg->error, cfg->method->klass->image, "Method with open type while not compiling gshared");
7424                 method = NULL;
7425         }
7426
7427         if (!method && !cfg)
7428                 mono_error_cleanup (&error); /* FIXME don't swallow the error */
7429
7430         return method;
7431 }
7432
7433 static inline MonoClass*
7434 mini_get_class (MonoMethod *method, guint32 token, MonoGenericContext *context)
7435 {
7436         MonoError error;
7437         MonoClass *klass;
7438
7439         if (method->wrapper_type != MONO_WRAPPER_NONE) {
7440                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
7441                 if (context)
7442                         klass = mono_class_inflate_generic_class (klass, context);
7443         } else {
7444                 klass = mono_class_get_and_inflate_typespec_checked (method->klass->image, token, context, &error);
7445                 mono_error_cleanup (&error); /* FIXME don't swallow the error */
7446         }
7447         if (klass)
7448                 mono_class_init (klass);
7449         return klass;
7450 }
7451
7452 static inline MonoMethodSignature*
7453 mini_get_signature (MonoMethod *method, guint32 token, MonoGenericContext *context)
7454 {
7455         MonoMethodSignature *fsig;
7456
7457         if (method->wrapper_type != MONO_WRAPPER_NONE) {
7458                 fsig = (MonoMethodSignature *)mono_method_get_wrapper_data (method, token);
7459         } else {
7460                 fsig = mono_metadata_parse_signature (method->klass->image, token);
7461         }
7462         if (context) {
7463                 MonoError error;
7464                 fsig = mono_inflate_generic_signature(fsig, context, &error);
7465                 // FIXME:
7466                 g_assert(mono_error_ok(&error));
7467         }
7468         return fsig;
7469 }
7470
7471 static MonoMethod*
7472 throw_exception (void)
7473 {
7474         static MonoMethod *method = NULL;
7475
7476         if (!method) {
7477                 MonoSecurityManager *secman = mono_security_manager_get_methods ();
7478                 method = mono_class_get_method_from_name (secman->securitymanager, "ThrowException", 1);
7479         }
7480         g_assert (method);
7481         return method;
7482 }
7483
7484 static void
7485 emit_throw_exception (MonoCompile *cfg, MonoException *ex)
7486 {
7487         MonoMethod *thrower = throw_exception ();
7488         MonoInst *args [1];
7489
7490         EMIT_NEW_PCONST (cfg, args [0], ex);
7491         mono_emit_method_call (cfg, thrower, args, NULL);
7492 }
7493
7494 /*
7495  * Return the original method is a wrapper is specified. We can only access
7496  * the custom attributes from the original method.
7497  */
7498 static MonoMethod*
7499 get_original_method (MonoMethod *method)
7500 {
7501         if (method->wrapper_type == MONO_WRAPPER_NONE)
7502                 return method;
7503
7504         /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
7505         if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)
7506                 return NULL;
7507
7508         /* in other cases we need to find the original method */
7509         return mono_marshal_method_from_wrapper (method);
7510 }
7511
7512 static void
7513 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field)
7514 {
7515         /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7516         MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
7517         if (ex)
7518                 emit_throw_exception (cfg, ex);
7519 }
7520
7521 static void
7522 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
7523 {
7524         /* we can't get the coreclr security level on wrappers since they don't have the attributes */
7525         MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
7526         if (ex)
7527                 emit_throw_exception (cfg, ex);
7528 }
7529
7530 /*
7531  * Check that the IL instructions at ip are the array initialization
7532  * sequence and return the pointer to the data and the size.
7533  */
7534 static const char*
7535 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
7536 {
7537         /*
7538          * newarr[System.Int32]
7539          * dup
7540          * ldtoken field valuetype ...
7541          * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
7542          */
7543         if (ip [0] == CEE_DUP && ip [1] == CEE_LDTOKEN && ip [5] == 0x4 && ip [6] == CEE_CALL) {
7544                 MonoError error;
7545                 guint32 token = read32 (ip + 7);
7546                 guint32 field_token = read32 (ip + 2);
7547                 guint32 field_index = field_token & 0xffffff;
7548                 guint32 rva;
7549                 const char *data_ptr;
7550                 int size = 0;
7551                 MonoMethod *cmethod;
7552                 MonoClass *dummy_class;
7553                 MonoClassField *field = mono_field_from_token_checked (method->klass->image, field_token, &dummy_class, NULL, &error);
7554                 int dummy_align;
7555
7556                 if (!field) {
7557                         mono_error_cleanup (&error); /* FIXME don't swallow the error */
7558                         return NULL;
7559                 }
7560
7561                 *out_field_token = field_token;
7562
7563                 cmethod = mini_get_method (NULL, method, token, NULL, NULL);
7564                 if (!cmethod)
7565                         return NULL;
7566                 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
7567                         return NULL;
7568                 switch (mono_type_get_underlying_type (&klass->byval_arg)->type) {
7569                 case MONO_TYPE_BOOLEAN:
7570                 case MONO_TYPE_I1:
7571                 case MONO_TYPE_U1:
7572                         size = 1; break;
7573                 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
7574 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
7575                 case MONO_TYPE_CHAR:
7576                 case MONO_TYPE_I2:
7577                 case MONO_TYPE_U2:
7578                         size = 2; break;
7579                 case MONO_TYPE_I4:
7580                 case MONO_TYPE_U4:
7581                 case MONO_TYPE_R4:
7582                         size = 4; break;
7583                 case MONO_TYPE_R8:
7584                 case MONO_TYPE_I8:
7585                 case MONO_TYPE_U8:
7586                         size = 8; break;
7587 #endif
7588                 default:
7589                         return NULL;
7590                 }
7591                 size *= len;
7592                 if (size > mono_type_size (field->type, &dummy_align))
7593                     return NULL;
7594                 *out_size = size;
7595                 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
7596                 if (!image_is_dynamic (method->klass->image)) {
7597                         field_index = read32 (ip + 2) & 0xffffff;
7598                         mono_metadata_field_info (method->klass->image, field_index - 1, NULL, &rva, NULL);
7599                         data_ptr = mono_image_rva_map (method->klass->image, rva);
7600                         /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
7601                         /* for aot code we do the lookup on load */
7602                         if (aot && data_ptr)
7603                                 return (const char *)GUINT_TO_POINTER (rva);
7604                 } else {
7605                         /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
7606                         g_assert (!aot);
7607                         data_ptr = mono_field_get_data (field);
7608                 }
7609                 return data_ptr;
7610         }
7611         return NULL;
7612 }
7613
7614 static void
7615 set_exception_type_from_invalid_il (MonoCompile *cfg, MonoMethod *method, unsigned char *ip)
7616 {
7617         char *method_fname = mono_method_full_name (method, TRUE);
7618         char *method_code;
7619         MonoMethodHeader *header = mono_method_get_header (method);
7620
7621         if (header->code_size == 0)
7622                 method_code = g_strdup ("method body is empty.");
7623         else
7624                 method_code = mono_disasm_code_one (NULL, method, ip, NULL);
7625         mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code));
7626         g_free (method_fname);
7627         g_free (method_code);
7628         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
7629 }
7630
7631 static void
7632 emit_stloc_ir (MonoCompile *cfg, MonoInst **sp, MonoMethodHeader *header, int n)
7633 {
7634         MonoInst *ins;
7635         guint32 opcode = mono_type_to_regmove (cfg, header->locals [n]);
7636         if ((opcode == OP_MOVE) && cfg->cbb->last_ins == sp [0]  &&
7637                         ((sp [0]->opcode == OP_ICONST) || (sp [0]->opcode == OP_I8CONST))) {
7638                 /* Optimize reg-reg moves away */
7639                 /*
7640                  * Can't optimize other opcodes, since sp[0] might point to
7641                  * the last ins of a decomposed opcode.
7642                  */
7643                 sp [0]->dreg = (cfg)->locals [n]->dreg;
7644         } else {
7645                 EMIT_NEW_LOCSTORE (cfg, ins, n, *sp);
7646         }
7647 }
7648
7649 /*
7650  * ldloca inhibits many optimizations so try to get rid of it in common
7651  * cases.
7652  */
7653 static inline unsigned char *
7654 emit_optimized_ldloca_ir (MonoCompile *cfg, unsigned char *ip, unsigned char *end, int size)
7655 {
7656         int local, token;
7657         MonoClass *klass;
7658         MonoType *type;
7659
7660         if (size == 1) {
7661                 local = ip [1];
7662                 ip += 2;
7663         } else {
7664                 local = read16 (ip + 2);
7665                 ip += 4;
7666         }
7667
7668         if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
7669                 /* From the INITOBJ case */
7670                 token = read32 (ip + 2);
7671                 klass = mini_get_class (cfg->current_method, token, cfg->generic_context);
7672                 CHECK_TYPELOAD (klass);
7673                 type = mini_get_underlying_type (&klass->byval_arg);
7674                 emit_init_local (cfg, local, type, TRUE);
7675                 return ip + 6;
7676         }
7677  exception_exit:
7678         return NULL;
7679 }
7680
7681 static MonoInst*
7682 emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used, MonoInst **sp)
7683 {
7684         MonoInst *icall_args [16];
7685         MonoInst *call_target, *ins, *vtable_ins;
7686         int arg_reg, this_reg, vtable_reg;
7687         gboolean is_iface = cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE;
7688         gboolean is_gsharedvt = cfg->gsharedvt && mini_is_gsharedvt_variable_signature (fsig);
7689         gboolean variant_iface = FALSE;
7690         guint32 slot;
7691         int offset;
7692
7693         /*
7694          * In llvm-only mode, vtables contain function descriptors instead of
7695          * method addresses/trampolines.
7696          */
7697         MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg);
7698
7699         if (is_iface)
7700                 slot = mono_method_get_imt_slot (cmethod);
7701         else
7702                 slot = mono_method_get_vtable_index (cmethod);
7703
7704         this_reg = sp [0]->dreg;
7705
7706         if (is_iface && mono_class_has_variant_generic_params (cmethod->klass))
7707                 variant_iface = TRUE;
7708
7709         if (!fsig->generic_param_count && !is_iface && !is_gsharedvt) {
7710                 /*
7711                  * The simplest case, a normal virtual call.
7712                  */
7713                 int slot_reg = alloc_preg (cfg);
7714                 int addr_reg = alloc_preg (cfg);
7715                 int arg_reg = alloc_preg (cfg);
7716                 MonoBasicBlock *non_null_bb;
7717
7718                 vtable_reg = alloc_preg (cfg);
7719                 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7720                 offset = MONO_STRUCT_OFFSET (MonoVTable, vtable) + (slot * SIZEOF_VOID_P);
7721
7722                 /* Load the vtable slot, which contains a function descriptor. */
7723                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, slot_reg, vtable_reg, offset);
7724
7725                 NEW_BBLOCK (cfg, non_null_bb);
7726
7727                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, slot_reg, 0);
7728                 cfg->cbb->last_ins->flags |= MONO_INST_LIKELY;
7729                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, non_null_bb);
7730
7731                 /* Slow path */
7732                 // FIXME: Make the wrapper use the preserveall cconv
7733                 // FIXME: Use one icall per slot for small slot numbers ?
7734                 icall_args [0] = vtable_ins;
7735                 EMIT_NEW_ICONST (cfg, icall_args [1], slot);
7736                 /* Make the icall return the vtable slot value to save some code space */
7737                 ins = mono_emit_jit_icall (cfg, mono_init_vtable_slot, icall_args);
7738                 ins->dreg = slot_reg;
7739                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, non_null_bb);
7740
7741                 /* Fastpath */
7742                 MONO_START_BB (cfg, non_null_bb);
7743                 /* Load the address + arg from the vtable slot */
7744                 EMIT_NEW_LOAD_MEMBASE (cfg, call_target, OP_LOAD_MEMBASE, addr_reg, slot_reg, 0);
7745                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, arg_reg, slot_reg, SIZEOF_VOID_P);
7746
7747                 return emit_extra_arg_calli (cfg, fsig, sp, arg_reg, call_target);
7748         }
7749
7750         if (!fsig->generic_param_count && is_iface && !variant_iface && !is_gsharedvt) {
7751                 /*
7752                  * A simple interface call
7753                  *
7754                  * We make a call through an imt slot to obtain the function descriptor we need to call.
7755                  * The imt slot contains a function descriptor for a runtime function + arg.
7756                  */
7757                 int slot_reg = alloc_preg (cfg);
7758                 int addr_reg = alloc_preg (cfg);
7759                 int arg_reg = alloc_preg (cfg);
7760                 MonoInst *thunk_addr_ins, *thunk_arg_ins, *ftndesc_ins;
7761
7762                 vtable_reg = alloc_preg (cfg);
7763                 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7764                 offset = ((gint32)slot - MONO_IMT_SIZE) * SIZEOF_VOID_P;
7765
7766                 /*
7767                  * The slot is already initialized when the vtable is created so there is no need
7768                  * to check it here.
7769                  */
7770
7771                 /* Load the imt slot, which contains a function descriptor. */
7772                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, slot_reg, vtable_reg, offset);
7773
7774                 /* Load the address + arg of the imt thunk from the imt slot */
7775                 EMIT_NEW_LOAD_MEMBASE (cfg, thunk_addr_ins, OP_LOAD_MEMBASE, addr_reg, slot_reg, 0);
7776                 EMIT_NEW_LOAD_MEMBASE (cfg, thunk_arg_ins, OP_LOAD_MEMBASE, arg_reg, slot_reg, SIZEOF_VOID_P);
7777                 /*
7778                  * IMT thunks in llvm-only mode are C functions which take an info argument
7779                  * plus the imt method and return the ftndesc to call.
7780                  */
7781                 icall_args [0] = thunk_arg_ins;
7782                 icall_args [1] = emit_get_rgctx_method (cfg, context_used,
7783                                                                                                 cmethod, MONO_RGCTX_INFO_METHOD);
7784                 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_thunk, icall_args, thunk_addr_ins, NULL, NULL);
7785
7786                 return emit_llvmonly_calli (cfg, fsig, sp, ftndesc_ins);
7787         }
7788
7789         if ((fsig->generic_param_count || variant_iface) && !is_gsharedvt) {
7790                 /*
7791                  * This is similar to the interface case, the vtable slot points to an imt thunk which is
7792                  * dynamically extended as more instantiations are discovered.
7793                  * This handles generic virtual methods both on classes and interfaces.
7794                  */
7795                 int slot_reg = alloc_preg (cfg);
7796                 int addr_reg = alloc_preg (cfg);
7797                 int arg_reg = alloc_preg (cfg);
7798                 int ftndesc_reg = alloc_preg (cfg);
7799                 MonoInst *thunk_addr_ins, *thunk_arg_ins, *ftndesc_ins;
7800                 MonoBasicBlock *slowpath_bb, *end_bb;
7801
7802                 NEW_BBLOCK (cfg, slowpath_bb);
7803                 NEW_BBLOCK (cfg, end_bb);
7804
7805                 vtable_reg = alloc_preg (cfg);
7806                 EMIT_NEW_LOAD_MEMBASE (cfg, vtable_ins, OP_LOAD_MEMBASE, vtable_reg, this_reg, MONO_STRUCT_OFFSET (MonoObject, vtable));
7807                 if (is_iface)
7808                         offset = ((gint32)slot - MONO_IMT_SIZE) * SIZEOF_VOID_P;
7809                 else
7810                         offset = MONO_STRUCT_OFFSET (MonoVTable, vtable) + (slot * SIZEOF_VOID_P);
7811
7812                 /* Load the slot, which contains a function descriptor. */
7813                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, slot_reg, vtable_reg, offset);
7814
7815                 /* These slots are not initialized, so fall back to the slow path until they are initialized */
7816                 /* That happens when mono_method_add_generic_virtual_invocation () creates an IMT thunk */
7817                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, slot_reg, 0);
7818                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, slowpath_bb);
7819
7820                 /* Fastpath */
7821                 /* Same as with iface calls */
7822                 EMIT_NEW_LOAD_MEMBASE (cfg, thunk_addr_ins, OP_LOAD_MEMBASE, addr_reg, slot_reg, 0);
7823                 EMIT_NEW_LOAD_MEMBASE (cfg, thunk_arg_ins, OP_LOAD_MEMBASE, arg_reg, slot_reg, SIZEOF_VOID_P);
7824                 icall_args [0] = thunk_arg_ins;
7825                 icall_args [1] = emit_get_rgctx_method (cfg, context_used,
7826                                                                                                 cmethod, MONO_RGCTX_INFO_METHOD);
7827                 ftndesc_ins = mono_emit_calli (cfg, helper_sig_llvmonly_imt_thunk, icall_args, thunk_addr_ins, NULL, NULL);
7828                 ftndesc_ins->dreg = ftndesc_reg;
7829                 /*
7830                  * Unlike normal iface calls, these imt thunks can return NULL, i.e. when they are passed an instantiation
7831                  * they don't know about yet. Fall back to the slowpath in that case.
7832                  */
7833                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, ftndesc_reg, 0);
7834                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, slowpath_bb);
7835
7836                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
7837
7838                 /* Slowpath */
7839                 MONO_START_BB (cfg, slowpath_bb);
7840                 icall_args [0] = vtable_ins;
7841                 EMIT_NEW_ICONST (cfg, icall_args [1], slot);
7842                 icall_args [2] = emit_get_rgctx_method (cfg, context_used,
7843                                                                                                 cmethod, MONO_RGCTX_INFO_METHOD);
7844                 if (is_iface)
7845                         ftndesc_ins = mono_emit_jit_icall (cfg, mono_resolve_generic_virtual_iface_call, icall_args);
7846                 else
7847                         ftndesc_ins = mono_emit_jit_icall (cfg, mono_resolve_generic_virtual_call, icall_args);
7848                 ftndesc_ins->dreg = ftndesc_reg;
7849                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
7850
7851                 /* Common case */
7852                 MONO_START_BB (cfg, end_bb);
7853                 return emit_llvmonly_calli (cfg, fsig, sp, ftndesc_ins);
7854         }
7855
7856         /*
7857          * Non-optimized cases
7858          */
7859         icall_args [0] = sp [0];
7860         EMIT_NEW_ICONST (cfg, icall_args [1], slot);
7861
7862         icall_args [2] = emit_get_rgctx_method (cfg, context_used,
7863                                                                                         cmethod, MONO_RGCTX_INFO_METHOD);
7864
7865         arg_reg = alloc_preg (cfg);
7866         MONO_EMIT_NEW_PCONST (cfg, arg_reg, NULL);
7867         EMIT_NEW_VARLOADA_VREG (cfg, icall_args [3], arg_reg, &mono_defaults.int_class->byval_arg);
7868
7869         g_assert (is_gsharedvt);
7870         if (is_iface)
7871                 call_target = mono_emit_jit_icall (cfg, mono_resolve_iface_call_gsharedvt, icall_args);
7872         else
7873                 call_target = mono_emit_jit_icall (cfg, mono_resolve_vcall_gsharedvt, icall_args);
7874
7875         /*
7876          * Pass the extra argument even if the callee doesn't receive it, most
7877          * calling conventions allow this.
7878          */
7879         return emit_extra_arg_calli (cfg, fsig, sp, arg_reg, call_target);
7880 }
7881
7882 static gboolean
7883 is_exception_class (MonoClass *klass)
7884 {
7885         while (klass) {
7886                 if (klass == mono_defaults.exception_class)
7887                         return TRUE;
7888                 klass = klass->parent;
7889         }
7890         return FALSE;
7891 }
7892
7893 /*
7894  * is_jit_optimizer_disabled:
7895  *
7896  *   Determine whenever M's assembly has a DebuggableAttribute with the
7897  * IsJITOptimizerDisabled flag set.
7898  */
7899 static gboolean
7900 is_jit_optimizer_disabled (MonoMethod *m)
7901 {
7902         MonoError error;
7903         MonoAssembly *ass = m->klass->image->assembly;
7904         MonoCustomAttrInfo* attrs;
7905         MonoClass *klass;
7906         int i;
7907         gboolean val = FALSE;
7908
7909         g_assert (ass);
7910         if (ass->jit_optimizer_disabled_inited)
7911                 return ass->jit_optimizer_disabled;
7912
7913         klass = mono_class_try_get_debuggable_attribute_class ();
7914
7915         if (!klass) {
7916                 /* Linked away */
7917                 ass->jit_optimizer_disabled = FALSE;
7918                 mono_memory_barrier ();
7919                 ass->jit_optimizer_disabled_inited = TRUE;
7920                 return FALSE;
7921         }
7922
7923         attrs = mono_custom_attrs_from_assembly_checked (ass, &error);
7924         mono_error_cleanup (&error); /* FIXME don't swallow the error */
7925         if (attrs) {
7926                 for (i = 0; i < attrs->num_attrs; ++i) {
7927                         MonoCustomAttrEntry *attr = &attrs->attrs [i];
7928                         const gchar *p;
7929                         MonoMethodSignature *sig;
7930
7931                         if (!attr->ctor || attr->ctor->klass != klass)
7932                                 continue;
7933                         /* Decode the attribute. See reflection.c */
7934                         p = (const char*)attr->data;
7935                         g_assert (read16 (p) == 0x0001);
7936                         p += 2;
7937
7938                         // FIXME: Support named parameters
7939                         sig = mono_method_signature (attr->ctor);
7940                         if (sig->param_count != 2 || sig->params [0]->type != MONO_TYPE_BOOLEAN || sig->params [1]->type != MONO_TYPE_BOOLEAN)
7941                                 continue;
7942                         /* Two boolean arguments */
7943                         p ++;
7944                         val = *p;
7945                 }
7946                 mono_custom_attrs_free (attrs);
7947         }
7948
7949         ass->jit_optimizer_disabled = val;
7950         mono_memory_barrier ();
7951         ass->jit_optimizer_disabled_inited = TRUE;
7952
7953         return val;
7954 }
7955
7956 static gboolean
7957 is_supported_tail_call (MonoCompile *cfg, MonoMethod *method, MonoMethod *cmethod, MonoMethodSignature *fsig, int call_opcode)
7958 {
7959         gboolean supported_tail_call;
7960         int i;
7961
7962         supported_tail_call = mono_arch_tail_call_supported (cfg, mono_method_signature (method), mono_method_signature (cmethod));
7963
7964         for (i = 0; i < fsig->param_count; ++i) {
7965                 if (fsig->params [i]->byref || fsig->params [i]->type == MONO_TYPE_PTR || fsig->params [i]->type == MONO_TYPE_FNPTR)
7966                         /* These can point to the current method's stack */
7967                         supported_tail_call = FALSE;
7968         }
7969         if (fsig->hasthis && cmethod->klass->valuetype)
7970                 /* this might point to the current method's stack */
7971                 supported_tail_call = FALSE;
7972         if (cmethod->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)
7973                 supported_tail_call = FALSE;
7974         if (cfg->method->save_lmf)
7975                 supported_tail_call = FALSE;
7976         if (cmethod->wrapper_type && cmethod->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)
7977                 supported_tail_call = FALSE;
7978         if (call_opcode != CEE_CALL)
7979                 supported_tail_call = FALSE;
7980
7981         /* Debugging support */
7982 #if 0
7983         if (supported_tail_call) {
7984                 if (!mono_debug_count ())
7985                         supported_tail_call = FALSE;
7986         }
7987 #endif
7988
7989         return supported_tail_call;
7990 }
7991
7992 /*
7993  * handle_ctor_call:
7994  *
7995  *   Handle calls made to ctors from NEWOBJ opcodes.
7996  */
7997 static void
7998 handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, int context_used,
7999                                   MonoInst **sp, guint8 *ip, int *inline_costs)
8000 {
8001         MonoInst *vtable_arg = NULL, *callvirt_this_arg = NULL, *ins;
8002
8003         if (cmethod->klass->valuetype && mono_class_generic_sharing_enabled (cmethod->klass) &&
8004                                         mono_method_is_generic_sharable (cmethod, TRUE)) {
8005                 if (cmethod->is_inflated && mono_method_get_context (cmethod)->method_inst) {
8006                         mono_class_vtable (cfg->domain, cmethod->klass);
8007                         CHECK_TYPELOAD (cmethod->klass);
8008
8009                         vtable_arg = emit_get_rgctx_method (cfg, context_used,
8010                                                                                                 cmethod, MONO_RGCTX_INFO_METHOD_RGCTX);
8011                 } else {
8012                         if (context_used) {
8013                                 vtable_arg = emit_get_rgctx_klass (cfg, context_used,
8014                                                                                                    cmethod->klass, MONO_RGCTX_INFO_VTABLE);
8015                         } else {
8016                                 MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
8017
8018                                 CHECK_TYPELOAD (cmethod->klass);
8019                                 EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
8020                         }
8021                 }
8022         }
8023
8024         /* Avoid virtual calls to ctors if possible */
8025         if (mono_class_is_marshalbyref (cmethod->klass))
8026                 callvirt_this_arg = sp [0];
8027
8028         if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
8029                 g_assert (MONO_TYPE_IS_VOID (fsig->ret));
8030                 CHECK_CFG_EXCEPTION;
8031         } else if ((cfg->opt & MONO_OPT_INLINE) && cmethod && !context_used && !vtable_arg &&
8032                            mono_method_check_inlining (cfg, cmethod) &&
8033                            !mono_class_is_subclass_of (cmethod->klass, mono_defaults.exception_class, FALSE)) {
8034                 int costs;
8035
8036                 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, FALSE))) {
8037                         cfg->real_offset += 5;
8038
8039                         *inline_costs += costs - 5;
8040                 } else {
8041                         INLINE_FAILURE ("inline failure");
8042                         // FIXME-VT: Clean this up
8043                         if (cfg->gsharedvt && mini_is_gsharedvt_signature (fsig))
8044                                 GSHAREDVT_FAILURE(*ip);
8045                         mono_emit_method_call_full (cfg, cmethod, fsig, FALSE, sp, callvirt_this_arg, NULL, NULL);
8046                 }
8047         } else if (cfg->gsharedvt && mini_is_gsharedvt_signature (fsig)) {
8048                 MonoInst *addr;
8049
8050                 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE);
8051
8052                 if (cfg->llvm_only) {
8053                         // FIXME: Avoid initializing vtable_arg
8054                         emit_llvmonly_calli (cfg, fsig, sp, addr);
8055                 } else {
8056                         mono_emit_calli (cfg, fsig, sp, addr, NULL, vtable_arg);
8057                 }
8058         } else if (context_used &&
8059                            ((!mono_method_is_generic_sharable_full (cmethod, TRUE, FALSE, FALSE) ||
8060                                  !mono_class_generic_sharing_enabled (cmethod->klass)) || cfg->gsharedvt)) {
8061                 MonoInst *cmethod_addr;
8062
8063                 /* Generic calls made out of gsharedvt methods cannot be patched, so use an indirect call */
8064
8065                 if (cfg->llvm_only) {
8066                         MonoInst *addr = emit_get_rgctx_method (cfg, context_used, cmethod,
8067                                                                                                         MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8068                         emit_llvmonly_calli (cfg, fsig, sp, addr);
8069                 } else {
8070                         cmethod_addr = emit_get_rgctx_method (cfg, context_used,
8071                                                                                                   cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
8072
8073                         mono_emit_calli (cfg, fsig, sp, cmethod_addr, NULL, vtable_arg);
8074                 }
8075         } else {
8076                 INLINE_FAILURE ("ctor call");
8077                 ins = mono_emit_method_call_full (cfg, cmethod, fsig, FALSE, sp,
8078                                                                                   callvirt_this_arg, NULL, vtable_arg);
8079         }
8080  exception_exit:
8081         return;
8082 }
8083
8084 static void
8085 emit_setret (MonoCompile *cfg, MonoInst *val)
8086 {
8087         MonoType *ret_type = mini_get_underlying_type (mono_method_signature (cfg->method)->ret);
8088         MonoInst *ins;
8089
8090         if (mini_type_to_stind (cfg, ret_type) == CEE_STOBJ) {
8091                 MonoInst *ret_addr;
8092
8093                 if (!cfg->vret_addr) {
8094                         EMIT_NEW_VARSTORE (cfg, ins, cfg->ret, ret_type, val);
8095                 } else {
8096                         EMIT_NEW_RETLOADA (cfg, ret_addr);
8097
8098                         EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STOREV_MEMBASE, ret_addr->dreg, 0, val->dreg);
8099                         ins->klass = mono_class_from_mono_type (ret_type);
8100                 }
8101         } else {
8102 #ifdef MONO_ARCH_SOFT_FLOAT_FALLBACK
8103                 if (COMPILE_SOFT_FLOAT (cfg) && !ret_type->byref && ret_type->type == MONO_TYPE_R4) {
8104                         MonoInst *iargs [1];
8105                         MonoInst *conv;
8106
8107                         iargs [0] = val;
8108                         conv = mono_emit_jit_icall (cfg, mono_fload_r4_arg, iargs);
8109                         mono_arch_emit_setret (cfg, cfg->method, conv);
8110                 } else {
8111                         mono_arch_emit_setret (cfg, cfg->method, val);
8112                 }
8113 #else
8114                 mono_arch_emit_setret (cfg, cfg->method, val);
8115 #endif
8116         }
8117 }
8118
8119 /*
8120  * mono_method_to_ir:
8121  *
8122  *   Translate the .net IL into linear IR.
8123  */
8124 int
8125 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
8126                    MonoInst *return_var, MonoInst **inline_args,
8127                    guint inline_offset, gboolean is_virtual_call)
8128 {
8129         MonoError error;
8130         MonoInst *ins, **sp, **stack_start;
8131         MonoBasicBlock *tblock = NULL, *init_localsbb = NULL;
8132         MonoSimpleBasicBlock *bb = NULL, *original_bb = NULL;
8133         MonoMethod *cmethod, *method_definition;
8134         MonoInst **arg_array;
8135         MonoMethodHeader *header;
8136         MonoImage *image;
8137         guint32 token, ins_flag;
8138         MonoClass *klass;
8139         MonoClass *constrained_class = NULL;
8140         unsigned char *ip, *end, *target, *err_pos;
8141         MonoMethodSignature *sig;
8142         MonoGenericContext *generic_context = NULL;
8143         MonoGenericContainer *generic_container = NULL;
8144         MonoType **param_types;
8145         int i, n, start_new_bblock, dreg;
8146         int num_calls = 0, inline_costs = 0;
8147         int breakpoint_id = 0;
8148         guint num_args;
8149         GSList *class_inits = NULL;
8150         gboolean dont_verify, dont_verify_stloc, readonly = FALSE;
8151         int context_used;
8152         gboolean init_locals, seq_points, skip_dead_blocks;
8153         gboolean sym_seq_points = FALSE;
8154         MonoDebugMethodInfo *minfo;
8155         MonoBitSet *seq_point_locs = NULL;
8156         MonoBitSet *seq_point_set_locs = NULL;
8157
8158         cfg->disable_inline = is_jit_optimizer_disabled (method);
8159
8160         /* serialization and xdomain stuff may need access to private fields and methods */
8161         dont_verify = method->klass->image->assembly->corlib_internal? TRUE: FALSE;
8162         dont_verify |= method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE;
8163         dont_verify |= method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH;
8164         dont_verify |= method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE; /* bug #77896 */
8165         dont_verify |= method->wrapper_type == MONO_WRAPPER_COMINTEROP;
8166         dont_verify |= method->wrapper_type == MONO_WRAPPER_COMINTEROP_INVOKE;
8167
8168         /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
8169         dont_verify_stloc = method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE;
8170         dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_UNKNOWN;
8171         dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED;
8172         dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_STELEMREF;
8173
8174         image = method->klass->image;
8175         header = mono_method_get_header (method);
8176         if (!header) {
8177                 if (mono_loader_get_last_error ()) {
8178                         mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
8179                         mono_error_set_from_loader_error (&cfg->error);
8180                 } else {
8181                         mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name));
8182                 }
8183                 goto exception_exit;
8184         }
8185         generic_container = mono_method_get_generic_container (method);
8186         sig = mono_method_signature (method);
8187         num_args = sig->hasthis + sig->param_count;
8188         ip = (unsigned char*)header->code;
8189         cfg->cil_start = ip;
8190         end = ip + header->code_size;
8191         cfg->stat_cil_code_size += header->code_size;
8192
8193         seq_points = cfg->gen_seq_points && cfg->method == method;
8194
8195         if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
8196                 /* We could hit a seq point before attaching to the JIT (#8338) */
8197                 seq_points = FALSE;
8198         }
8199
8200         if (cfg->gen_sdb_seq_points && cfg->method == method) {
8201                 minfo = mono_debug_lookup_method (method);
8202                 if (minfo) {
8203                         MonoSymSeqPoint *sps;
8204                         int i, n_il_offsets;
8205
8206                         mono_debug_get_seq_points (minfo, NULL, NULL, NULL, &sps, &n_il_offsets);
8207                         seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8208                         seq_point_set_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8209                         sym_seq_points = TRUE;
8210                         for (i = 0; i < n_il_offsets; ++i) {
8211                                 if (sps [i].il_offset < header->code_size)
8212                                         mono_bitset_set_fast (seq_point_locs, sps [i].il_offset);
8213                         }
8214                         g_free (sps);
8215                 } else if (!method->wrapper_type && !method->dynamic && mono_debug_image_has_debug_info (method->klass->image)) {
8216                         /* Methods without line number info like auto-generated property accessors */
8217                         seq_point_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8218                         seq_point_set_locs = mono_bitset_mem_new (mono_mempool_alloc0 (cfg->mempool, mono_bitset_alloc_size (header->code_size, 0)), header->code_size, 0);
8219                         sym_seq_points = TRUE;
8220                 }
8221         }
8222
8223         /*
8224          * Methods without init_locals set could cause asserts in various passes
8225          * (#497220). To work around this, we emit dummy initialization opcodes
8226          * (OP_DUMMY_ICONST etc.) which generate no code. These are only supported
8227          * on some platforms.
8228          */
8229         if ((cfg->opt & MONO_OPT_UNSAFE) && cfg->backend->have_dummy_init)
8230                 init_locals = header->init_locals;
8231         else
8232                 init_locals = TRUE;
8233
8234         method_definition = method;
8235         while (method_definition->is_inflated) {
8236                 MonoMethodInflated *imethod = (MonoMethodInflated *) method_definition;
8237                 method_definition = imethod->declaring;
8238         }
8239
8240         /* SkipVerification is not allowed if core-clr is enabled */
8241         if (!dont_verify && mini_assembly_can_skip_verification (cfg->domain, method)) {
8242                 dont_verify = TRUE;
8243                 dont_verify_stloc = TRUE;
8244         }
8245
8246         if (sig->is_inflated)
8247                 generic_context = mono_method_get_context (method);
8248         else if (generic_container)
8249                 generic_context = &generic_container->context;
8250         cfg->generic_context = generic_context;
8251
8252         if (!cfg->gshared)
8253                 g_assert (!sig->has_type_parameters);
8254
8255         if (sig->generic_param_count && method->wrapper_type == MONO_WRAPPER_NONE) {
8256                 g_assert (method->is_inflated);
8257                 g_assert (mono_method_get_context (method)->method_inst);
8258         }
8259         if (method->is_inflated && mono_method_get_context (method)->method_inst)
8260                 g_assert (sig->generic_param_count);
8261
8262         if (cfg->method == method) {
8263                 cfg->real_offset = 0;
8264         } else {
8265                 cfg->real_offset = inline_offset;
8266         }
8267
8268         cfg->cil_offset_to_bb = (MonoBasicBlock **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
8269         cfg->cil_offset_to_bb_len = header->code_size;
8270
8271         cfg->current_method = method;
8272
8273         if (cfg->verbose_level > 2)
8274                 printf ("method to IR %s\n", mono_method_full_name (method, TRUE));
8275
8276         param_types = (MonoType **)mono_mempool_alloc (cfg->mempool, sizeof (MonoType*) * num_args);
8277         if (sig->hasthis)
8278                 param_types [0] = method->klass->valuetype?&method->klass->this_arg:&method->klass->byval_arg;
8279         for (n = 0; n < sig->param_count; ++n)
8280                 param_types [n + sig->hasthis] = sig->params [n];
8281         cfg->arg_types = param_types;
8282
8283         cfg->dont_inline = g_list_prepend (cfg->dont_inline, method);
8284         if (cfg->method == method) {
8285
8286                 if (cfg->prof_options & MONO_PROFILE_INS_COVERAGE)
8287                         cfg->coverage_info = mono_profiler_coverage_alloc (cfg->method, header->code_size);
8288
8289                 /* ENTRY BLOCK */
8290                 NEW_BBLOCK (cfg, start_bblock);
8291                 cfg->bb_entry = start_bblock;
8292                 start_bblock->cil_code = NULL;
8293                 start_bblock->cil_length = 0;
8294
8295                 /* EXIT BLOCK */
8296                 NEW_BBLOCK (cfg, end_bblock);
8297                 cfg->bb_exit = end_bblock;
8298                 end_bblock->cil_code = NULL;
8299                 end_bblock->cil_length = 0;
8300                 end_bblock->flags |= BB_INDIRECT_JUMP_TARGET;
8301                 g_assert (cfg->num_bblocks == 2);
8302
8303                 arg_array = cfg->args;
8304
8305                 if (header->num_clauses) {
8306                         cfg->spvars = g_hash_table_new (NULL, NULL);
8307                         cfg->exvars = g_hash_table_new (NULL, NULL);
8308                 }
8309                 /* handle exception clauses */
8310                 for (i = 0; i < header->num_clauses; ++i) {
8311                         MonoBasicBlock *try_bb;
8312                         MonoExceptionClause *clause = &header->clauses [i];
8313                         GET_BBLOCK (cfg, try_bb, ip + clause->try_offset);
8314
8315                         try_bb->real_offset = clause->try_offset;
8316                         try_bb->try_start = TRUE;
8317                         try_bb->region = ((i + 1) << 8) | clause->flags;
8318                         GET_BBLOCK (cfg, tblock, ip + clause->handler_offset);
8319                         tblock->real_offset = clause->handler_offset;
8320                         tblock->flags |= BB_EXCEPTION_HANDLER;
8321
8322                         /*
8323                          * Linking the try block with the EH block hinders inlining as we won't be able to
8324                          * merge the bblocks from inlining and produce an artificial hole for no good reason.
8325                          */
8326                         if (COMPILE_LLVM (cfg))
8327                                 link_bblock (cfg, try_bb, tblock);
8328
8329                         if (*(ip + clause->handler_offset) == CEE_POP)
8330                                 tblock->flags |= BB_EXCEPTION_DEAD_OBJ;
8331
8332                         if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY ||
8333                             clause->flags == MONO_EXCEPTION_CLAUSE_FILTER ||
8334                             clause->flags == MONO_EXCEPTION_CLAUSE_FAULT) {
8335                                 MONO_INST_NEW (cfg, ins, OP_START_HANDLER);
8336                                 MONO_ADD_INS (tblock, ins);
8337
8338                                 if (seq_points && clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_FILTER) {
8339                                         /* finally clauses already have a seq point */
8340                                         /* seq points for filter clauses are emitted below */
8341                                         NEW_SEQ_POINT (cfg, ins, clause->handler_offset, TRUE);
8342                                         MONO_ADD_INS (tblock, ins);
8343                                 }
8344
8345                                 /* todo: is a fault block unsafe to optimize? */
8346                                 if (clause->flags == MONO_EXCEPTION_CLAUSE_FAULT)
8347                                         tblock->flags |= BB_EXCEPTION_UNSAFE;
8348                         }
8349
8350                         /*printf ("clause try IL_%04x to IL_%04x handler %d at IL_%04x to IL_%04x\n", clause->try_offset, clause->try_offset + clause->try_len, clause->flags, clause->handler_offset, clause->handler_offset + clause->handler_len);
8351                           while (p < end) {
8352                           printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
8353                           }*/
8354                         /* catch and filter blocks get the exception object on the stack */
8355                         if (clause->flags == MONO_EXCEPTION_CLAUSE_NONE ||
8356                             clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
8357
8358                                 /* mostly like handle_stack_args (), but just sets the input args */
8359                                 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
8360                                 tblock->in_scount = 1;
8361                                 tblock->in_stack = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
8362                                 tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
8363
8364                                 cfg->cbb = tblock;
8365
8366 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
8367                                 /* The EH code passes in the exception in a register to both JITted and LLVM compiled code */
8368                                 if (!cfg->compile_llvm) {
8369                                         MONO_INST_NEW (cfg, ins, OP_GET_EX_OBJ);
8370                                         ins->dreg = tblock->in_stack [0]->dreg;
8371                                         MONO_ADD_INS (tblock, ins);
8372                                 }
8373 #else
8374                                 MonoInst *dummy_use;
8375
8376                                 /*
8377                                  * Add a dummy use for the exvar so its liveness info will be
8378                                  * correct.
8379                                  */
8380                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, tblock->in_stack [0]);
8381 #endif
8382
8383                                 if (seq_points && clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
8384                                         NEW_SEQ_POINT (cfg, ins, clause->handler_offset, TRUE);
8385                                         MONO_ADD_INS (tblock, ins);
8386                                 }
8387
8388                                 if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
8389                                         GET_BBLOCK (cfg, tblock, ip + clause->data.filter_offset);
8390                                         tblock->flags |= BB_EXCEPTION_HANDLER;
8391                                         tblock->real_offset = clause->data.filter_offset;
8392                                         tblock->in_scount = 1;
8393                                         tblock->in_stack = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
8394                                         /* The filter block shares the exvar with the handler block */
8395                                         tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
8396                                         MONO_INST_NEW (cfg, ins, OP_START_HANDLER);
8397                                         MONO_ADD_INS (tblock, ins);
8398                                 }
8399                         }
8400
8401                         if (clause->flags != MONO_EXCEPTION_CLAUSE_FILTER &&
8402                                         clause->data.catch_class &&
8403                                         cfg->gshared &&
8404                                         mono_class_check_context_used (clause->data.catch_class)) {
8405                                 /*
8406                                  * In shared generic code with catch
8407                                  * clauses containing type variables
8408                                  * the exception handling code has to
8409                                  * be able to get to the rgctx.
8410                                  * Therefore we have to make sure that
8411                                  * the vtable/mrgctx argument (for
8412                                  * static or generic methods) or the
8413                                  * "this" argument (for non-static
8414                                  * methods) are live.
8415                                  */
8416                                 if ((method->flags & METHOD_ATTRIBUTE_STATIC) ||
8417                                                 mini_method_get_context (method)->method_inst ||
8418                                                 method->klass->valuetype) {
8419                                         mono_get_vtable_var (cfg);
8420                                 } else {
8421                                         MonoInst *dummy_use;
8422
8423                                         EMIT_NEW_DUMMY_USE (cfg, dummy_use, arg_array [0]);
8424                                 }
8425                         }
8426                 }
8427         } else {
8428                 arg_array = (MonoInst **) alloca (sizeof (MonoInst *) * num_args);
8429                 cfg->cbb = start_bblock;
8430                 cfg->args = arg_array;
8431                 mono_save_args (cfg, sig, inline_args);
8432         }
8433
8434         /* FIRST CODE BLOCK */
8435         NEW_BBLOCK (cfg, tblock);
8436         tblock->cil_code = ip;
8437         cfg->cbb = tblock;
8438         cfg->ip = ip;
8439
8440         ADD_BBLOCK (cfg, tblock);
8441
8442         if (cfg->method == method) {
8443                 breakpoint_id = mono_debugger_method_has_breakpoint (method);
8444                 if (breakpoint_id) {
8445                         MONO_INST_NEW (cfg, ins, OP_BREAK);
8446                         MONO_ADD_INS (cfg->cbb, ins);
8447                 }
8448         }
8449
8450         /* we use a separate basic block for the initialization code */
8451         NEW_BBLOCK (cfg, init_localsbb);
8452         cfg->bb_init = init_localsbb;
8453         init_localsbb->real_offset = cfg->real_offset;
8454         start_bblock->next_bb = init_localsbb;
8455         init_localsbb->next_bb = cfg->cbb;
8456         link_bblock (cfg, start_bblock, init_localsbb);
8457         link_bblock (cfg, init_localsbb, cfg->cbb);
8458
8459         cfg->cbb = init_localsbb;
8460
8461         if (cfg->gsharedvt && cfg->method == method) {
8462                 MonoGSharedVtMethodInfo *info;
8463                 MonoInst *var, *locals_var;
8464                 int dreg;
8465
8466                 info = (MonoGSharedVtMethodInfo *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoGSharedVtMethodInfo));
8467                 info->method = cfg->method;
8468                 info->count_entries = 16;
8469                 info->entries = (MonoRuntimeGenericContextInfoTemplate *)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoRuntimeGenericContextInfoTemplate) * info->count_entries);
8470                 cfg->gsharedvt_info = info;
8471
8472                 var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
8473                 /* prevent it from being register allocated */
8474                 //var->flags |= MONO_INST_VOLATILE;
8475                 cfg->gsharedvt_info_var = var;
8476
8477                 ins = emit_get_rgctx_gsharedvt_method (cfg, mini_method_check_context_used (cfg, method), method, info);
8478                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, var->dreg, ins->dreg);
8479
8480                 /* Allocate locals */
8481                 locals_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
8482                 /* prevent it from being register allocated */
8483                 //locals_var->flags |= MONO_INST_VOLATILE;
8484                 cfg->gsharedvt_locals_var = locals_var;
8485
8486                 dreg = alloc_ireg (cfg);
8487                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, dreg, var->dreg, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, locals_size));
8488
8489                 MONO_INST_NEW (cfg, ins, OP_LOCALLOC);
8490                 ins->dreg = locals_var->dreg;
8491                 ins->sreg1 = dreg;
8492                 MONO_ADD_INS (cfg->cbb, ins);
8493                 cfg->gsharedvt_locals_var_ins = ins;
8494
8495                 cfg->flags |= MONO_CFG_HAS_ALLOCA;
8496                 /*
8497                 if (init_locals)
8498                         ins->flags |= MONO_INST_INIT;
8499                 */
8500         }
8501
8502         if (mono_security_core_clr_enabled ()) {
8503                 /* check if this is native code, e.g. an icall or a p/invoke */
8504                 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
8505                         MonoMethod *wrapped = mono_marshal_method_from_wrapper (method);
8506                         if (wrapped) {
8507                                 gboolean pinvk = (wrapped->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL);
8508                                 gboolean icall = (wrapped->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL);
8509
8510                                 /* if this ia a native call then it can only be JITted from platform code */
8511                                 if ((icall || pinvk) && method->klass && method->klass->image) {
8512                                         if (!mono_security_core_clr_is_platform_image (method->klass->image)) {
8513                                                 MonoException *ex = icall ? mono_get_exception_security () :
8514                                                         mono_get_exception_method_access ();
8515                                                 emit_throw_exception (cfg, ex);
8516                                         }
8517                                 }
8518                         }
8519                 }
8520         }
8521
8522         CHECK_CFG_EXCEPTION;
8523
8524         if (header->code_size == 0)
8525                 UNVERIFIED;
8526
8527         if (get_basic_blocks (cfg, header, cfg->real_offset, ip, end, &err_pos)) {
8528                 ip = err_pos;
8529                 UNVERIFIED;
8530         }
8531
8532         if (cfg->method == method)
8533                 mono_debug_init_method (cfg, cfg->cbb, breakpoint_id);
8534
8535         for (n = 0; n < header->num_locals; ++n) {
8536                 if (header->locals [n]->type == MONO_TYPE_VOID && !header->locals [n]->byref)
8537                         UNVERIFIED;
8538         }
8539         class_inits = NULL;
8540
8541         /* We force the vtable variable here for all shared methods
8542            for the possibility that they might show up in a stack
8543            trace where their exact instantiation is needed. */
8544         if (cfg->gshared && method == cfg->method) {
8545                 if ((method->flags & METHOD_ATTRIBUTE_STATIC) ||
8546                                 mini_method_get_context (method)->method_inst ||
8547                                 method->klass->valuetype) {
8548                         mono_get_vtable_var (cfg);
8549                 } else {
8550                         /* FIXME: Is there a better way to do this?
8551                            We need the variable live for the duration
8552                            of the whole method. */
8553                         cfg->args [0]->flags |= MONO_INST_VOLATILE;
8554                 }
8555         }
8556
8557         /* add a check for this != NULL to inlined methods */
8558         if (is_virtual_call) {
8559                 MonoInst *arg_ins;
8560
8561                 NEW_ARGLOAD (cfg, arg_ins, 0);
8562                 MONO_ADD_INS (cfg->cbb, arg_ins);
8563                 MONO_EMIT_NEW_CHECK_THIS (cfg, arg_ins->dreg);
8564         }
8565
8566         skip_dead_blocks = !dont_verify;
8567         if (skip_dead_blocks) {
8568                 original_bb = bb = mono_basic_block_split (method, &cfg->error);
8569                 CHECK_CFG_ERROR;
8570                 g_assert (bb);
8571         }
8572
8573         /* we use a spare stack slot in SWITCH and NEWOBJ and others */
8574         stack_start = sp = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
8575
8576         ins_flag = 0;
8577         start_new_bblock = 0;
8578         while (ip < end) {
8579                 if (cfg->method == method)
8580                         cfg->real_offset = ip - header->code;
8581                 else
8582                         cfg->real_offset = inline_offset;
8583                 cfg->ip = ip;
8584
8585                 context_used = 0;
8586
8587                 if (start_new_bblock) {
8588                         cfg->cbb->cil_length = ip - cfg->cbb->cil_code;
8589                         if (start_new_bblock == 2) {
8590                                 g_assert (ip == tblock->cil_code);
8591                         } else {
8592                                 GET_BBLOCK (cfg, tblock, ip);
8593                         }
8594                         cfg->cbb->next_bb = tblock;
8595                         cfg->cbb = tblock;
8596                         start_new_bblock = 0;
8597                         for (i = 0; i < cfg->cbb->in_scount; ++i) {
8598                                 if (cfg->verbose_level > 3)
8599                                         printf ("loading %d from temp %d\n", i, (int)cfg->cbb->in_stack [i]->inst_c0);
8600                                 EMIT_NEW_TEMPLOAD (cfg, ins, cfg->cbb->in_stack [i]->inst_c0);
8601                                 *sp++ = ins;
8602                         }
8603                         if (class_inits)
8604                                 g_slist_free (class_inits);
8605                         class_inits = NULL;
8606                 } else {
8607                         if ((tblock = cfg->cil_offset_to_bb [ip - cfg->cil_start]) && (tblock != cfg->cbb)) {
8608                                 link_bblock (cfg, cfg->cbb, tblock);
8609                                 if (sp != stack_start) {
8610                                         handle_stack_args (cfg, stack_start, sp - stack_start);
8611                                         sp = stack_start;
8612                                         CHECK_UNVERIFIABLE (cfg);
8613                                 }
8614                                 cfg->cbb->next_bb = tblock;
8615                                 cfg->cbb = tblock;
8616                                 for (i = 0; i < cfg->cbb->in_scount; ++i) {
8617                                         if (cfg->verbose_level > 3)
8618                                                 printf ("loading %d from temp %d\n", i, (int)cfg->cbb->in_stack [i]->inst_c0);
8619                                         EMIT_NEW_TEMPLOAD (cfg, ins, cfg->cbb->in_stack [i]->inst_c0);
8620                                         *sp++ = ins;
8621                                 }
8622                                 g_slist_free (class_inits);
8623                                 class_inits = NULL;
8624                         }
8625                 }
8626
8627                 if (skip_dead_blocks) {
8628                         int ip_offset = ip - header->code;
8629
8630                         if (ip_offset == bb->end)
8631                                 bb = bb->next;
8632
8633                         if (bb->dead) {
8634                                 int op_size = mono_opcode_size (ip, end);
8635                                 g_assert (op_size > 0); /*The BB formation pass must catch all bad ops*/
8636
8637                                 if (cfg->verbose_level > 3) printf ("SKIPPING DEAD OP at %x\n", ip_offset);
8638
8639                                 if (ip_offset + op_size == bb->end) {
8640                                         MONO_INST_NEW (cfg, ins, OP_NOP);
8641                                         MONO_ADD_INS (cfg->cbb, ins);
8642                                         start_new_bblock = 1;
8643                                 }
8644
8645                                 ip += op_size;
8646                                 continue;
8647                         }
8648                 }
8649                 /*
8650                  * Sequence points are points where the debugger can place a breakpoint.
8651                  * Currently, we generate these automatically at points where the IL
8652                  * stack is empty.
8653                  */
8654                 if (seq_points && ((!sym_seq_points && (sp == stack_start)) || (sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code)))) {
8655                         /*
8656                          * Make methods interruptable at the beginning, and at the targets of
8657                          * backward branches.
8658                          * Also, do this at the start of every bblock in methods with clauses too,
8659                          * to be able to handle instructions with inprecise control flow like
8660                          * throw/endfinally.
8661                          * Backward branches are handled at the end of method-to-ir ().
8662                          */
8663                         gboolean intr_loc = ip == header->code || (!cfg->cbb->last_ins && cfg->header->num_clauses);
8664                         gboolean sym_seq_point = sym_seq_points && mono_bitset_test_fast (seq_point_locs, ip - header->code);
8665
8666                         /* Avoid sequence points on empty IL like .volatile */
8667                         // FIXME: Enable this
8668                         //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) {
8669                         NEW_SEQ_POINT (cfg, ins, ip - header->code, intr_loc);
8670                         if ((sp != stack_start) && !sym_seq_point)
8671                                 ins->flags |= MONO_INST_NONEMPTY_STACK;
8672                         MONO_ADD_INS (cfg->cbb, ins);
8673
8674                         if (sym_seq_points)
8675                                 mono_bitset_set_fast (seq_point_set_locs, ip - header->code);
8676                 }
8677
8678                 cfg->cbb->real_offset = cfg->real_offset;
8679
8680                 if ((cfg->method == method) && cfg->coverage_info) {
8681                         guint32 cil_offset = ip - header->code;
8682                         cfg->coverage_info->data [cil_offset].cil_code = ip;
8683
8684                         /* TODO: Use an increment here */
8685 #if defined(TARGET_X86)
8686                         MONO_INST_NEW (cfg, ins, OP_STORE_MEM_IMM);
8687                         ins->inst_p0 = &(cfg->coverage_info->data [cil_offset].count);
8688                         ins->inst_imm = 1;
8689                         MONO_ADD_INS (cfg->cbb, ins);
8690 #else
8691                         EMIT_NEW_PCONST (cfg, ins, &(cfg->coverage_info->data [cil_offset].count));
8692                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, ins->dreg, 0, 1);
8693 #endif
8694                 }
8695
8696                 if (cfg->verbose_level > 3)
8697                         printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
8698
8699                 switch (*ip) {
8700                 case CEE_NOP:
8701                         if (seq_points && !sym_seq_points && sp != stack_start) {
8702                                 /*
8703                                  * The C# compiler uses these nops to notify the JIT that it should
8704                                  * insert seq points.
8705                                  */
8706                                 NEW_SEQ_POINT (cfg, ins, ip - header->code, FALSE);
8707                                 MONO_ADD_INS (cfg->cbb, ins);
8708                         }
8709                         if (cfg->keep_cil_nops)
8710                                 MONO_INST_NEW (cfg, ins, OP_HARD_NOP);
8711                         else
8712                                 MONO_INST_NEW (cfg, ins, OP_NOP);
8713                         ip++;
8714                         MONO_ADD_INS (cfg->cbb, ins);
8715                         break;
8716                 case CEE_BREAK:
8717                         if (should_insert_brekpoint (cfg->method)) {
8718                                 ins = mono_emit_jit_icall (cfg, mono_debugger_agent_user_break, NULL);
8719                         } else {
8720                                 MONO_INST_NEW (cfg, ins, OP_NOP);
8721                         }
8722                         ip++;
8723                         MONO_ADD_INS (cfg->cbb, ins);
8724                         break;
8725                 case CEE_LDARG_0:
8726                 case CEE_LDARG_1:
8727                 case CEE_LDARG_2:
8728                 case CEE_LDARG_3:
8729                         CHECK_STACK_OVF (1);
8730                         n = (*ip)-CEE_LDARG_0;
8731                         CHECK_ARG (n);
8732                         EMIT_NEW_ARGLOAD (cfg, ins, n);
8733                         ip++;
8734                         *sp++ = ins;
8735                         break;
8736                 case CEE_LDLOC_0:
8737                 case CEE_LDLOC_1:
8738                 case CEE_LDLOC_2:
8739                 case CEE_LDLOC_3:
8740                         CHECK_STACK_OVF (1);
8741                         n = (*ip)-CEE_LDLOC_0;
8742                         CHECK_LOCAL (n);
8743                         EMIT_NEW_LOCLOAD (cfg, ins, n);
8744                         ip++;
8745                         *sp++ = ins;
8746                         break;
8747                 case CEE_STLOC_0:
8748                 case CEE_STLOC_1:
8749                 case CEE_STLOC_2:
8750                 case CEE_STLOC_3: {
8751                         CHECK_STACK (1);
8752                         n = (*ip)-CEE_STLOC_0;
8753                         CHECK_LOCAL (n);
8754                         --sp;
8755                         if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [n], *sp))
8756                                 UNVERIFIED;
8757                         emit_stloc_ir (cfg, sp, header, n);
8758                         ++ip;
8759                         inline_costs += 1;
8760                         break;
8761                         }
8762                 case CEE_LDARG_S:
8763                         CHECK_OPSIZE (2);
8764                         CHECK_STACK_OVF (1);
8765                         n = ip [1];
8766                         CHECK_ARG (n);
8767                         EMIT_NEW_ARGLOAD (cfg, ins, n);
8768                         *sp++ = ins;
8769                         ip += 2;
8770                         break;
8771                 case CEE_LDARGA_S:
8772                         CHECK_OPSIZE (2);
8773                         CHECK_STACK_OVF (1);
8774                         n = ip [1];
8775                         CHECK_ARG (n);
8776                         NEW_ARGLOADA (cfg, ins, n);
8777                         MONO_ADD_INS (cfg->cbb, ins);
8778                         *sp++ = ins;
8779                         ip += 2;
8780                         break;
8781                 case CEE_STARG_S:
8782                         CHECK_OPSIZE (2);
8783                         CHECK_STACK (1);
8784                         --sp;
8785                         n = ip [1];
8786                         CHECK_ARG (n);
8787                         if (!dont_verify_stloc && target_type_is_incompatible (cfg, param_types [ip [1]], *sp))
8788                                 UNVERIFIED;
8789                         EMIT_NEW_ARGSTORE (cfg, ins, n, *sp);
8790                         ip += 2;
8791                         break;
8792                 case CEE_LDLOC_S:
8793                         CHECK_OPSIZE (2);
8794                         CHECK_STACK_OVF (1);
8795                         n = ip [1];
8796                         CHECK_LOCAL (n);
8797                         EMIT_NEW_LOCLOAD (cfg, ins, n);
8798                         *sp++ = ins;
8799                         ip += 2;
8800                         break;
8801                 case CEE_LDLOCA_S: {
8802                         unsigned char *tmp_ip;
8803                         CHECK_OPSIZE (2);
8804                         CHECK_STACK_OVF (1);
8805                         CHECK_LOCAL (ip [1]);
8806
8807                         if ((tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 1))) {
8808                                 ip = tmp_ip;
8809                                 inline_costs += 1;
8810                                 break;
8811                         }
8812
8813                         EMIT_NEW_LOCLOADA (cfg, ins, ip [1]);
8814                         *sp++ = ins;
8815                         ip += 2;
8816                         break;
8817                 }
8818                 case CEE_STLOC_S:
8819                         CHECK_OPSIZE (2);
8820                         CHECK_STACK (1);
8821                         --sp;
8822                         CHECK_LOCAL (ip [1]);
8823                         if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [ip [1]], *sp))
8824                                 UNVERIFIED;
8825                         emit_stloc_ir (cfg, sp, header, ip [1]);
8826                         ip += 2;
8827                         inline_costs += 1;
8828                         break;
8829                 case CEE_LDNULL:
8830                         CHECK_STACK_OVF (1);
8831                         EMIT_NEW_PCONST (cfg, ins, NULL);
8832                         ins->type = STACK_OBJ;
8833                         ++ip;
8834                         *sp++ = ins;
8835                         break;
8836                 case CEE_LDC_I4_M1:
8837                         CHECK_STACK_OVF (1);
8838                         EMIT_NEW_ICONST (cfg, ins, -1);
8839                         ++ip;
8840                         *sp++ = ins;
8841                         break;
8842                 case CEE_LDC_I4_0:
8843                 case CEE_LDC_I4_1:
8844                 case CEE_LDC_I4_2:
8845                 case CEE_LDC_I4_3:
8846                 case CEE_LDC_I4_4:
8847                 case CEE_LDC_I4_5:
8848                 case CEE_LDC_I4_6:
8849                 case CEE_LDC_I4_7:
8850                 case CEE_LDC_I4_8:
8851                         CHECK_STACK_OVF (1);
8852                         EMIT_NEW_ICONST (cfg, ins, (*ip) - CEE_LDC_I4_0);
8853                         ++ip;
8854                         *sp++ = ins;
8855                         break;
8856                 case CEE_LDC_I4_S:
8857                         CHECK_OPSIZE (2);
8858                         CHECK_STACK_OVF (1);
8859                         ++ip;
8860                         EMIT_NEW_ICONST (cfg, ins, *((signed char*)ip));
8861                         ++ip;
8862                         *sp++ = ins;
8863                         break;
8864                 case CEE_LDC_I4:
8865                         CHECK_OPSIZE (5);
8866                         CHECK_STACK_OVF (1);
8867                         EMIT_NEW_ICONST (cfg, ins, (gint32)read32 (ip + 1));
8868                         ip += 5;
8869                         *sp++ = ins;
8870                         break;
8871                 case CEE_LDC_I8:
8872                         CHECK_OPSIZE (9);
8873                         CHECK_STACK_OVF (1);
8874                         MONO_INST_NEW (cfg, ins, OP_I8CONST);
8875                         ins->type = STACK_I8;
8876                         ins->dreg = alloc_dreg (cfg, STACK_I8);
8877                         ++ip;
8878                         ins->inst_l = (gint64)read64 (ip);
8879                         MONO_ADD_INS (cfg->cbb, ins);
8880                         ip += 8;
8881                         *sp++ = ins;
8882                         break;
8883                 case CEE_LDC_R4: {
8884                         float *f;
8885                         gboolean use_aotconst = FALSE;
8886
8887 #ifdef TARGET_POWERPC
8888                         /* FIXME: Clean this up */
8889                         if (cfg->compile_aot)
8890                                 use_aotconst = TRUE;
8891 #endif
8892
8893                         /* FIXME: we should really allocate this only late in the compilation process */
8894                         f = (float *)mono_domain_alloc (cfg->domain, sizeof (float));
8895                         CHECK_OPSIZE (5);
8896                         CHECK_STACK_OVF (1);
8897
8898                         if (use_aotconst) {
8899                                 MonoInst *cons;
8900                                 int dreg;
8901
8902                                 EMIT_NEW_AOTCONST (cfg, cons, MONO_PATCH_INFO_R4, f);
8903
8904                                 dreg = alloc_freg (cfg);
8905                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADR4_MEMBASE, dreg, cons->dreg, 0);
8906                                 ins->type = cfg->r4_stack_type;
8907                         } else {
8908                                 MONO_INST_NEW (cfg, ins, OP_R4CONST);
8909                                 ins->type = cfg->r4_stack_type;
8910                                 ins->dreg = alloc_dreg (cfg, STACK_R8);
8911                                 ins->inst_p0 = f;
8912                                 MONO_ADD_INS (cfg->cbb, ins);
8913                         }
8914                         ++ip;
8915                         readr4 (ip, f);
8916                         ip += 4;
8917                         *sp++ = ins;
8918                         break;
8919                 }
8920                 case CEE_LDC_R8: {
8921                         double *d;
8922                         gboolean use_aotconst = FALSE;
8923
8924 #ifdef TARGET_POWERPC
8925                         /* FIXME: Clean this up */
8926                         if (cfg->compile_aot)
8927                                 use_aotconst = TRUE;
8928 #endif
8929
8930                         /* FIXME: we should really allocate this only late in the compilation process */
8931                         d = (double *)mono_domain_alloc (cfg->domain, sizeof (double));
8932                         CHECK_OPSIZE (9);
8933                         CHECK_STACK_OVF (1);
8934
8935                         if (use_aotconst) {
8936                                 MonoInst *cons;
8937                                 int dreg;
8938
8939                                 EMIT_NEW_AOTCONST (cfg, cons, MONO_PATCH_INFO_R8, d);
8940
8941                                 dreg = alloc_freg (cfg);
8942                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADR8_MEMBASE, dreg, cons->dreg, 0);
8943                                 ins->type = STACK_R8;
8944                         } else {
8945                                 MONO_INST_NEW (cfg, ins, OP_R8CONST);
8946                                 ins->type = STACK_R8;
8947                                 ins->dreg = alloc_dreg (cfg, STACK_R8);
8948                                 ins->inst_p0 = d;
8949                                 MONO_ADD_INS (cfg->cbb, ins);
8950                         }
8951                         ++ip;
8952                         readr8 (ip, d);
8953                         ip += 8;
8954                         *sp++ = ins;
8955                         break;
8956                 }
8957                 case CEE_DUP: {
8958                         MonoInst *temp, *store;
8959                         CHECK_STACK (1);
8960                         CHECK_STACK_OVF (1);
8961                         sp--;
8962                         ins = *sp;
8963
8964                         temp = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
8965                         EMIT_NEW_TEMPSTORE (cfg, store, temp->inst_c0, ins);
8966
8967                         EMIT_NEW_TEMPLOAD (cfg, ins, temp->inst_c0);
8968                         *sp++ = ins;
8969
8970                         EMIT_NEW_TEMPLOAD (cfg, ins, temp->inst_c0);
8971                         *sp++ = ins;
8972
8973                         ++ip;
8974                         inline_costs += 2;
8975                         break;
8976                 }
8977                 case CEE_POP:
8978                         CHECK_STACK (1);
8979                         ip++;
8980                         --sp;
8981
8982 #ifdef TARGET_X86
8983                         if (sp [0]->type == STACK_R8)
8984                                 /* we need to pop the value from the x86 FP stack */
8985                                 MONO_EMIT_NEW_UNALU (cfg, OP_X86_FPOP, -1, sp [0]->dreg);
8986 #endif
8987                         break;
8988                 case CEE_JMP: {
8989                         MonoCallInst *call;
8990                         MonoMethodSignature *fsig;
8991                         int i, n;
8992
8993                         INLINE_FAILURE ("jmp");
8994                         GSHAREDVT_FAILURE (*ip);
8995
8996                         CHECK_OPSIZE (5);
8997                         if (stack_start != sp)
8998                                 UNVERIFIED;
8999                         token = read32 (ip + 1);
9000                         /* FIXME: check the signature matches */
9001                         cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
9002                         CHECK_CFG_ERROR;
9003
9004                         if (cfg->gshared && mono_method_check_context_used (cmethod))
9005                                 GENERIC_SHARING_FAILURE (CEE_JMP);
9006
9007                         emit_instrumentation_call (cfg, mono_profiler_method_leave);
9008
9009                         fsig = mono_method_signature (cmethod);
9010                         n = fsig->param_count + fsig->hasthis;
9011                         if (cfg->llvm_only) {
9012                                 MonoInst **args;
9013
9014                                 args = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
9015                                 for (i = 0; i < n; ++i)
9016                                         EMIT_NEW_ARGLOAD (cfg, args [i], i);
9017                                 ins = mono_emit_method_call_full (cfg, cmethod, fsig, TRUE, args, NULL, NULL, NULL);
9018                                 /*
9019                                  * The code in mono-basic-block.c treats the rest of the code as dead, but we
9020                                  * have to emit a normal return since llvm expects it.
9021                                  */
9022                                 if (cfg->ret)
9023                                         emit_setret (cfg, ins);
9024                                 MONO_INST_NEW (cfg, ins, OP_BR);
9025                                 ins->inst_target_bb = end_bblock;
9026                                 MONO_ADD_INS (cfg->cbb, ins);
9027                                 link_bblock (cfg, cfg->cbb, end_bblock);
9028                                 ip += 5;
9029                                 break;
9030                         } else if (cfg->backend->have_op_tail_call) {
9031                                 /* Handle tail calls similarly to calls */
9032                                 DISABLE_AOT (cfg);
9033
9034                                 MONO_INST_NEW_CALL (cfg, call, OP_TAILCALL);
9035                                 call->method = cmethod;
9036                                 call->tail_call = TRUE;
9037                                 call->signature = mono_method_signature (cmethod);
9038                                 call->args = (MonoInst **)mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
9039                                 call->inst.inst_p0 = cmethod;
9040                                 for (i = 0; i < n; ++i)
9041                                         EMIT_NEW_ARGLOAD (cfg, call->args [i], i);
9042
9043                                 mono_arch_emit_call (cfg, call);
9044                                 cfg->param_area = MAX(cfg->param_area, call->stack_usage);
9045                                 MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
9046                         } else {
9047                                 for (i = 0; i < num_args; ++i)
9048                                         /* Prevent arguments from being optimized away */
9049                                         arg_array [i]->flags |= MONO_INST_VOLATILE;
9050
9051                                 MONO_INST_NEW_CALL (cfg, call, OP_JMP);
9052                                 ins = (MonoInst*)call;
9053                                 ins->inst_p0 = cmethod;
9054                                 MONO_ADD_INS (cfg->cbb, ins);
9055                         }
9056
9057                         ip += 5;
9058                         start_new_bblock = 1;
9059                         break;
9060                 }
9061                 case CEE_CALLI: {
9062                         MonoInst *addr;
9063                         MonoMethodSignature *fsig;
9064
9065                         CHECK_OPSIZE (5);
9066                         token = read32 (ip + 1);
9067
9068                         ins = NULL;
9069
9070                         //GSHAREDVT_FAILURE (*ip);
9071                         cmethod = NULL;
9072                         CHECK_STACK (1);
9073                         --sp;
9074                         addr = *sp;
9075                         fsig = mini_get_signature (method, token, generic_context);
9076
9077                         if (method->dynamic && fsig->pinvoke) {
9078                                 MonoInst *args [3];
9079
9080                                 /*
9081                                  * This is a call through a function pointer using a pinvoke
9082                                  * signature. Have to create a wrapper and call that instead.
9083                                  * FIXME: This is very slow, need to create a wrapper at JIT time
9084                                  * instead based on the signature.
9085                                  */
9086                                 EMIT_NEW_IMAGECONST (cfg, args [0], method->klass->image);
9087                                 EMIT_NEW_PCONST (cfg, args [1], fsig);
9088                                 args [2] = addr;
9089                                 addr = mono_emit_jit_icall (cfg, mono_get_native_calli_wrapper, args);
9090                         }
9091
9092                         n = fsig->param_count + fsig->hasthis;
9093
9094                         CHECK_STACK (n);
9095
9096                         //g_assert (!virtual_ || fsig->hasthis);
9097
9098                         sp -= n;
9099
9100                         inline_costs += 10 * num_calls++;
9101
9102                         /*
9103                          * Making generic calls out of gsharedvt methods.
9104                          * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9105                          * patching gshared method addresses into a gsharedvt method.
9106                          */
9107                         if (cfg->gsharedvt && mini_is_gsharedvt_signature (fsig)) {
9108                                 /*
9109                                  * We pass the address to the gsharedvt trampoline in the rgctx reg
9110                                  */
9111                                 MonoInst *callee = addr;
9112
9113                                 if (method->wrapper_type != MONO_WRAPPER_DELEGATE_INVOKE)
9114                                         /* Not tested */
9115                                         GSHAREDVT_FAILURE (*ip);
9116
9117                                 if (cfg->llvm_only)
9118                                         // FIXME:
9119                                         GSHAREDVT_FAILURE (*ip);
9120
9121                                 addr = emit_get_rgctx_sig (cfg, context_used,
9122                                                                                           fsig, MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI);
9123                                 ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, callee);
9124                                 goto calli_end;
9125                         }
9126
9127                         /* Prevent inlining of methods with indirect calls */
9128                         INLINE_FAILURE ("indirect call");
9129
9130                         if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST || addr->opcode == OP_GOT_ENTRY) {
9131                                 MonoJumpInfoType info_type;
9132                                 gpointer info_data;
9133
9134                                 /*
9135                                  * Instead of emitting an indirect call, emit a direct call
9136                                  * with the contents of the aotconst as the patch info.
9137                                  */
9138                                 if (addr->opcode == OP_PCONST || addr->opcode == OP_AOTCONST) {
9139                                         info_type = (MonoJumpInfoType)addr->inst_c1;
9140                                         info_data = addr->inst_p0;
9141                                 } else {
9142                                         info_type = (MonoJumpInfoType)addr->inst_right->inst_c1;
9143                                         info_data = addr->inst_right->inst_left;
9144                                 }
9145
9146                                 if (info_type == MONO_PATCH_INFO_ICALL_ADDR || info_type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
9147                                         ins = (MonoInst*)mono_emit_abs_call (cfg, info_type, info_data, fsig, sp);
9148                                         NULLIFY_INS (addr);
9149                                         goto calli_end;
9150                                 }
9151                         }
9152                         ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, NULL);
9153
9154                         calli_end:
9155
9156                         /* End of call, INS should contain the result of the call, if any */
9157
9158                         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
9159                                 g_assert (ins);
9160                                 *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
9161                         }
9162
9163                         CHECK_CFG_EXCEPTION;
9164
9165                         ip += 5;
9166                         ins_flag = 0;
9167                         constrained_class = NULL;
9168                         break;
9169                 }
9170                 case CEE_CALL:
9171                 case CEE_CALLVIRT: {
9172                         MonoInst *addr = NULL;
9173                         MonoMethodSignature *fsig = NULL;
9174                         int array_rank = 0;
9175                         int virtual_ = *ip == CEE_CALLVIRT;
9176                         gboolean pass_imt_from_rgctx = FALSE;
9177                         MonoInst *imt_arg = NULL;
9178                         MonoInst *keep_this_alive = NULL;
9179                         gboolean pass_vtable = FALSE;
9180                         gboolean pass_mrgctx = FALSE;
9181                         MonoInst *vtable_arg = NULL;
9182                         gboolean check_this = FALSE;
9183                         gboolean supported_tail_call = FALSE;
9184                         gboolean tail_call = FALSE;
9185                         gboolean need_seq_point = FALSE;
9186                         guint32 call_opcode = *ip;
9187                         gboolean emit_widen = TRUE;
9188                         gboolean push_res = TRUE;
9189                         gboolean skip_ret = FALSE;
9190                         gboolean delegate_invoke = FALSE;
9191                         gboolean direct_icall = FALSE;
9192                         gboolean constrained_partial_call = FALSE;
9193                         MonoMethod *cil_method;
9194
9195                         CHECK_OPSIZE (5);
9196                         token = read32 (ip + 1);
9197
9198                         ins = NULL;
9199
9200                         cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
9201                         CHECK_CFG_ERROR;
9202
9203                         cil_method = cmethod;
9204
9205                         if (constrained_class) {
9206                                 if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9207                                         if (!mini_is_gsharedvt_klass (constrained_class)) {
9208                                                 g_assert (!cmethod->klass->valuetype);
9209                                                 if (!mini_type_is_reference (&constrained_class->byval_arg))
9210                                                         constrained_partial_call = TRUE;
9211                                         }
9212                                 }
9213
9214                                 if (method->wrapper_type != MONO_WRAPPER_NONE) {
9215                                         if (cfg->verbose_level > 2)
9216                                                 printf ("DM Constrained call to %s\n", mono_type_get_full_name (constrained_class));
9217                                         if (!((constrained_class->byval_arg.type == MONO_TYPE_VAR ||
9218                                                    constrained_class->byval_arg.type == MONO_TYPE_MVAR) &&
9219                                                   cfg->gshared)) {
9220                                                 cmethod = mono_get_method_constrained_with_method (image, cil_method, constrained_class, generic_context, &cfg->error);
9221                                                 CHECK_CFG_ERROR;
9222                                         }
9223                                 } else {
9224                                         if (cfg->verbose_level > 2)
9225                                                 printf ("Constrained call to %s\n", mono_type_get_full_name (constrained_class));
9226
9227                                         if ((constrained_class->byval_arg.type == MONO_TYPE_VAR || constrained_class->byval_arg.type == MONO_TYPE_MVAR) && cfg->gshared) {
9228                                                 /*
9229                                                  * This is needed since get_method_constrained can't find
9230                                                  * the method in klass representing a type var.
9231                                                  * The type var is guaranteed to be a reference type in this
9232                                                  * case.
9233                                                  */
9234                                                 if (!mini_is_gsharedvt_klass (constrained_class))
9235                                                         g_assert (!cmethod->klass->valuetype);
9236                                         } else {
9237                                                 cmethod = mono_get_method_constrained_checked (image, token, constrained_class, generic_context, &cil_method, &cfg->error);
9238                                                 CHECK_CFG_ERROR;
9239                                         }
9240                                 }
9241                         }
9242
9243                         if (!cmethod || mono_loader_get_last_error ()) {
9244                                 if (mono_loader_get_last_error ()) {
9245                                         mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
9246                                         mono_error_set_from_loader_error (&cfg->error);
9247                                         CHECK_CFG_ERROR;
9248                                 } else {
9249                                         LOAD_ERROR;
9250                                 }
9251                         }
9252                         if (!dont_verify && !cfg->skip_visibility) {
9253                                 MonoMethod *target_method = cil_method;
9254                                 if (method->is_inflated) {
9255                                         target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context), &cfg->error);
9256                                         CHECK_CFG_ERROR;
9257                                 }
9258                                 if (!mono_method_can_access_method (method_definition, target_method) &&
9259                                         !mono_method_can_access_method (method, cil_method))
9260                                         METHOD_ACCESS_FAILURE (method, cil_method);
9261                         }
9262
9263                         if (mono_security_core_clr_enabled ())
9264                                 ensure_method_is_allowed_to_call_method (cfg, method, cil_method);
9265
9266                         if (!virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_ABSTRACT))
9267                                 /* MS.NET seems to silently convert this to a callvirt */
9268                                 virtual_ = 1;
9269
9270                         {
9271                                 /*
9272                                  * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
9273                                  * converts to a callvirt.
9274                                  *
9275                                  * tests/bug-515884.il is an example of this behavior
9276                                  */
9277                                 const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
9278                                 const int expected_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL;
9279                                 if (!virtual_ && mono_class_is_marshalbyref (cmethod->klass) && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
9280                                         virtual_ = 1;
9281                         }
9282
9283                         if (!cmethod->klass->inited)
9284                                 if (!mono_class_init (cmethod->klass))
9285                                         TYPE_LOAD_ERROR (cmethod->klass);
9286
9287                         fsig = mono_method_signature (cmethod);
9288                         if (!fsig)
9289                                 LOAD_ERROR;
9290                         if (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL &&
9291                                 mini_class_is_system_array (cmethod->klass)) {
9292                                 array_rank = cmethod->klass->rank;
9293                         } else if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && icall_is_direct_callable (cfg, cmethod)) {
9294                                 direct_icall = TRUE;
9295                         } else if (fsig->pinvoke) {
9296                                 MonoMethod *wrapper = mono_marshal_get_native_wrapper (cmethod, TRUE, cfg->compile_aot);
9297                                 fsig = mono_method_signature (wrapper);
9298                         } else if (constrained_class) {
9299                         } else {
9300                                 fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
9301                                 CHECK_CFG_ERROR;
9302                         }
9303
9304                         if (cfg->llvm_only && !cfg->method->wrapper_type)
9305                                 cfg->signatures = g_slist_prepend_mempool (cfg->mempool, cfg->signatures, fsig);
9306
9307                         /* See code below */
9308                         if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9309                                 MonoBasicBlock *tbb;
9310
9311                                 GET_BBLOCK (cfg, tbb, ip + 5);
9312                                 if (tbb->try_start && MONO_REGION_FLAGS(tbb->region) == MONO_EXCEPTION_CLAUSE_FINALLY) {
9313                                         /*
9314                                          * We want to extend the try block to cover the call, but we can't do it if the
9315                                          * call is made directly since its followed by an exception check.
9316                                          */
9317                                         direct_icall = FALSE;
9318                                 }
9319                         }
9320
9321                         mono_save_token_info (cfg, image, token, cil_method);
9322
9323                         if (!(seq_point_locs && mono_bitset_test_fast (seq_point_locs, ip + 5 - header->code)))
9324                                 need_seq_point = TRUE;
9325
9326                         /* Don't support calls made using type arguments for now */
9327                         /*
9328                           if (cfg->gsharedvt) {
9329                           if (mini_is_gsharedvt_signature (fsig))
9330                           GSHAREDVT_FAILURE (*ip);
9331                           }
9332                         */
9333
9334                         if (cmethod->string_ctor && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
9335                                 g_assert_not_reached ();
9336
9337                         n = fsig->param_count + fsig->hasthis;
9338
9339                         if (!cfg->gshared && cmethod->klass->generic_container)
9340                                 UNVERIFIED;
9341
9342                         if (!cfg->gshared)
9343                                 g_assert (!mono_method_check_context_used (cmethod));
9344
9345                         CHECK_STACK (n);
9346
9347                         //g_assert (!virtual_ || fsig->hasthis);
9348
9349                         sp -= n;
9350
9351                         /*
9352                          * We have the `constrained.' prefix opcode.
9353                          */
9354                         if (constrained_class) {
9355                                 if (mini_is_gsharedvt_klass (constrained_class)) {
9356                                         if ((cmethod->klass != mono_defaults.object_class) && constrained_class->valuetype && cmethod->klass->valuetype) {
9357                                                 /* The 'Own method' case below */
9358                                         } else if (cmethod->klass->image != mono_defaults.corlib && !(cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) && !cmethod->klass->valuetype) {
9359                                                 /* 'The type parameter is instantiated as a reference type' case below. */
9360                                         } else {
9361                                                 ins = handle_constrained_gsharedvt_call (cfg, cmethod, fsig, sp, constrained_class, &emit_widen);
9362                                                 CHECK_CFG_EXCEPTION;
9363                                                 g_assert (ins);
9364                                                 goto call_end;
9365                                         }
9366                                 }
9367
9368                                 if (constrained_partial_call) {
9369                                         gboolean need_box = TRUE;
9370
9371                                         /*
9372                                          * The receiver is a valuetype, but the exact type is not known at compile time. This means the
9373                                          * called method is not known at compile time either. The called method could end up being
9374                                          * one of the methods on the parent classes (object/valuetype/enum), in which case we need
9375                                          * to box the receiver.
9376                                          * A simple solution would be to box always and make a normal virtual call, but that would
9377                                          * be bad performance wise.
9378                                          */
9379                                         if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE && cmethod->klass->generic_class) {
9380                                                 /*
9381                                                  * The parent classes implement no generic interfaces, so the called method will be a vtype method, so no boxing neccessary.
9382                                                  */
9383                                                 need_box = FALSE;
9384                                         }
9385
9386                                         if (!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9387                                                 /* The called method is not virtual, i.e. Object:GetType (), the receiver is a vtype, has to box */
9388                                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &constrained_class->byval_arg, sp [0]->dreg, 0);
9389                                                 ins->klass = constrained_class;
9390                                                 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9391                                                 CHECK_CFG_EXCEPTION;
9392                                         } else if (need_box) {
9393                                                 MonoInst *box_type;
9394                                                 MonoBasicBlock *is_ref_bb, *end_bb;
9395                                                 MonoInst *nonbox_call;
9396
9397                                                 /*
9398                                                  * Determine at runtime whenever the called method is defined on object/valuetype/enum, and emit a boxing call
9399                                                  * if needed.
9400                                                  * FIXME: It is possible to inline the called method in a lot of cases, i.e. for T_INT,
9401                                                  * the no-box case goes to a method in Int32, while the box case goes to a method in Enum.
9402                                                  */
9403                                                 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9404
9405                                                 NEW_BBLOCK (cfg, is_ref_bb);
9406                                                 NEW_BBLOCK (cfg, end_bb);
9407
9408                                                 box_type = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_BOX_TYPE);
9409                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, box_type->dreg, MONO_GSHAREDVT_BOX_TYPE_REF);
9410                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_ref_bb);
9411
9412                                                 /* Non-ref case */
9413                                                 nonbox_call = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, NULL);
9414
9415                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
9416
9417                                                 /* Ref case */
9418                                                 MONO_START_BB (cfg, is_ref_bb);
9419                                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &constrained_class->byval_arg, sp [0]->dreg, 0);
9420                                                 ins->klass = constrained_class;
9421                                                 sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9422                                                 ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, NULL);
9423
9424                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
9425
9426                                                 MONO_START_BB (cfg, end_bb);
9427                                                 cfg->cbb = end_bb;
9428
9429                                                 nonbox_call->dreg = ins->dreg;
9430                                                 goto call_end;
9431                                         } else {
9432                                                 g_assert (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE);
9433                                                 addr = emit_get_rgctx_virt_method (cfg, mono_class_check_context_used (constrained_class), constrained_class, cmethod, MONO_RGCTX_INFO_VIRT_METHOD_CODE);
9434                                                 ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, NULL);
9435                                                 goto call_end;
9436                                         }
9437                                 } else if (constrained_class->valuetype && (cmethod->klass == mono_defaults.object_class || cmethod->klass == mono_defaults.enum_class->parent || cmethod->klass == mono_defaults.enum_class)) {
9438                                         /*
9439                                          * The type parameter is instantiated as a valuetype,
9440                                          * but that type doesn't override the method we're
9441                                          * calling, so we need to box `this'.
9442                                          */
9443                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &constrained_class->byval_arg, sp [0]->dreg, 0);
9444                                         ins->klass = constrained_class;
9445                                         sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9446                                         CHECK_CFG_EXCEPTION;
9447                                 } else if (!constrained_class->valuetype) {
9448                                         int dreg = alloc_ireg_ref (cfg);
9449
9450                                         /*
9451                                          * The type parameter is instantiated as a reference
9452                                          * type.  We have a managed pointer on the stack, so
9453                                          * we need to dereference it here.
9454                                          */
9455                                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, sp [0]->dreg, 0);
9456                                         ins->type = STACK_OBJ;
9457                                         sp [0] = ins;
9458                                 } else {
9459                                         if (cmethod->klass->valuetype) {
9460                                                 /* Own method */
9461                                         } else {
9462                                                 /* Interface method */
9463                                                 int ioffset, slot;
9464
9465                                                 mono_class_setup_vtable (constrained_class);
9466                                                 CHECK_TYPELOAD (constrained_class);
9467                                                 ioffset = mono_class_interface_offset (constrained_class, cmethod->klass);
9468                                                 if (ioffset == -1)
9469                                                         TYPE_LOAD_ERROR (constrained_class);
9470                                                 slot = mono_method_get_vtable_slot (cmethod);
9471                                                 if (slot == -1)
9472                                                         TYPE_LOAD_ERROR (cmethod->klass);
9473                                                 cmethod = constrained_class->vtable [ioffset + slot];
9474
9475                                                 if (cmethod->klass == mono_defaults.enum_class) {
9476                                                         /* Enum implements some interfaces, so treat this as the first case */
9477                                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &constrained_class->byval_arg, sp [0]->dreg, 0);
9478                                                         ins->klass = constrained_class;
9479                                                         sp [0] = handle_box (cfg, ins, constrained_class, mono_class_check_context_used (constrained_class));
9480                                                         CHECK_CFG_EXCEPTION;
9481                                                 }
9482                                         }
9483                                         virtual_ = 0;
9484                                 }
9485                                 constrained_class = NULL;
9486                         }
9487
9488                         if (check_call_signature (cfg, fsig, sp))
9489                                 UNVERIFIED;
9490
9491                         if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke"))
9492                                 delegate_invoke = TRUE;
9493
9494                         if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp))) {
9495                                 if (!MONO_TYPE_IS_VOID (fsig->ret)) {
9496                                         type_to_eval_stack_type ((cfg), fsig->ret, ins);
9497                                         emit_widen = FALSE;
9498                                 }
9499
9500                                 goto call_end;
9501                         }
9502
9503                         /*
9504                          * If the callee is a shared method, then its static cctor
9505                          * might not get called after the call was patched.
9506                          */
9507                         if (cfg->gshared && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
9508                                 emit_class_init (cfg, cmethod->klass);
9509                                 CHECK_TYPELOAD (cmethod->klass);
9510                         }
9511
9512                         check_method_sharing (cfg, cmethod, &pass_vtable, &pass_mrgctx);
9513
9514                         if (cfg->gshared) {
9515                                 MonoGenericContext *cmethod_context = mono_method_get_context (cmethod);
9516
9517                                 context_used = mini_method_check_context_used (cfg, cmethod);
9518
9519                                 if (context_used && (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
9520                                         /* Generic method interface
9521                                            calls are resolved via a
9522                                            helper function and don't
9523                                            need an imt. */
9524                                         if (!cmethod_context || !cmethod_context->method_inst)
9525                                                 pass_imt_from_rgctx = TRUE;
9526                                 }
9527
9528                                 /*
9529                                  * If a shared method calls another
9530                                  * shared method then the caller must
9531                                  * have a generic sharing context
9532                                  * because the magic trampoline
9533                                  * requires it.  FIXME: We shouldn't
9534                                  * have to force the vtable/mrgctx
9535                                  * variable here.  Instead there
9536                                  * should be a flag in the cfg to
9537                                  * request a generic sharing context.
9538                                  */
9539                                 if (context_used &&
9540                                                 ((method->flags & METHOD_ATTRIBUTE_STATIC) || method->klass->valuetype))
9541                                         mono_get_vtable_var (cfg);
9542                         }
9543
9544                         if (pass_vtable) {
9545                                 if (context_used) {
9546                                         vtable_arg = emit_get_rgctx_klass (cfg, context_used, cmethod->klass, MONO_RGCTX_INFO_VTABLE);
9547                                 } else {
9548                                         MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
9549
9550                                         CHECK_TYPELOAD (cmethod->klass);
9551                                         EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
9552                                 }
9553                         }
9554
9555                         if (pass_mrgctx) {
9556                                 g_assert (!vtable_arg);
9557
9558                                 if (!cfg->compile_aot) {
9559                                         /*
9560                                          * emit_get_rgctx_method () calls mono_class_vtable () so check
9561                                          * for type load errors before.
9562                                          */
9563                                         mono_class_setup_vtable (cmethod->klass);
9564                                         CHECK_TYPELOAD (cmethod->klass);
9565                                 }
9566
9567                                 vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_METHOD_RGCTX);
9568
9569                                 /* !marshalbyref is needed to properly handle generic methods + remoting */
9570                                 if ((!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
9571                                          MONO_METHOD_IS_FINAL (cmethod)) &&
9572                                         !mono_class_is_marshalbyref (cmethod->klass)) {
9573                                         if (virtual_)
9574                                                 check_this = TRUE;
9575                                         virtual_ = 0;
9576                                 }
9577                         }
9578
9579                         if (pass_imt_from_rgctx) {
9580                                 g_assert (!pass_vtable);
9581
9582                                 imt_arg = emit_get_rgctx_method (cfg, context_used,
9583                                         cmethod, MONO_RGCTX_INFO_METHOD);
9584                         }
9585
9586                         if (check_this)
9587                                 MONO_EMIT_NEW_CHECK_THIS (cfg, sp [0]->dreg);
9588
9589                         /* Calling virtual generic methods */
9590                         if (virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) &&
9591                             !(MONO_METHOD_IS_FINAL (cmethod) &&
9592                               cmethod->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) &&
9593                             fsig->generic_param_count &&
9594                                 !(cfg->gsharedvt && mini_is_gsharedvt_signature (fsig)) &&
9595                                 !cfg->llvm_only) {
9596                                 MonoInst *this_temp, *this_arg_temp, *store;
9597                                 MonoInst *iargs [4];
9598
9599                                 g_assert (fsig->is_inflated);
9600
9601                                 /* Prevent inlining of methods that contain indirect calls */
9602                                 INLINE_FAILURE ("virtual generic call");
9603
9604                                 if (cfg->gsharedvt && mini_is_gsharedvt_signature (fsig))
9605                                         GSHAREDVT_FAILURE (*ip);
9606
9607                                 if (cfg->backend->have_generalized_imt_thunk && cfg->backend->gshared_supported && cmethod->wrapper_type == MONO_WRAPPER_NONE) {
9608                                         g_assert (!imt_arg);
9609                                         if (!context_used)
9610                                                 g_assert (cmethod->is_inflated);
9611                                         imt_arg = emit_get_rgctx_method (cfg, context_used,
9612                                                                                                          cmethod, MONO_RGCTX_INFO_METHOD);
9613                                         ins = mono_emit_method_call_full (cfg, cmethod, fsig, FALSE, sp, sp [0], imt_arg, NULL);
9614                                 } else {
9615                                         this_temp = mono_compile_create_var (cfg, type_from_stack_type (sp [0]), OP_LOCAL);
9616                                         NEW_TEMPSTORE (cfg, store, this_temp->inst_c0, sp [0]);
9617                                         MONO_ADD_INS (cfg->cbb, store);
9618
9619                                         /* FIXME: This should be a managed pointer */
9620                                         this_arg_temp = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9621
9622                                         EMIT_NEW_TEMPLOAD (cfg, iargs [0], this_temp->inst_c0);
9623                                         iargs [1] = emit_get_rgctx_method (cfg, context_used,
9624                                                                                                            cmethod, MONO_RGCTX_INFO_METHOD);
9625                                         EMIT_NEW_TEMPLOADA (cfg, iargs [2], this_arg_temp->inst_c0);
9626                                         addr = mono_emit_jit_icall (cfg,
9627                                                                                                 mono_helper_compile_generic_method, iargs);
9628
9629                                         EMIT_NEW_TEMPLOAD (cfg, sp [0], this_arg_temp->inst_c0);
9630
9631                                         ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, NULL);
9632                                 }
9633
9634                                 goto call_end;
9635                         }
9636
9637                         /*
9638                          * Implement a workaround for the inherent races involved in locking:
9639                          * Monitor.Enter ()
9640                          * try {
9641                          * } finally {
9642                          *    Monitor.Exit ()
9643                          * }
9644                          * If a thread abort happens between the call to Monitor.Enter () and the start of the
9645                          * try block, the Exit () won't be executed, see:
9646                          * http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx
9647                          * To work around this, we extend such try blocks to include the last x bytes
9648                          * of the Monitor.Enter () call.
9649                          */
9650                         if (cmethod->klass == mono_defaults.monitor_class && !strcmp (cmethod->name, "Enter") && mono_method_signature (cmethod)->param_count == 1) {
9651                                 MonoBasicBlock *tbb;
9652
9653                                 GET_BBLOCK (cfg, tbb, ip + 5);
9654                                 /*
9655                                  * Only extend try blocks with a finally, to avoid catching exceptions thrown
9656                                  * from Monitor.Enter like ArgumentNullException.
9657                                  */
9658                                 if (tbb->try_start && MONO_REGION_FLAGS(tbb->region) == MONO_EXCEPTION_CLAUSE_FINALLY) {
9659                                         /* Mark this bblock as needing to be extended */
9660                                         tbb->extend_try_block = TRUE;
9661                                 }
9662                         }
9663
9664                         /* Conversion to a JIT intrinsic */
9665                         if ((cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
9666                                 if (!MONO_TYPE_IS_VOID (fsig->ret)) {
9667                                         type_to_eval_stack_type ((cfg), fsig->ret, ins);
9668                                         emit_widen = FALSE;
9669                                 }
9670                                 goto call_end;
9671                         }
9672
9673                         /* Inlining */
9674                         if ((cfg->opt & MONO_OPT_INLINE) &&
9675                                 (!virtual_ || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
9676                             mono_method_check_inlining (cfg, cmethod)) {
9677                                 int costs;
9678                                 gboolean always = FALSE;
9679
9680                                 if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
9681                                         (cmethod->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
9682                                         /* Prevent inlining of methods that call wrappers */
9683                                         INLINE_FAILURE ("wrapper call");
9684                                         cmethod = mono_marshal_get_native_wrapper (cmethod, TRUE, FALSE);
9685                                         always = TRUE;
9686                                 }
9687
9688                                 costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, always);
9689                                 if (costs) {
9690                                         cfg->real_offset += 5;
9691
9692                                         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
9693                                                 /* *sp is already set by inline_method */
9694                                                 sp++;
9695                                                 push_res = FALSE;
9696                                         }
9697
9698                                         inline_costs += costs;
9699
9700                                         goto call_end;
9701                                 }
9702                         }
9703
9704                         /* Tail recursion elimination */
9705                         if ((cfg->opt & MONO_OPT_TAILC) && call_opcode == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
9706                                 gboolean has_vtargs = FALSE;
9707                                 int i;
9708
9709                                 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9710                                 INLINE_FAILURE ("tail call");
9711
9712                                 /* keep it simple */
9713                                 for (i =  fsig->param_count - 1; i >= 0; i--) {
9714                                         if (MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->params [i]))
9715                                                 has_vtargs = TRUE;
9716                                 }
9717
9718                                 if (!has_vtargs) {
9719                                         for (i = 0; i < n; ++i)
9720                                                 EMIT_NEW_ARGSTORE (cfg, ins, i, sp [i]);
9721                                         MONO_INST_NEW (cfg, ins, OP_BR);
9722                                         MONO_ADD_INS (cfg->cbb, ins);
9723                                         tblock = start_bblock->out_bb [0];
9724                                         link_bblock (cfg, cfg->cbb, tblock);
9725                                         ins->inst_target_bb = tblock;
9726                                         start_new_bblock = 1;
9727
9728                                         /* skip the CEE_RET, too */
9729                                         if (ip_in_bb (cfg, cfg->cbb, ip + 5))
9730                                                 skip_ret = TRUE;
9731                                         push_res = FALSE;
9732                                         goto call_end;
9733                                 }
9734                         }
9735
9736                         inline_costs += 10 * num_calls++;
9737
9738                         /*
9739                          * Making generic calls out of gsharedvt methods.
9740                          * This needs to be used for all generic calls, not just ones with a gsharedvt signature, to avoid
9741                          * patching gshared method addresses into a gsharedvt method.
9742                          */
9743                         if (cfg->gsharedvt && (mini_is_gsharedvt_signature (fsig) || cmethod->is_inflated || cmethod->klass->generic_class) &&
9744                                 !(cmethod->klass->rank && cmethod->klass->byval_arg.type != MONO_TYPE_SZARRAY) &&
9745                                 (!(cfg->llvm_only && virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL)))) {
9746                                 MonoRgctxInfoType info_type;
9747
9748                                 if (virtual_) {
9749                                         //if (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)
9750                                                 //GSHAREDVT_FAILURE (*ip);
9751                                         // disable for possible remoting calls
9752                                         if (fsig->hasthis && (mono_class_is_marshalbyref (method->klass) || method->klass == mono_defaults.object_class))
9753                                                 GSHAREDVT_FAILURE (*ip);
9754                                         if (fsig->generic_param_count) {
9755                                                 /* virtual generic call */
9756                                                 g_assert (!imt_arg);
9757                                                 /* Same as the virtual generic case above */
9758                                                 imt_arg = emit_get_rgctx_method (cfg, context_used,
9759                                                                                                                  cmethod, MONO_RGCTX_INFO_METHOD);
9760                                                 /* This is not needed, as the trampoline code will pass one, and it might be passed in the same reg as the imt arg */
9761                                                 vtable_arg = NULL;
9762                                         } else if ((cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE) && !imt_arg) {
9763                                                 /* This can happen when we call a fully instantiated iface method */
9764                                                 imt_arg = emit_get_rgctx_method (cfg, context_used,
9765                                                                                                                  cmethod, MONO_RGCTX_INFO_METHOD);
9766                                                 vtable_arg = NULL;
9767                                         }
9768                                 }
9769
9770                                 if ((cmethod->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (cmethod->name, "Invoke")))
9771                                         keep_this_alive = sp [0];
9772
9773                                 if (virtual_ && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL))
9774                                         info_type = MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE_VIRT;
9775                                 else
9776                                         info_type = MONO_RGCTX_INFO_METHOD_GSHAREDVT_OUT_TRAMPOLINE;
9777                                 addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, info_type);
9778
9779                                 if (cfg->llvm_only) {
9780                                         // FIXME: Avoid initializing vtable_arg
9781                                         ins = emit_llvmonly_calli (cfg, fsig, sp, addr);
9782                                 } else {
9783                                         ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, imt_arg, vtable_arg);
9784                                 }
9785                                 goto call_end;
9786                         }
9787
9788                         /* Generic sharing */
9789
9790                         /*
9791                          * Use this if the callee is gsharedvt sharable too, since
9792                          * at runtime we might find an instantiation so the call cannot
9793                          * be patched (the 'no_patch' code path in mini-trampolines.c).
9794                          */
9795                         if (context_used && !imt_arg && !array_rank && !delegate_invoke &&
9796                                 (!mono_method_is_generic_sharable_full (cmethod, TRUE, FALSE, FALSE) ||
9797                                  !mono_class_generic_sharing_enabled (cmethod->klass)) &&
9798                                 (!virtual_ || MONO_METHOD_IS_FINAL (cmethod) ||
9799                                  !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL))) {
9800                                 INLINE_FAILURE ("gshared");
9801
9802                                 g_assert (cfg->gshared && cmethod);
9803                                 g_assert (!addr);
9804
9805                                 /*
9806                                  * We are compiling a call to a
9807                                  * generic method from shared code,
9808                                  * which means that we have to look up
9809                                  * the method in the rgctx and do an
9810                                  * indirect call.
9811                                  */
9812                                 if (fsig->hasthis)
9813                                         MONO_EMIT_NEW_CHECK_THIS (cfg, sp [0]->dreg);
9814
9815                                 if (cfg->llvm_only) {
9816                                         if (cfg->gsharedvt && mini_is_gsharedvt_variable_signature (fsig))
9817                                                 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GSHAREDVT_OUT_WRAPPER);
9818                                         else
9819                                                 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9820                                         // FIXME: Avoid initializing imt_arg/vtable_arg
9821                                         ins = emit_llvmonly_calli (cfg, fsig, sp, addr);
9822                                 } else {
9823                                         addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
9824                                         ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, imt_arg, vtable_arg);
9825                                 }
9826                                 goto call_end;
9827                         }
9828
9829                         /* Direct calls to icalls */
9830                         if (direct_icall) {
9831                                 MonoMethod *wrapper;
9832                                 int costs;
9833
9834                                 /* Inline the wrapper */
9835                                 wrapper = mono_marshal_get_native_wrapper (cmethod, TRUE, cfg->compile_aot);
9836
9837                                 costs = inline_method (cfg, wrapper, fsig, sp, ip, cfg->real_offset, TRUE);
9838                                 g_assert (costs > 0);
9839                                 cfg->real_offset += 5;
9840
9841                                 if (!MONO_TYPE_IS_VOID (fsig->ret)) {
9842                                         /* *sp is already set by inline_method */
9843                                         sp++;
9844                                         push_res = FALSE;
9845                                 }
9846
9847                                 inline_costs += costs;
9848
9849                                 goto call_end;
9850                         }
9851
9852                         /* Array methods */
9853                         if (array_rank) {
9854                                 MonoInst *addr;
9855
9856                                 if (strcmp (cmethod->name, "Set") == 0) { /* array Set */
9857                                         MonoInst *val = sp [fsig->param_count];
9858
9859                                         if (val->type == STACK_OBJ) {
9860                                                 MonoInst *iargs [2];
9861
9862                                                 iargs [0] = sp [0];
9863                                                 iargs [1] = val;
9864
9865                                                 mono_emit_jit_icall (cfg, mono_helper_stelem_ref_check, iargs);
9866                                         }
9867
9868                                         addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, TRUE);
9869                                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, val->dreg);
9870                                         if (cfg->gen_write_barriers && val->type == STACK_OBJ && !(val->opcode == OP_PCONST && val->inst_c0 == 0))
9871                                                 emit_write_barrier (cfg, addr, val);
9872                                         if (cfg->gen_write_barriers && mini_is_gsharedvt_klass (cmethod->klass))
9873                                                 GSHAREDVT_FAILURE (*ip);
9874                                 } else if (strcmp (cmethod->name, "Get") == 0) { /* array Get */
9875                                         addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, FALSE);
9876
9877                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, fsig->ret, addr->dreg, 0);
9878                                 } else if (strcmp (cmethod->name, "Address") == 0) { /* array Address */
9879                                         if (!cmethod->klass->element_class->valuetype && !readonly)
9880                                                 mini_emit_check_array_type (cfg, sp [0], cmethod->klass);
9881                                         CHECK_TYPELOAD (cmethod->klass);
9882
9883                                         readonly = FALSE;
9884                                         addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, FALSE);
9885                                         ins = addr;
9886                                 } else {
9887                                         g_assert_not_reached ();
9888                                 }
9889
9890                                 emit_widen = FALSE;
9891                                 goto call_end;
9892                         }
9893
9894                         ins = mini_redirect_call (cfg, cmethod, fsig, sp, virtual_ ? sp [0] : NULL);
9895                         if (ins)
9896                                 goto call_end;
9897
9898                         /* Tail prefix / tail call optimization */
9899
9900                         /* FIXME: Enabling TAILC breaks some inlining/stack trace/etc tests */
9901                         /* FIXME: runtime generic context pointer for jumps? */
9902                         /* FIXME: handle this for generic sharing eventually */
9903                         if ((ins_flag & MONO_INST_TAILCALL) &&
9904                                 !vtable_arg && !cfg->gshared && is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode))
9905                                 supported_tail_call = TRUE;
9906
9907                         if (supported_tail_call) {
9908                                 MonoCallInst *call;
9909
9910                                 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
9911                                 INLINE_FAILURE ("tail call");
9912
9913                                 //printf ("HIT: %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
9914
9915                                 if (cfg->backend->have_op_tail_call) {
9916                                         /* Handle tail calls similarly to normal calls */
9917                                         tail_call = TRUE;
9918                                 } else {
9919                                         emit_instrumentation_call (cfg, mono_profiler_method_leave);
9920
9921                                         MONO_INST_NEW_CALL (cfg, call, OP_JMP);
9922                                         call->tail_call = TRUE;
9923                                         call->method = cmethod;
9924                                         call->signature = mono_method_signature (cmethod);
9925
9926                                         /*
9927                                          * We implement tail calls by storing the actual arguments into the
9928                                          * argument variables, then emitting a CEE_JMP.
9929                                          */
9930                                         for (i = 0; i < n; ++i) {
9931                                                 /* Prevent argument from being register allocated */
9932                                                 arg_array [i]->flags |= MONO_INST_VOLATILE;
9933                                                 EMIT_NEW_ARGSTORE (cfg, ins, i, sp [i]);
9934                                         }
9935                                         ins = (MonoInst*)call;
9936                                         ins->inst_p0 = cmethod;
9937                                         ins->inst_p1 = arg_array [0];
9938                                         MONO_ADD_INS (cfg->cbb, ins);
9939                                         link_bblock (cfg, cfg->cbb, end_bblock);
9940                                         start_new_bblock = 1;
9941
9942                                         // FIXME: Eliminate unreachable epilogs
9943
9944                                         /*
9945                                          * OP_TAILCALL has no return value, so skip the CEE_RET if it is
9946                                          * only reachable from this call.
9947                                          */
9948                                         GET_BBLOCK (cfg, tblock, ip + 5);
9949                                         if (tblock == cfg->cbb || tblock->in_count == 0)
9950                                                 skip_ret = TRUE;
9951                                         push_res = FALSE;
9952
9953                                         goto call_end;
9954                                 }
9955                         }
9956
9957                         /*
9958                          * Synchronized wrappers.
9959                          * Its hard to determine where to replace a method with its synchronized
9960                          * wrapper without causing an infinite recursion. The current solution is
9961                          * to add the synchronized wrapper in the trampolines, and to
9962                          * change the called method to a dummy wrapper, and resolve that wrapper
9963                          * to the real method in mono_jit_compile_method ().
9964                          */
9965                         if (cfg->method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED) {
9966                                 MonoMethod *orig = mono_marshal_method_from_wrapper (cfg->method);
9967                                 if (cmethod == orig || (cmethod->is_inflated && mono_method_get_declaring_generic_method (cmethod) == orig))
9968                                         cmethod = mono_marshal_get_synchronized_inner_wrapper (cmethod);
9969                         }
9970
9971                         /*
9972                          * Virtual calls in llvm-only mode.
9973                          */
9974                         if (cfg->llvm_only && virtual_ && cmethod && (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
9975                                 ins = emit_llvmonly_virtual_call (cfg, cmethod, fsig, context_used, sp);
9976                                 goto call_end;
9977                         }
9978
9979                         /* Common call */
9980                         INLINE_FAILURE ("call");
9981                         ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, virtual_ ? sp [0] : NULL,
9982                                                                                           imt_arg, vtable_arg);
9983
9984                         if (tail_call && !cfg->llvm_only) {
9985                                 link_bblock (cfg, cfg->cbb, end_bblock);
9986                                 start_new_bblock = 1;
9987
9988                                 // FIXME: Eliminate unreachable epilogs
9989
9990                                 /*
9991                                  * OP_TAILCALL has no return value, so skip the CEE_RET if it is
9992                                  * only reachable from this call.
9993                                  */
9994                                 GET_BBLOCK (cfg, tblock, ip + 5);
9995                                 if (tblock == cfg->cbb || tblock->in_count == 0)
9996                                         skip_ret = TRUE;
9997                                 push_res = FALSE;
9998                         }
9999
10000                         call_end:
10001
10002                         /* End of call, INS should contain the result of the call, if any */
10003
10004                         if (push_res && !MONO_TYPE_IS_VOID (fsig->ret)) {
10005                                 g_assert (ins);
10006                                 if (emit_widen)
10007                                         *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
10008                                 else
10009                                         *sp++ = ins;
10010                         }
10011
10012                         if (keep_this_alive) {
10013                                 MonoInst *dummy_use;
10014
10015                                 /* See mono_emit_method_call_full () */
10016                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, keep_this_alive);
10017                         }
10018
10019                         CHECK_CFG_EXCEPTION;
10020
10021                         ip += 5;
10022                         if (skip_ret) {
10023                                 g_assert (*ip == CEE_RET);
10024                                 ip += 1;
10025                         }
10026                         ins_flag = 0;
10027                         constrained_class = NULL;
10028                         if (need_seq_point)
10029                                 emit_seq_point (cfg, method, ip, FALSE, TRUE);
10030                         break;
10031                 }
10032                 case CEE_RET:
10033                         if (cfg->method != method) {
10034                                 /* return from inlined method */
10035                                 /*
10036                                  * If in_count == 0, that means the ret is unreachable due to
10037                                  * being preceeded by a throw. In that case, inline_method () will
10038                                  * handle setting the return value
10039                                  * (test case: test_0_inline_throw ()).
10040                                  */
10041                                 if (return_var && cfg->cbb->in_count) {
10042                                         MonoType *ret_type = mono_method_signature (method)->ret;
10043
10044                                         MonoInst *store;
10045                                         CHECK_STACK (1);
10046                                         --sp;
10047
10048                                         if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10049                                                 UNVERIFIED;
10050
10051                                         //g_assert (returnvar != -1);
10052                                         EMIT_NEW_TEMPSTORE (cfg, store, return_var->inst_c0, *sp);
10053                                         cfg->ret_var_set = TRUE;
10054                                 }
10055                         } else {
10056                                 emit_instrumentation_call (cfg, mono_profiler_method_leave);
10057
10058                                 if (cfg->lmf_var && cfg->cbb->in_count && !cfg->llvm_only)
10059                                         emit_pop_lmf (cfg);
10060
10061                                 if (cfg->ret) {
10062                                         MonoType *ret_type = mini_get_underlying_type (mono_method_signature (method)->ret);
10063
10064                                         if (seq_points && !sym_seq_points) {
10065                                                 /*
10066                                                  * Place a seq point here too even through the IL stack is not
10067                                                  * empty, so a step over on
10068                                                  * call <FOO>
10069                                                  * ret
10070                                                  * will work correctly.
10071                                                  */
10072                                                 NEW_SEQ_POINT (cfg, ins, ip - header->code, TRUE);
10073                                                 MONO_ADD_INS (cfg->cbb, ins);
10074                                         }
10075
10076                                         g_assert (!return_var);
10077                                         CHECK_STACK (1);
10078                                         --sp;
10079
10080                                         if ((method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD || method->wrapper_type == MONO_WRAPPER_NONE) && target_type_is_incompatible (cfg, ret_type, *sp))
10081                                                 UNVERIFIED;
10082
10083                                         emit_setret (cfg, *sp);
10084                                 }
10085                         }
10086                         if (sp != stack_start)
10087                                 UNVERIFIED;
10088                         MONO_INST_NEW (cfg, ins, OP_BR);
10089                         ip++;
10090                         ins->inst_target_bb = end_bblock;
10091                         MONO_ADD_INS (cfg->cbb, ins);
10092                         link_bblock (cfg, cfg->cbb, end_bblock);
10093                         start_new_bblock = 1;
10094                         break;
10095                 case CEE_BR_S:
10096                         CHECK_OPSIZE (2);
10097                         MONO_INST_NEW (cfg, ins, OP_BR);
10098                         ip++;
10099                         target = ip + 1 + (signed char)(*ip);
10100                         ++ip;
10101                         GET_BBLOCK (cfg, tblock, target);
10102                         link_bblock (cfg, cfg->cbb, tblock);
10103                         ins->inst_target_bb = tblock;
10104                         if (sp != stack_start) {
10105                                 handle_stack_args (cfg, stack_start, sp - stack_start);
10106                                 sp = stack_start;
10107                                 CHECK_UNVERIFIABLE (cfg);
10108                         }
10109                         MONO_ADD_INS (cfg->cbb, ins);
10110                         start_new_bblock = 1;
10111                         inline_costs += BRANCH_COST;
10112                         break;
10113                 case CEE_BEQ_S:
10114                 case CEE_BGE_S:
10115                 case CEE_BGT_S:
10116                 case CEE_BLE_S:
10117                 case CEE_BLT_S:
10118                 case CEE_BNE_UN_S:
10119                 case CEE_BGE_UN_S:
10120                 case CEE_BGT_UN_S:
10121                 case CEE_BLE_UN_S:
10122                 case CEE_BLT_UN_S:
10123                         CHECK_OPSIZE (2);
10124                         CHECK_STACK (2);
10125                         MONO_INST_NEW (cfg, ins, *ip + BIG_BRANCH_OFFSET);
10126                         ip++;
10127                         target = ip + 1 + *(signed char*)ip;
10128                         ip++;
10129
10130                         ADD_BINCOND (NULL);
10131
10132                         sp = stack_start;
10133                         inline_costs += BRANCH_COST;
10134                         break;
10135                 case CEE_BR:
10136                         CHECK_OPSIZE (5);
10137                         MONO_INST_NEW (cfg, ins, OP_BR);
10138                         ip++;
10139
10140                         target = ip + 4 + (gint32)read32(ip);
10141                         ip += 4;
10142                         GET_BBLOCK (cfg, tblock, target);
10143                         link_bblock (cfg, cfg->cbb, tblock);
10144                         ins->inst_target_bb = tblock;
10145                         if (sp != stack_start) {
10146                                 handle_stack_args (cfg, stack_start, sp - stack_start);
10147                                 sp = stack_start;
10148                                 CHECK_UNVERIFIABLE (cfg);
10149                         }
10150
10151                         MONO_ADD_INS (cfg->cbb, ins);
10152
10153                         start_new_bblock = 1;
10154                         inline_costs += BRANCH_COST;
10155                         break;
10156                 case CEE_BRFALSE_S:
10157                 case CEE_BRTRUE_S:
10158                 case CEE_BRFALSE:
10159                 case CEE_BRTRUE: {
10160                         MonoInst *cmp;
10161                         gboolean is_short = ((*ip) == CEE_BRFALSE_S) || ((*ip) == CEE_BRTRUE_S);
10162                         gboolean is_true = ((*ip) == CEE_BRTRUE_S) || ((*ip) == CEE_BRTRUE);
10163                         guint32 opsize = is_short ? 1 : 4;
10164
10165                         CHECK_OPSIZE (opsize);
10166                         CHECK_STACK (1);
10167                         if (sp [-1]->type == STACK_VTYPE || sp [-1]->type == STACK_R8)
10168                                 UNVERIFIED;
10169                         ip ++;
10170                         target = ip + opsize + (is_short ? *(signed char*)ip : (gint32)read32(ip));
10171                         ip += opsize;
10172
10173                         sp--;
10174
10175                         GET_BBLOCK (cfg, tblock, target);
10176                         link_bblock (cfg, cfg->cbb, tblock);
10177                         GET_BBLOCK (cfg, tblock, ip);
10178                         link_bblock (cfg, cfg->cbb, tblock);
10179
10180                         if (sp != stack_start) {
10181                                 handle_stack_args (cfg, stack_start, sp - stack_start);
10182                                 CHECK_UNVERIFIABLE (cfg);
10183                         }
10184
10185                         MONO_INST_NEW(cfg, cmp, OP_ICOMPARE_IMM);
10186                         cmp->sreg1 = sp [0]->dreg;
10187                         type_from_op (cfg, cmp, sp [0], NULL);
10188                         CHECK_TYPE (cmp);
10189
10190 #if SIZEOF_REGISTER == 4
10191                         if (cmp->opcode == OP_LCOMPARE_IMM) {
10192                                 /* Convert it to OP_LCOMPARE */
10193                                 MONO_INST_NEW (cfg, ins, OP_I8CONST);
10194                                 ins->type = STACK_I8;
10195                                 ins->dreg = alloc_dreg (cfg, STACK_I8);
10196                                 ins->inst_l = 0;
10197                                 MONO_ADD_INS (cfg->cbb, ins);
10198                                 cmp->opcode = OP_LCOMPARE;
10199                                 cmp->sreg2 = ins->dreg;
10200                         }
10201 #endif
10202                         MONO_ADD_INS (cfg->cbb, cmp);
10203
10204                         MONO_INST_NEW (cfg, ins, is_true ? CEE_BNE_UN : CEE_BEQ);
10205                         type_from_op (cfg, ins, sp [0], NULL);
10206                         MONO_ADD_INS (cfg->cbb, ins);
10207                         ins->inst_many_bb = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);
10208                         GET_BBLOCK (cfg, tblock, target);
10209                         ins->inst_true_bb = tblock;
10210                         GET_BBLOCK (cfg, tblock, ip);
10211                         ins->inst_false_bb = tblock;
10212                         start_new_bblock = 2;
10213
10214                         sp = stack_start;
10215                         inline_costs += BRANCH_COST;
10216                         break;
10217                 }
10218                 case CEE_BEQ:
10219                 case CEE_BGE:
10220                 case CEE_BGT:
10221                 case CEE_BLE:
10222                 case CEE_BLT:
10223                 case CEE_BNE_UN:
10224                 case CEE_BGE_UN:
10225                 case CEE_BGT_UN:
10226                 case CEE_BLE_UN:
10227                 case CEE_BLT_UN:
10228                         CHECK_OPSIZE (5);
10229                         CHECK_STACK (2);
10230                         MONO_INST_NEW (cfg, ins, *ip);
10231                         ip++;
10232                         target = ip + 4 + (gint32)read32(ip);
10233                         ip += 4;
10234
10235                         ADD_BINCOND (NULL);
10236
10237                         sp = stack_start;
10238                         inline_costs += BRANCH_COST;
10239                         break;
10240                 case CEE_SWITCH: {
10241                         MonoInst *src1;
10242                         MonoBasicBlock **targets;
10243                         MonoBasicBlock *default_bblock;
10244                         MonoJumpInfoBBTable *table;
10245                         int offset_reg = alloc_preg (cfg);
10246                         int target_reg = alloc_preg (cfg);
10247                         int table_reg = alloc_preg (cfg);
10248                         int sum_reg = alloc_preg (cfg);
10249                         gboolean use_op_switch;
10250
10251                         CHECK_OPSIZE (5);
10252                         CHECK_STACK (1);
10253                         n = read32 (ip + 1);
10254                         --sp;
10255                         src1 = sp [0];
10256                         if ((src1->type != STACK_I4) && (src1->type != STACK_PTR))
10257                                 UNVERIFIED;
10258
10259                         ip += 5;
10260                         CHECK_OPSIZE (n * sizeof (guint32));
10261                         target = ip + n * sizeof (guint32);
10262
10263                         GET_BBLOCK (cfg, default_bblock, target);
10264                         default_bblock->flags |= BB_INDIRECT_JUMP_TARGET;
10265
10266                         targets = (MonoBasicBlock **)mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * n);
10267                         for (i = 0; i < n; ++i) {
10268                                 GET_BBLOCK (cfg, tblock, target + (gint32)read32(ip));
10269                                 targets [i] = tblock;
10270                                 targets [i]->flags |= BB_INDIRECT_JUMP_TARGET;
10271                                 ip += 4;
10272                         }
10273
10274                         if (sp != stack_start) {
10275                                 /*
10276                                  * Link the current bb with the targets as well, so handle_stack_args
10277                                  * will set their in_stack correctly.
10278                                  */
10279                                 link_bblock (cfg, cfg->cbb, default_bblock);
10280                                 for (i = 0; i < n; ++i)
10281                                         link_bblock (cfg, cfg->cbb, targets [i]);
10282
10283                                 handle_stack_args (cfg, stack_start, sp - stack_start);
10284                                 sp = stack_start;
10285                                 CHECK_UNVERIFIABLE (cfg);
10286
10287                                 /* Undo the links */
10288                                 mono_unlink_bblock (cfg, cfg->cbb, default_bblock);
10289                                 for (i = 0; i < n; ++i)
10290                                         mono_unlink_bblock (cfg, cfg->cbb, targets [i]);
10291                         }
10292
10293                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, src1->dreg, n);
10294                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBGE_UN, default_bblock);
10295
10296                         for (i = 0; i < n; ++i)
10297                                 link_bblock (cfg, cfg->cbb, targets [i]);
10298
10299                         table = (MonoJumpInfoBBTable *)mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
10300                         table->table = targets;
10301                         table->table_size = n;
10302
10303                         use_op_switch = FALSE;
10304 #ifdef TARGET_ARM
10305                         /* ARM implements SWITCH statements differently */
10306                         /* FIXME: Make it use the generic implementation */
10307                         if (!cfg->compile_aot)
10308                                 use_op_switch = TRUE;
10309 #endif
10310
10311                         if (COMPILE_LLVM (cfg))
10312                                 use_op_switch = TRUE;
10313
10314                         cfg->cbb->has_jump_table = 1;
10315
10316                         if (use_op_switch) {
10317                                 MONO_INST_NEW (cfg, ins, OP_SWITCH);
10318                                 ins->sreg1 = src1->dreg;
10319                                 ins->inst_p0 = table;
10320                                 ins->inst_many_bb = targets;
10321                                 ins->klass = (MonoClass *)GUINT_TO_POINTER (n);
10322                                 MONO_ADD_INS (cfg->cbb, ins);
10323                         } else {
10324                                 if (sizeof (gpointer) == 8)
10325                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, offset_reg, src1->dreg, 3);
10326                                 else
10327                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, offset_reg, src1->dreg, 2);
10328
10329 #if SIZEOF_REGISTER == 8
10330                                 /* The upper word might not be zero, and we add it to a 64 bit address later */
10331                                 MONO_EMIT_NEW_UNALU (cfg, OP_ZEXT_I4, offset_reg, offset_reg);
10332 #endif
10333
10334                                 if (cfg->compile_aot) {
10335                                         MONO_EMIT_NEW_AOTCONST (cfg, table_reg, table, MONO_PATCH_INFO_SWITCH);
10336                                 } else {
10337                                         MONO_INST_NEW (cfg, ins, OP_JUMP_TABLE);
10338                                         ins->inst_c1 = MONO_PATCH_INFO_SWITCH;
10339                                         ins->inst_p0 = table;
10340                                         ins->dreg = table_reg;
10341                                         MONO_ADD_INS (cfg->cbb, ins);
10342                                 }
10343
10344                                 /* FIXME: Use load_memindex */
10345                                 MONO_EMIT_NEW_BIALU (cfg, OP_PADD, sum_reg, table_reg, offset_reg);
10346                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, target_reg, sum_reg, 0);
10347                                 MONO_EMIT_NEW_UNALU (cfg, OP_BR_REG, -1, target_reg);
10348                         }
10349                         start_new_bblock = 1;
10350                         inline_costs += (BRANCH_COST * 2);
10351                         break;
10352                 }
10353                 case CEE_LDIND_I1:
10354                 case CEE_LDIND_U1:
10355                 case CEE_LDIND_I2:
10356                 case CEE_LDIND_U2:
10357                 case CEE_LDIND_I4:
10358                 case CEE_LDIND_U4:
10359                 case CEE_LDIND_I8:
10360                 case CEE_LDIND_I:
10361                 case CEE_LDIND_R4:
10362                 case CEE_LDIND_R8:
10363                 case CEE_LDIND_REF:
10364                         CHECK_STACK (1);
10365                         --sp;
10366
10367                         switch (*ip) {
10368                         case CEE_LDIND_R4:
10369                         case CEE_LDIND_R8:
10370                                 dreg = alloc_freg (cfg);
10371                                 break;
10372                         case CEE_LDIND_I8:
10373                                 dreg = alloc_lreg (cfg);
10374                                 break;
10375                         case CEE_LDIND_REF:
10376                                 dreg = alloc_ireg_ref (cfg);
10377                                 break;
10378                         default:
10379                                 dreg = alloc_preg (cfg);
10380                         }
10381
10382                         NEW_LOAD_MEMBASE (cfg, ins, ldind_to_load_membase (*ip), dreg, sp [0]->dreg, 0);
10383                         ins->type = ldind_type [*ip - CEE_LDIND_I1];
10384                         if (*ip == CEE_LDIND_R4)
10385                                 ins->type = cfg->r4_stack_type;
10386                         ins->flags |= ins_flag;
10387                         MONO_ADD_INS (cfg->cbb, ins);
10388                         *sp++ = ins;
10389                         if (ins_flag & MONO_INST_VOLATILE) {
10390                                 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10391                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_ACQ);
10392                         }
10393                         ins_flag = 0;
10394                         ++ip;
10395                         break;
10396                 case CEE_STIND_REF:
10397                 case CEE_STIND_I1:
10398                 case CEE_STIND_I2:
10399                 case CEE_STIND_I4:
10400                 case CEE_STIND_I8:
10401                 case CEE_STIND_R4:
10402                 case CEE_STIND_R8:
10403                 case CEE_STIND_I:
10404                         CHECK_STACK (2);
10405                         sp -= 2;
10406
10407                         if (ins_flag & MONO_INST_VOLATILE) {
10408                                 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
10409                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_REL);
10410                         }
10411
10412                         NEW_STORE_MEMBASE (cfg, ins, stind_to_store_membase (*ip), sp [0]->dreg, 0, sp [1]->dreg);
10413                         ins->flags |= ins_flag;
10414                         ins_flag = 0;
10415
10416                         MONO_ADD_INS (cfg->cbb, ins);
10417
10418                         if (cfg->gen_write_barriers && *ip == CEE_STIND_REF && method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER && !((sp [1]->opcode == OP_PCONST) && (sp [1]->inst_p0 == 0)))
10419                                 emit_write_barrier (cfg, sp [0], sp [1]);
10420
10421                         inline_costs += 1;
10422                         ++ip;
10423                         break;
10424
10425                 case CEE_MUL:
10426                         CHECK_STACK (2);
10427
10428                         MONO_INST_NEW (cfg, ins, (*ip));
10429                         sp -= 2;
10430                         ins->sreg1 = sp [0]->dreg;
10431                         ins->sreg2 = sp [1]->dreg;
10432                         type_from_op (cfg, ins, sp [0], sp [1]);
10433                         CHECK_TYPE (ins);
10434                         ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type);
10435
10436                         /* Use the immediate opcodes if possible */
10437                         if ((sp [1]->opcode == OP_ICONST) && mono_arch_is_inst_imm (sp [1]->inst_c0)) {
10438                                 int imm_opcode = mono_op_to_op_imm_noemul (ins->opcode);
10439                                 if (imm_opcode != -1) {
10440                                         ins->opcode = imm_opcode;
10441                                         ins->inst_p1 = (gpointer)(gssize)(sp [1]->inst_c0);
10442                                         ins->sreg2 = -1;
10443
10444                                         NULLIFY_INS (sp [1]);
10445                                 }
10446                         }
10447
10448                         MONO_ADD_INS ((cfg)->cbb, (ins));
10449
10450                         *sp++ = mono_decompose_opcode (cfg, ins);
10451                         ip++;
10452                         break;
10453                 case CEE_ADD:
10454                 case CEE_SUB:
10455                 case CEE_DIV:
10456                 case CEE_DIV_UN:
10457                 case CEE_REM:
10458                 case CEE_REM_UN:
10459                 case CEE_AND:
10460                 case CEE_OR:
10461                 case CEE_XOR:
10462                 case CEE_SHL:
10463                 case CEE_SHR:
10464                 case CEE_SHR_UN:
10465                         CHECK_STACK (2);
10466
10467                         MONO_INST_NEW (cfg, ins, (*ip));
10468                         sp -= 2;
10469                         ins->sreg1 = sp [0]->dreg;
10470                         ins->sreg2 = sp [1]->dreg;
10471                         type_from_op (cfg, ins, sp [0], sp [1]);
10472                         CHECK_TYPE (ins);
10473                         add_widen_op (cfg, ins, &sp [0], &sp [1]);
10474                         ins->dreg = alloc_dreg ((cfg), (MonoStackType)(ins)->type);
10475
10476                         /* FIXME: Pass opcode to is_inst_imm */
10477
10478                         /* Use the immediate opcodes if possible */
10479                         if (((sp [1]->opcode == OP_ICONST) || (sp [1]->opcode == OP_I8CONST)) && mono_arch_is_inst_imm (sp [1]->opcode == OP_ICONST ? sp [1]->inst_c0 : sp [1]->inst_l)) {
10480                                 int imm_opcode = mono_op_to_op_imm_noemul (ins->opcode);
10481                                 if (imm_opcode != -1) {
10482                                         ins->opcode = imm_opcode;
10483                                         if (sp [1]->opcode == OP_I8CONST) {
10484 #if SIZEOF_REGISTER == 8
10485                                                 ins->inst_imm = sp [1]->inst_l;
10486 #else
10487                                                 ins->inst_ls_word = sp [1]->inst_ls_word;
10488                                                 ins->inst_ms_word = sp [1]->inst_ms_word;
10489 #endif
10490                                         }
10491                                         else
10492                                                 ins->inst_imm = (gssize)(sp [1]->inst_c0);
10493                                         ins->sreg2 = -1;
10494
10495                                         /* Might be followed by an instruction added by add_widen_op */
10496                                         if (sp [1]->next == NULL)
10497                                                 NULLIFY_INS (sp [1]);
10498                                 }
10499                         }
10500                         MONO_ADD_INS ((cfg)->cbb, (ins));
10501
10502                         *sp++ = mono_decompose_opcode (cfg, ins);
10503                         ip++;
10504                         break;
10505                 case CEE_NEG:
10506                 case CEE_NOT:
10507                 case CEE_CONV_I1:
10508                 case CEE_CONV_I2:
10509                 case CEE_CONV_I4:
10510                 case CEE_CONV_R4:
10511                 case CEE_CONV_R8:
10512                 case CEE_CONV_U4:
10513                 case CEE_CONV_I8:
10514                 case CEE_CONV_U8:
10515                 case CEE_CONV_OVF_I8:
10516                 case CEE_CONV_OVF_U8:
10517                 case CEE_CONV_R_UN:
10518                         CHECK_STACK (1);
10519
10520                         /* Special case this earlier so we have long constants in the IR */
10521                         if ((((*ip) == CEE_CONV_I8) || ((*ip) == CEE_CONV_U8)) && (sp [-1]->opcode == OP_ICONST)) {
10522                                 int data = sp [-1]->inst_c0;
10523                                 sp [-1]->opcode = OP_I8CONST;
10524                                 sp [-1]->type = STACK_I8;
10525 #if SIZEOF_REGISTER == 8
10526                                 if ((*ip) == CEE_CONV_U8)
10527                                         sp [-1]->inst_c0 = (guint32)data;
10528                                 else
10529                                         sp [-1]->inst_c0 = data;
10530 #else
10531                                 sp [-1]->inst_ls_word = data;
10532                                 if ((*ip) == CEE_CONV_U8)
10533                                         sp [-1]->inst_ms_word = 0;
10534                                 else
10535                                         sp [-1]->inst_ms_word = (data < 0) ? -1 : 0;
10536 #endif
10537                                 sp [-1]->dreg = alloc_dreg (cfg, STACK_I8);
10538                         }
10539                         else {
10540                                 ADD_UNOP (*ip);
10541                         }
10542                         ip++;
10543                         break;
10544                 case CEE_CONV_OVF_I4:
10545                 case CEE_CONV_OVF_I1:
10546                 case CEE_CONV_OVF_I2:
10547                 case CEE_CONV_OVF_I:
10548                 case CEE_CONV_OVF_U:
10549                         CHECK_STACK (1);
10550
10551                         if (sp [-1]->type == STACK_R8 || sp [-1]->type == STACK_R4) {
10552                                 ADD_UNOP (CEE_CONV_OVF_I8);
10553                                 ADD_UNOP (*ip);
10554                         } else {
10555                                 ADD_UNOP (*ip);
10556                         }
10557                         ip++;
10558                         break;
10559                 case CEE_CONV_OVF_U1:
10560                 case CEE_CONV_OVF_U2:
10561                 case CEE_CONV_OVF_U4:
10562                         CHECK_STACK (1);
10563
10564                         if (sp [-1]->type == STACK_R8 || sp [-1]->type == STACK_R4) {
10565                                 ADD_UNOP (CEE_CONV_OVF_U8);
10566                                 ADD_UNOP (*ip);
10567                         } else {
10568                                 ADD_UNOP (*ip);
10569                         }
10570                         ip++;
10571                         break;
10572                 case CEE_CONV_OVF_I1_UN:
10573                 case CEE_CONV_OVF_I2_UN:
10574                 case CEE_CONV_OVF_I4_UN:
10575                 case CEE_CONV_OVF_I8_UN:
10576                 case CEE_CONV_OVF_U1_UN:
10577                 case CEE_CONV_OVF_U2_UN:
10578                 case CEE_CONV_OVF_U4_UN:
10579                 case CEE_CONV_OVF_U8_UN:
10580                 case CEE_CONV_OVF_I_UN:
10581                 case CEE_CONV_OVF_U_UN:
10582                 case CEE_CONV_U2:
10583                 case CEE_CONV_U1:
10584                 case CEE_CONV_I:
10585                 case CEE_CONV_U:
10586                         CHECK_STACK (1);
10587                         ADD_UNOP (*ip);
10588                         CHECK_CFG_EXCEPTION;
10589                         ip++;
10590                         break;
10591                 case CEE_ADD_OVF:
10592                 case CEE_ADD_OVF_UN:
10593                 case CEE_MUL_OVF:
10594                 case CEE_MUL_OVF_UN:
10595                 case CEE_SUB_OVF:
10596                 case CEE_SUB_OVF_UN:
10597                         CHECK_STACK (2);
10598                         ADD_BINOP (*ip);
10599                         ip++;
10600                         break;
10601                 case CEE_CPOBJ:
10602                         GSHAREDVT_FAILURE (*ip);
10603                         CHECK_OPSIZE (5);
10604                         CHECK_STACK (2);
10605                         token = read32 (ip + 1);
10606                         klass = mini_get_class (method, token, generic_context);
10607                         CHECK_TYPELOAD (klass);
10608                         sp -= 2;
10609                         if (generic_class_is_reference_type (cfg, klass)) {
10610                                 MonoInst *store, *load;
10611                                 int dreg = alloc_ireg_ref (cfg);
10612
10613                                 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, dreg, sp [1]->dreg, 0);
10614                                 load->flags |= ins_flag;
10615                                 MONO_ADD_INS (cfg->cbb, load);
10616
10617                                 NEW_STORE_MEMBASE (cfg, store, OP_STORE_MEMBASE_REG, sp [0]->dreg, 0, dreg);
10618                                 store->flags |= ins_flag;
10619                                 MONO_ADD_INS (cfg->cbb, store);
10620
10621                                 if (cfg->gen_write_barriers && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER)
10622                                         emit_write_barrier (cfg, sp [0], sp [1]);
10623                         } else {
10624                                 mini_emit_stobj (cfg, sp [0], sp [1], klass, FALSE);
10625                         }
10626                         ins_flag = 0;
10627                         ip += 5;
10628                         break;
10629                 case CEE_LDOBJ: {
10630                         int loc_index = -1;
10631                         int stloc_len = 0;
10632
10633                         CHECK_OPSIZE (5);
10634                         CHECK_STACK (1);
10635                         --sp;
10636                         token = read32 (ip + 1);
10637                         klass = mini_get_class (method, token, generic_context);
10638                         CHECK_TYPELOAD (klass);
10639
10640                         /* Optimize the common ldobj+stloc combination */
10641                         switch (ip [5]) {
10642                         case CEE_STLOC_S:
10643                                 loc_index = ip [6];
10644                                 stloc_len = 2;
10645                                 break;
10646                         case CEE_STLOC_0:
10647                         case CEE_STLOC_1:
10648                         case CEE_STLOC_2:
10649                         case CEE_STLOC_3:
10650                                 loc_index = ip [5] - CEE_STLOC_0;
10651                                 stloc_len = 1;
10652                                 break;
10653                         default:
10654                                 break;
10655                         }
10656
10657                         if ((loc_index != -1) && ip_in_bb (cfg, cfg->cbb, ip + 5)) {
10658                                 CHECK_LOCAL (loc_index);
10659
10660                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0);
10661                                 ins->dreg = cfg->locals [loc_index]->dreg;
10662                                 ins->flags |= ins_flag;
10663                                 ip += 5;
10664                                 ip += stloc_len;
10665                                 if (ins_flag & MONO_INST_VOLATILE) {
10666                                         /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10667                                         emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_ACQ);
10668                                 }
10669                                 ins_flag = 0;
10670                                 break;
10671                         }
10672
10673                         /* Optimize the ldobj+stobj combination */
10674                         /* The reference case ends up being a load+store anyway */
10675                         /* Skip this if the operation is volatile. */
10676                         if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass) && !(ins_flag & MONO_INST_VOLATILE)) {
10677                                 CHECK_STACK (1);
10678
10679                                 sp --;
10680
10681                                 mini_emit_stobj (cfg, sp [0], sp [1], klass, FALSE);
10682
10683                                 ip += 5 + 5;
10684                                 ins_flag = 0;
10685                                 break;
10686                         }
10687
10688                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0);
10689                         ins->flags |= ins_flag;
10690                         *sp++ = ins;
10691
10692                         if (ins_flag & MONO_INST_VOLATILE) {
10693                                 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
10694                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_ACQ);
10695                         }
10696
10697                         ip += 5;
10698                         ins_flag = 0;
10699                         inline_costs += 1;
10700                         break;
10701                 }
10702                 case CEE_LDSTR:
10703                         CHECK_STACK_OVF (1);
10704                         CHECK_OPSIZE (5);
10705                         n = read32 (ip + 1);
10706
10707                         if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
10708                                 EMIT_NEW_PCONST (cfg, ins, mono_method_get_wrapper_data (method, n));
10709                                 ins->type = STACK_OBJ;
10710                                 *sp = ins;
10711                         }
10712                         else if (method->wrapper_type != MONO_WRAPPER_NONE) {
10713                                 MonoInst *iargs [1];
10714                                 char *str = (char *)mono_method_get_wrapper_data (method, n);
10715
10716                                 if (cfg->compile_aot)
10717                                         EMIT_NEW_LDSTRLITCONST (cfg, iargs [0], str);
10718                                 else
10719                                         EMIT_NEW_PCONST (cfg, iargs [0], str);
10720                                 *sp = mono_emit_jit_icall (cfg, mono_string_new_wrapper, iargs);
10721                         } else {
10722                                 if (cfg->opt & MONO_OPT_SHARED) {
10723                                         MonoInst *iargs [3];
10724
10725                                         if (cfg->compile_aot) {
10726                                                 cfg->ldstr_list = g_list_prepend (cfg->ldstr_list, GINT_TO_POINTER (n));
10727                                         }
10728                                         EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
10729                                         EMIT_NEW_IMAGECONST (cfg, iargs [1], image);
10730                                         EMIT_NEW_ICONST (cfg, iargs [2], mono_metadata_token_index (n));
10731                                         *sp = mono_emit_jit_icall (cfg, mono_ldstr, iargs);
10732                                         mono_ldstr (cfg->domain, image, mono_metadata_token_index (n));
10733                                 } else {
10734                                         if (cfg->cbb->out_of_line) {
10735                                                 MonoInst *iargs [2];
10736
10737                                                 if (image == mono_defaults.corlib) {
10738                                                         /*
10739                                                          * Avoid relocations in AOT and save some space by using a
10740                                                          * version of helper_ldstr specialized to mscorlib.
10741                                                          */
10742                                                         EMIT_NEW_ICONST (cfg, iargs [0], mono_metadata_token_index (n));
10743                                                         *sp = mono_emit_jit_icall (cfg, mono_helper_ldstr_mscorlib, iargs);
10744                                                 } else {
10745                                                         /* Avoid creating the string object */
10746                                                         EMIT_NEW_IMAGECONST (cfg, iargs [0], image);
10747                                                         EMIT_NEW_ICONST (cfg, iargs [1], mono_metadata_token_index (n));
10748                                                         *sp = mono_emit_jit_icall (cfg, mono_helper_ldstr, iargs);
10749                                                 }
10750                                         }
10751                                         else
10752                                         if (cfg->compile_aot) {
10753                                                 NEW_LDSTRCONST (cfg, ins, image, n);
10754                                                 *sp = ins;
10755                                                 MONO_ADD_INS (cfg->cbb, ins);
10756                                         }
10757                                         else {
10758                                                 NEW_PCONST (cfg, ins, NULL);
10759                                                 ins->type = STACK_OBJ;
10760                                                 ins->inst_p0 = mono_ldstr (cfg->domain, image, mono_metadata_token_index (n));
10761                                                 if (!ins->inst_p0)
10762                                                         OUT_OF_MEMORY_FAILURE;
10763
10764                                                 *sp = ins;
10765                                                 MONO_ADD_INS (cfg->cbb, ins);
10766                                         }
10767                                 }
10768                         }
10769
10770                         sp++;
10771                         ip += 5;
10772                         break;
10773                 case CEE_NEWOBJ: {
10774                         MonoInst *iargs [2];
10775                         MonoMethodSignature *fsig;
10776                         MonoInst this_ins;
10777                         MonoInst *alloc;
10778                         MonoInst *vtable_arg = NULL;
10779
10780                         CHECK_OPSIZE (5);
10781                         token = read32 (ip + 1);
10782                         cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
10783                         CHECK_CFG_ERROR;
10784
10785                         fsig = mono_method_get_signature_checked (cmethod, image, token, generic_context, &cfg->error);
10786                         CHECK_CFG_ERROR;
10787
10788                         mono_save_token_info (cfg, image, token, cmethod);
10789
10790                         if (!mono_class_init (cmethod->klass))
10791                                 TYPE_LOAD_ERROR (cmethod->klass);
10792
10793                         context_used = mini_method_check_context_used (cfg, cmethod);
10794
10795                         if (mono_security_core_clr_enabled ())
10796                                 ensure_method_is_allowed_to_call_method (cfg, method, cmethod);
10797
10798                         if (cfg->gshared && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
10799                                 emit_class_init (cfg, cmethod->klass);
10800                                 CHECK_TYPELOAD (cmethod->klass);
10801                         }
10802
10803                         /*
10804                         if (cfg->gsharedvt) {
10805                                 if (mini_is_gsharedvt_variable_signature (sig))
10806                                         GSHAREDVT_FAILURE (*ip);
10807                         }
10808                         */
10809
10810                         n = fsig->param_count;
10811                         CHECK_STACK (n);
10812
10813                         /*
10814                          * Generate smaller code for the common newobj <exception> instruction in
10815                          * argument checking code.
10816                          */
10817                         if (cfg->cbb->out_of_line && cmethod->klass->image == mono_defaults.corlib &&
10818                                 is_exception_class (cmethod->klass) && n <= 2 &&
10819                                 ((n < 1) || (!fsig->params [0]->byref && fsig->params [0]->type == MONO_TYPE_STRING)) &&
10820                                 ((n < 2) || (!fsig->params [1]->byref && fsig->params [1]->type == MONO_TYPE_STRING))) {
10821                                 MonoInst *iargs [3];
10822
10823                                 sp -= n;
10824
10825                                 EMIT_NEW_ICONST (cfg, iargs [0], cmethod->klass->type_token);
10826                                 switch (n) {
10827                                 case 0:
10828                                         *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_0, iargs);
10829                                         break;
10830                                 case 1:
10831                                         iargs [1] = sp [0];
10832                                         *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_1, iargs);
10833                                         break;
10834                                 case 2:
10835                                         iargs [1] = sp [0];
10836                                         iargs [2] = sp [1];
10837                                         *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_2, iargs);
10838                                         break;
10839                                 default:
10840                                         g_assert_not_reached ();
10841                                 }
10842
10843                                 ip += 5;
10844                                 inline_costs += 5;
10845                                 break;
10846                         }
10847
10848                         /* move the args to allow room for 'this' in the first position */
10849                         while (n--) {
10850                                 --sp;
10851                                 sp [1] = sp [0];
10852                         }
10853
10854                         /* check_call_signature () requires sp[0] to be set */
10855                         this_ins.type = STACK_OBJ;
10856                         sp [0] = &this_ins;
10857                         if (check_call_signature (cfg, fsig, sp))
10858                                 UNVERIFIED;
10859
10860                         iargs [0] = NULL;
10861
10862                         if (mini_class_is_system_array (cmethod->klass)) {
10863                                 *sp = emit_get_rgctx_method (cfg, context_used,
10864                                                                                          cmethod, MONO_RGCTX_INFO_METHOD);
10865
10866                                 /* Avoid varargs in the common case */
10867                                 if (fsig->param_count == 1)
10868                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_1, sp);
10869                                 else if (fsig->param_count == 2)
10870                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_2, sp);
10871                                 else if (fsig->param_count == 3)
10872                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_3, sp);
10873                                 else if (fsig->param_count == 4)
10874                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_4, sp);
10875                                 else
10876                                         alloc = handle_array_new (cfg, fsig->param_count, sp, ip);
10877                         } else if (cmethod->string_ctor) {
10878                                 g_assert (!context_used);
10879                                 g_assert (!vtable_arg);
10880                                 /* we simply pass a null pointer */
10881                                 EMIT_NEW_PCONST (cfg, *sp, NULL);
10882                                 /* now call the string ctor */
10883                                 alloc = mono_emit_method_call_full (cfg, cmethod, fsig, FALSE, sp, NULL, NULL, NULL);
10884                         } else {
10885                                 if (cmethod->klass->valuetype) {
10886                                         iargs [0] = mono_compile_create_var (cfg, &cmethod->klass->byval_arg, OP_LOCAL);
10887                                         emit_init_rvar (cfg, iargs [0]->dreg, &cmethod->klass->byval_arg);
10888                                         EMIT_NEW_TEMPLOADA (cfg, *sp, iargs [0]->inst_c0);
10889
10890                                         alloc = NULL;
10891
10892                                         /*
10893                                          * The code generated by mini_emit_virtual_call () expects
10894                                          * iargs [0] to be a boxed instance, but luckily the vcall
10895                                          * will be transformed into a normal call there.
10896                                          */
10897                                 } else if (context_used) {
10898                                         alloc = handle_alloc (cfg, cmethod->klass, FALSE, context_used);
10899                                         *sp = alloc;
10900                                 } else {
10901                                         MonoVTable *vtable = NULL;
10902
10903                                         if (!cfg->compile_aot)
10904                                                 vtable = mono_class_vtable (cfg->domain, cmethod->klass);
10905                                         CHECK_TYPELOAD (cmethod->klass);
10906
10907                                         /*
10908                                          * TypeInitializationExceptions thrown from the mono_runtime_class_init
10909                                          * call in mono_jit_runtime_invoke () can abort the finalizer thread.
10910                                          * As a workaround, we call class cctors before allocating objects.
10911                                          */
10912                                         if (mini_field_access_needs_cctor_run (cfg, method, cmethod->klass, vtable) && !(g_slist_find (class_inits, cmethod->klass))) {
10913                                                 emit_class_init (cfg, cmethod->klass);
10914                                                 if (cfg->verbose_level > 2)
10915                                                         printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
10916                                                 class_inits = g_slist_prepend (class_inits, cmethod->klass);
10917                                         }
10918
10919                                         alloc = handle_alloc (cfg, cmethod->klass, FALSE, 0);
10920                                         *sp = alloc;
10921                                 }
10922                                 CHECK_CFG_EXCEPTION; /*for handle_alloc*/
10923
10924                                 if (alloc)
10925                                         MONO_EMIT_NEW_UNALU (cfg, OP_NOT_NULL, -1, alloc->dreg);
10926
10927                                 /* Now call the actual ctor */
10928                                 handle_ctor_call (cfg, cmethod, fsig, context_used, sp, ip, &inline_costs);
10929                                 CHECK_CFG_EXCEPTION;
10930                         }
10931
10932                         if (alloc == NULL) {
10933                                 /* Valuetype */
10934                                 EMIT_NEW_TEMPLOAD (cfg, ins, iargs [0]->inst_c0);
10935                                 type_to_eval_stack_type (cfg, &ins->klass->byval_arg, ins);
10936                                 *sp++= ins;
10937                         } else {
10938                                 *sp++ = alloc;
10939                         }
10940
10941                         ip += 5;
10942                         inline_costs += 5;
10943                         if (!(seq_point_locs && mono_bitset_test_fast (seq_point_locs, ip - header->code)))
10944                                 emit_seq_point (cfg, method, ip, FALSE, TRUE);
10945                         break;
10946                 }
10947                 case CEE_CASTCLASS:
10948                         CHECK_STACK (1);
10949                         --sp;
10950                         CHECK_OPSIZE (5);
10951                         token = read32 (ip + 1);
10952                         klass = mini_get_class (method, token, generic_context);
10953                         CHECK_TYPELOAD (klass);
10954                         if (sp [0]->type != STACK_OBJ)
10955                                 UNVERIFIED;
10956
10957                         ins = handle_castclass (cfg, klass, *sp, ip, &inline_costs);
10958                         CHECK_CFG_EXCEPTION;
10959
10960                         *sp ++ = ins;
10961                         ip += 5;
10962                         break;
10963                 case CEE_ISINST: {
10964                         CHECK_STACK (1);
10965                         --sp;
10966                         CHECK_OPSIZE (5);
10967                         token = read32 (ip + 1);
10968                         klass = mini_get_class (method, token, generic_context);
10969                         CHECK_TYPELOAD (klass);
10970                         if (sp [0]->type != STACK_OBJ)
10971                                 UNVERIFIED;
10972
10973                         context_used = mini_class_check_context_used (cfg, klass);
10974
10975                         if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
10976                                 MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
10977                                 MonoInst *args [3];
10978                                 int idx;
10979
10980                                 /* obj */
10981                                 args [0] = *sp;
10982
10983                                 /* klass */
10984                                 EMIT_NEW_CLASSCONST (cfg, args [1], klass);
10985
10986                                 /* inline cache*/
10987                                 idx = get_castclass_cache_idx (cfg);
10988                                 args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
10989
10990                                 *sp++ = mono_emit_method_call (cfg, mono_isinst, args, NULL);
10991                                 ip += 5;
10992                                 inline_costs += 2;
10993                         } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
10994                                 MonoMethod *mono_isinst;
10995                                 MonoInst *iargs [1];
10996                                 int costs;
10997
10998                                 mono_isinst = mono_marshal_get_isinst (klass);
10999                                 iargs [0] = sp [0];
11000
11001                                 costs = inline_method (cfg, mono_isinst, mono_method_signature (mono_isinst),
11002                                                                            iargs, ip, cfg->real_offset, TRUE);
11003                                 CHECK_CFG_EXCEPTION;
11004                                 g_assert (costs > 0);
11005
11006                                 ip += 5;
11007                                 cfg->real_offset += 5;
11008
11009                                 *sp++= iargs [0];
11010
11011                                 inline_costs += costs;
11012                         }
11013                         else {
11014                                 ins = handle_isinst (cfg, klass, *sp, context_used);
11015                                 CHECK_CFG_EXCEPTION;
11016                                 *sp ++ = ins;
11017                                 ip += 5;
11018                         }
11019                         break;
11020                 }
11021                 case CEE_UNBOX_ANY: {
11022                         MonoInst *res, *addr;
11023
11024                         CHECK_STACK (1);
11025                         --sp;
11026                         CHECK_OPSIZE (5);
11027                         token = read32 (ip + 1);
11028                         klass = mini_get_class (method, token, generic_context);
11029                         CHECK_TYPELOAD (klass);
11030
11031                         mono_save_token_info (cfg, image, token, klass);
11032
11033                         context_used = mini_class_check_context_used (cfg, klass);
11034
11035                         if (mini_is_gsharedvt_klass (klass)) {
11036                                 res = handle_unbox_gsharedvt (cfg, klass, *sp);
11037                                 inline_costs += 2;
11038                         } else if (generic_class_is_reference_type (cfg, klass)) {
11039                                 res = handle_castclass (cfg, klass, *sp, ip, &inline_costs);
11040                                 CHECK_CFG_EXCEPTION;
11041                         } else if (mono_class_is_nullable (klass)) {
11042                                 res = handle_unbox_nullable (cfg, *sp, klass, context_used);
11043                         } else {
11044                                 addr = handle_unbox (cfg, klass, sp, context_used);
11045                                 /* LDOBJ */
11046                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0);
11047                                 res = ins;
11048                                 inline_costs += 2;
11049                         }
11050
11051                         *sp ++ = res;
11052                         ip += 5;
11053                         break;
11054                 }
11055                 case CEE_BOX: {
11056                         MonoInst *val;
11057                         MonoClass *enum_class;
11058                         MonoMethod *has_flag;
11059
11060                         CHECK_STACK (1);
11061                         --sp;
11062                         val = *sp;
11063                         CHECK_OPSIZE (5);
11064                         token = read32 (ip + 1);
11065                         klass = mini_get_class (method, token, generic_context);
11066                         CHECK_TYPELOAD (klass);
11067
11068                         mono_save_token_info (cfg, image, token, klass);
11069
11070                         context_used = mini_class_check_context_used (cfg, klass);
11071
11072                         if (generic_class_is_reference_type (cfg, klass)) {
11073                                 *sp++ = val;
11074                                 ip += 5;
11075                                 break;
11076                         }
11077
11078                         if (klass == mono_defaults.void_class)
11079                                 UNVERIFIED;
11080                         if (target_type_is_incompatible (cfg, &klass->byval_arg, *sp))
11081                                 UNVERIFIED;
11082                         /* frequent check in generic code: box (struct), brtrue */
11083
11084                         /*
11085                          * Look for:
11086                          *
11087                          *   <push int/long ptr>
11088                          *   <push int/long>
11089                          *   box MyFlags
11090                          *   constrained. MyFlags
11091                          *   callvirt instace bool class [mscorlib] System.Enum::HasFlag (class [mscorlib] System.Enum)
11092                          *
11093                          * If we find this sequence and the operand types on box and constrained
11094                          * are equal, we can emit a specialized instruction sequence instead of
11095                          * the very slow HasFlag () call.
11096                          */
11097                         if ((cfg->opt & MONO_OPT_INTRINS) &&
11098                             /* Cheap checks first. */
11099                             ip + 5 + 6 + 5 < end &&
11100                             ip [5] == CEE_PREFIX1 &&
11101                             ip [6] == CEE_CONSTRAINED_ &&
11102                             ip [11] == CEE_CALLVIRT &&
11103                             ip_in_bb (cfg, cfg->cbb, ip + 5 + 6 + 5) &&
11104                             mono_class_is_enum (klass) &&
11105                             (enum_class = mini_get_class (method, read32 (ip + 7), generic_context)) &&
11106                             (has_flag = mini_get_method (cfg, method, read32 (ip + 12), NULL, generic_context)) &&
11107                             has_flag->klass == mono_defaults.enum_class &&
11108                             !strcmp (has_flag->name, "HasFlag") &&
11109                             has_flag->signature->hasthis &&
11110                             has_flag->signature->param_count == 1) {
11111                                 CHECK_TYPELOAD (enum_class);
11112
11113                                 if (enum_class == klass) {
11114                                         MonoInst *enum_this, *enum_flag;
11115
11116                                         ip += 5 + 6 + 5;
11117                                         --sp;
11118
11119                                         enum_this = sp [0];
11120                                         enum_flag = sp [1];
11121
11122                                         *sp++ = handle_enum_has_flag (cfg, klass, enum_this, enum_flag);
11123                                         break;
11124                                 }
11125                         }
11126
11127                         // FIXME: LLVM can't handle the inconsistent bb linking
11128                         if (!mono_class_is_nullable (klass) &&
11129                                 !mini_is_gsharedvt_klass (klass) &&
11130                                 ip + 5 < end && ip_in_bb (cfg, cfg->cbb, ip + 5) &&
11131                                 (ip [5] == CEE_BRTRUE ||
11132                                  ip [5] == CEE_BRTRUE_S ||
11133                                  ip [5] == CEE_BRFALSE ||
11134                                  ip [5] == CEE_BRFALSE_S)) {
11135                                 gboolean is_true = ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S;
11136                                 int dreg;
11137                                 MonoBasicBlock *true_bb, *false_bb;
11138
11139                                 ip += 5;
11140
11141                                 if (cfg->verbose_level > 3) {
11142                                         printf ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
11143                                         printf ("<box+brtrue opt>\n");
11144                                 }
11145
11146                                 switch (*ip) {
11147                                 case CEE_BRTRUE_S:
11148                                 case CEE_BRFALSE_S:
11149                                         CHECK_OPSIZE (2);
11150                                         ip++;
11151                                         target = ip + 1 + (signed char)(*ip);
11152                                         ip++;
11153                                         break;
11154                                 case CEE_BRTRUE:
11155                                 case CEE_BRFALSE:
11156                                         CHECK_OPSIZE (5);
11157                                         ip++;
11158                                         target = ip + 4 + (gint)(read32 (ip));
11159                                         ip += 4;
11160                                         break;
11161                                 default:
11162                                         g_assert_not_reached ();
11163                                 }
11164
11165                                 /*
11166                                  * We need to link both bblocks, since it is needed for handling stack
11167                                  * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
11168                                  * Branching to only one of them would lead to inconsistencies, so
11169                                  * generate an ICONST+BRTRUE, the branch opts will get rid of them.
11170                                  */
11171                                 GET_BBLOCK (cfg, true_bb, target);
11172                                 GET_BBLOCK (cfg, false_bb, ip);
11173
11174                                 mono_link_bblock (cfg, cfg->cbb, true_bb);
11175                                 mono_link_bblock (cfg, cfg->cbb, false_bb);
11176
11177                                 if (sp != stack_start) {
11178                                         handle_stack_args (cfg, stack_start, sp - stack_start);
11179                                         sp = stack_start;
11180                                         CHECK_UNVERIFIABLE (cfg);
11181                                 }
11182
11183                                 if (COMPILE_LLVM (cfg)) {
11184                                         dreg = alloc_ireg (cfg);
11185                                         MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
11186                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, dreg, is_true ? 0 : 1);
11187
11188                                         MONO_EMIT_NEW_BRANCH_BLOCK2 (cfg, OP_IBEQ, true_bb, false_bb);
11189                                 } else {
11190                                         /* The JIT can't eliminate the iconst+compare */
11191                                         MONO_INST_NEW (cfg, ins, OP_BR);
11192                                         ins->inst_target_bb = is_true ? true_bb : false_bb;
11193                                         MONO_ADD_INS (cfg->cbb, ins);
11194                                 }
11195
11196                                 start_new_bblock = 1;
11197                                 break;
11198                         }
11199
11200                         *sp++ = handle_box (cfg, val, klass, context_used);
11201
11202                         CHECK_CFG_EXCEPTION;
11203                         ip += 5;
11204                         inline_costs += 1;
11205                         break;
11206                 }
11207                 case CEE_UNBOX: {
11208                         CHECK_STACK (1);
11209                         --sp;
11210                         CHECK_OPSIZE (5);
11211                         token = read32 (ip + 1);
11212                         klass = mini_get_class (method, token, generic_context);
11213                         CHECK_TYPELOAD (klass);
11214
11215                         mono_save_token_info (cfg, image, token, klass);
11216
11217                         context_used = mini_class_check_context_used (cfg, klass);
11218
11219                         if (mono_class_is_nullable (klass)) {
11220                                 MonoInst *val;
11221
11222                                 val = handle_unbox_nullable (cfg, *sp, klass, context_used);
11223                                 EMIT_NEW_VARLOADA (cfg, ins, get_vreg_to_inst (cfg, val->dreg), &val->klass->byval_arg);
11224
11225                                 *sp++= ins;
11226                         } else {
11227                                 ins = handle_unbox (cfg, klass, sp, context_used);
11228                                 *sp++ = ins;
11229                         }
11230                         ip += 5;
11231                         inline_costs += 2;
11232                         break;
11233                 }
11234                 case CEE_LDFLD:
11235                 case CEE_LDFLDA:
11236                 case CEE_STFLD:
11237                 case CEE_LDSFLD:
11238                 case CEE_LDSFLDA:
11239                 case CEE_STSFLD: {
11240                         MonoClassField *field;
11241 #ifndef DISABLE_REMOTING
11242                         int costs;
11243 #endif
11244                         guint foffset;
11245                         gboolean is_instance;
11246                         int op;
11247                         gpointer addr = NULL;
11248                         gboolean is_special_static;
11249                         MonoType *ftype;
11250                         MonoInst *store_val = NULL;
11251                         MonoInst *thread_ins;
11252
11253                         op = *ip;
11254                         is_instance = (op == CEE_LDFLD || op == CEE_LDFLDA || op == CEE_STFLD);
11255                         if (is_instance) {
11256                                 if (op == CEE_STFLD) {
11257                                         CHECK_STACK (2);
11258                                         sp -= 2;
11259                                         store_val = sp [1];
11260                                 } else {
11261                                         CHECK_STACK (1);
11262                                         --sp;
11263                                 }
11264                                 if (sp [0]->type == STACK_I4 || sp [0]->type == STACK_I8 || sp [0]->type == STACK_R8)
11265                                         UNVERIFIED;
11266                                 if (*ip != CEE_LDFLD && sp [0]->type == STACK_VTYPE)
11267                                         UNVERIFIED;
11268                         } else {
11269                                 if (op == CEE_STSFLD) {
11270                                         CHECK_STACK (1);
11271                                         sp--;
11272                                         store_val = sp [0];
11273                                 }
11274                         }
11275
11276                         CHECK_OPSIZE (5);
11277                         token = read32 (ip + 1);
11278                         if (method->wrapper_type != MONO_WRAPPER_NONE) {
11279                                 field = (MonoClassField *)mono_method_get_wrapper_data (method, token);
11280                                 klass = field->parent;
11281                         }
11282                         else {
11283                                 field = mono_field_from_token_checked (image, token, &klass, generic_context, &cfg->error);
11284                                 CHECK_CFG_ERROR;
11285                         }
11286                         if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_field (method, field))
11287                                 FIELD_ACCESS_FAILURE (method, field);
11288                         mono_class_init (klass);
11289
11290                         /* if the class is Critical then transparent code cannot access it's fields */
11291                         if (!is_instance && mono_security_core_clr_enabled ())
11292                                 ensure_method_is_allowed_to_access_field (cfg, method, field);
11293
11294                         /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
11295                            any visible *instance* field  (in fact there's a single case for a static field in Marshal) XXX
11296                         if (mono_security_core_clr_enabled ())
11297                                 ensure_method_is_allowed_to_access_field (cfg, method, field);
11298                         */
11299
11300                         ftype = mono_field_get_type (field);
11301
11302                         /*
11303                          * LDFLD etc. is usable on static fields as well, so convert those cases to
11304                          * the static case.
11305                          */
11306                         if (is_instance && ftype->attrs & FIELD_ATTRIBUTE_STATIC) {
11307                                 switch (op) {
11308                                 case CEE_LDFLD:
11309                                         op = CEE_LDSFLD;
11310                                         break;
11311                                 case CEE_STFLD:
11312                                         op = CEE_STSFLD;
11313                                         break;
11314                                 case CEE_LDFLDA:
11315                                         op = CEE_LDSFLDA;
11316                                         break;
11317                                 default:
11318                                         g_assert_not_reached ();
11319                                 }
11320                                 is_instance = FALSE;
11321                         }
11322
11323                         context_used = mini_class_check_context_used (cfg, klass);
11324
11325                         /* INSTANCE CASE */
11326
11327                         foffset = klass->valuetype? field->offset - sizeof (MonoObject): field->offset;
11328                         if (op == CEE_STFLD) {
11329                                 if (target_type_is_incompatible (cfg, field->type, sp [1]))
11330                                         UNVERIFIED;
11331 #ifndef DISABLE_REMOTING
11332                                 if ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class) {
11333                                         MonoMethod *stfld_wrapper = mono_marshal_get_stfld_wrapper (field->type);
11334                                         MonoInst *iargs [5];
11335
11336                                         GSHAREDVT_FAILURE (op);
11337
11338                                         iargs [0] = sp [0];
11339                                         EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
11340                                         EMIT_NEW_FIELDCONST (cfg, iargs [2], field);
11341                                         EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) :
11342                                                     field->offset);
11343                                         iargs [4] = sp [1];
11344
11345                                         if (cfg->opt & MONO_OPT_INLINE || cfg->compile_aot) {
11346                                                 costs = inline_method (cfg, stfld_wrapper, mono_method_signature (stfld_wrapper),
11347                                                                                            iargs, ip, cfg->real_offset, TRUE);
11348                                                 CHECK_CFG_EXCEPTION;
11349                                                 g_assert (costs > 0);
11350
11351                                                 cfg->real_offset += 5;
11352
11353                                                 inline_costs += costs;
11354                                         } else {
11355                                                 mono_emit_method_call (cfg, stfld_wrapper, iargs, NULL);
11356                                         }
11357                                 } else
11358 #endif
11359                                 {
11360                                         MonoInst *store;
11361
11362                                         MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg);
11363
11364                                         if (mini_is_gsharedvt_klass (klass)) {
11365                                                 MonoInst *offset_ins;
11366
11367                                                 context_used = mini_class_check_context_used (cfg, klass);
11368
11369                                                 offset_ins = emit_get_gsharedvt_info (cfg, field, MONO_RGCTX_INFO_FIELD_OFFSET);
11370                                                 /* The value is offset by 1 */
11371                                                 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PSUB_IMM, offset_ins->dreg, offset_ins->dreg, 1);
11372                                                 dreg = alloc_ireg_mp (cfg);
11373                                                 EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, sp [0]->dreg, offset_ins->dreg);
11374                                                 /* The decomposition will call mini_emit_stobj () which will emit a wbarrier if needed */
11375                                                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, field->type, dreg, 0, sp [1]->dreg);
11376                                         } else {
11377                                                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, field->type, sp [0]->dreg, foffset, sp [1]->dreg);
11378                                         }
11379                                         if (sp [0]->opcode != OP_LDADDR)
11380                                                 store->flags |= MONO_INST_FAULT;
11381
11382                                 if (cfg->gen_write_barriers && mini_type_to_stind (cfg, field->type) == CEE_STIND_REF && !(sp [1]->opcode == OP_PCONST && sp [1]->inst_c0 == 0)) {
11383                                         /* insert call to write barrier */
11384                                         MonoInst *ptr;
11385                                         int dreg;
11386
11387                                         dreg = alloc_ireg_mp (cfg);
11388                                         EMIT_NEW_BIALU_IMM (cfg, ptr, OP_PADD_IMM, dreg, sp [0]->dreg, foffset);
11389                                         emit_write_barrier (cfg, ptr, sp [1]);
11390                                 }
11391
11392                                         store->flags |= ins_flag;
11393                                 }
11394                                 ins_flag = 0;
11395                                 ip += 5;
11396                                 break;
11397                         }
11398
11399 #ifndef DISABLE_REMOTING
11400                         if (is_instance && ((mono_class_is_marshalbyref (klass) && !MONO_CHECK_THIS (sp [0])) || mono_class_is_contextbound (klass) || klass == mono_defaults.marshalbyrefobject_class)) {
11401                                 MonoMethod *wrapper = (op == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
11402                                 MonoInst *iargs [4];
11403
11404                                 GSHAREDVT_FAILURE (op);
11405
11406                                 iargs [0] = sp [0];
11407                                 EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
11408                                 EMIT_NEW_FIELDCONST (cfg, iargs [2], field);
11409                                 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
11410                                 if (cfg->opt & MONO_OPT_INLINE || cfg->compile_aot) {
11411                                         costs = inline_method (cfg, wrapper, mono_method_signature (wrapper),
11412                                                                                    iargs, ip, cfg->real_offset, TRUE);
11413                                         CHECK_CFG_EXCEPTION;
11414                                         g_assert (costs > 0);
11415
11416                                         cfg->real_offset += 5;
11417
11418                                         *sp++ = iargs [0];
11419
11420                                         inline_costs += costs;
11421                                 } else {
11422                                         ins = mono_emit_method_call (cfg, wrapper, iargs, NULL);
11423                                         *sp++ = ins;
11424                                 }
11425                         } else
11426 #endif
11427                         if (is_instance) {
11428                                 if (sp [0]->type == STACK_VTYPE) {
11429                                         MonoInst *var;
11430
11431                                         /* Have to compute the address of the variable */
11432
11433                                         var = get_vreg_to_inst (cfg, sp [0]->dreg);
11434                                         if (!var)
11435                                                 var = mono_compile_create_var_for_vreg (cfg, &klass->byval_arg, OP_LOCAL, sp [0]->dreg);
11436                                         else
11437                                                 g_assert (var->klass == klass);
11438
11439                                         EMIT_NEW_VARLOADA (cfg, ins, var, &var->klass->byval_arg);
11440                                         sp [0] = ins;
11441                                 }
11442
11443                                 if (op == CEE_LDFLDA) {
11444                                         if (sp [0]->type == STACK_OBJ) {
11445                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, sp [0]->dreg, 0);
11446                                                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "NullReferenceException");
11447                                         }
11448
11449                                         dreg = alloc_ireg_mp (cfg);
11450
11451                                         if (mini_is_gsharedvt_klass (klass)) {
11452                                                 MonoInst *offset_ins;
11453
11454                                                 offset_ins = emit_get_gsharedvt_info (cfg, field, MONO_RGCTX_INFO_FIELD_OFFSET);
11455                                                 /* The value is offset by 1 */
11456                                                 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PSUB_IMM, offset_ins->dreg, offset_ins->dreg, 1);
11457                                                 EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, sp [0]->dreg, offset_ins->dreg);
11458                                         } else {
11459                                                 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, dreg, sp [0]->dreg, foffset);
11460                                         }
11461                                         ins->klass = mono_class_from_mono_type (field->type);
11462                                         ins->type = STACK_MP;
11463                                         *sp++ = ins;
11464                                 } else {
11465                                         MonoInst *load;
11466
11467                                         MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg);
11468
11469                                         if (mini_is_gsharedvt_klass (klass)) {
11470                                                 MonoInst *offset_ins;
11471
11472                                                 offset_ins = emit_get_gsharedvt_info (cfg, field, MONO_RGCTX_INFO_FIELD_OFFSET);
11473                                                 /* The value is offset by 1 */
11474                                                 EMIT_NEW_BIALU_IMM (cfg, ins, OP_PSUB_IMM, offset_ins->dreg, offset_ins->dreg, 1);
11475                                                 dreg = alloc_ireg_mp (cfg);
11476                                                 EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, sp [0]->dreg, offset_ins->dreg);
11477                                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, dreg, 0);
11478                                         } else {
11479                                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, sp [0]->dreg, foffset);
11480                                         }
11481                                         load->flags |= ins_flag;
11482                                         if (sp [0]->opcode != OP_LDADDR)
11483                                                 load->flags |= MONO_INST_FAULT;
11484                                         *sp++ = load;
11485                                 }
11486                         }
11487
11488                         if (is_instance) {
11489                                 ins_flag = 0;
11490                                 ip += 5;
11491                                 break;
11492                         }
11493
11494                         /* STATIC CASE */
11495                         context_used = mini_class_check_context_used (cfg, klass);
11496
11497                         if (ftype->attrs & FIELD_ATTRIBUTE_LITERAL)
11498                                 UNVERIFIED;
11499
11500                         /* The special_static_fields field is init'd in mono_class_vtable, so it needs
11501                          * to be called here.
11502                          */
11503                         if (!context_used && !(cfg->opt & MONO_OPT_SHARED)) {
11504                                 mono_class_vtable (cfg->domain, klass);
11505                                 CHECK_TYPELOAD (klass);
11506                         }
11507                         mono_domain_lock (cfg->domain);
11508                         if (cfg->domain->special_static_fields)
11509                                 addr = g_hash_table_lookup (cfg->domain->special_static_fields, field);
11510                         mono_domain_unlock (cfg->domain);
11511
11512                         is_special_static = mono_class_field_is_special_static (field);
11513
11514                         if (is_special_static && ((gsize)addr & 0x80000000) == 0)
11515                                 thread_ins = mono_get_thread_intrinsic (cfg);
11516                         else
11517                                 thread_ins = NULL;
11518
11519                         /* Generate IR to compute the field address */
11520                         if (is_special_static && ((gsize)addr & 0x80000000) == 0 && thread_ins && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
11521                                 /*
11522                                  * Fast access to TLS data
11523                                  * Inline version of get_thread_static_data () in
11524                                  * threads.c.
11525                                  */
11526                                 guint32 offset;
11527                                 int idx, static_data_reg, array_reg, dreg;
11528
11529                                 GSHAREDVT_FAILURE (op);
11530
11531                                 MONO_ADD_INS (cfg->cbb, thread_ins);
11532                                 static_data_reg = alloc_ireg (cfg);
11533                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, MONO_STRUCT_OFFSET (MonoInternalThread, static_data));
11534
11535                                 if (cfg->compile_aot) {
11536                                         int offset_reg, offset2_reg, idx_reg;
11537
11538                                         /* For TLS variables, this will return the TLS offset */
11539                                         EMIT_NEW_SFLDACONST (cfg, ins, field);
11540                                         offset_reg = ins->dreg;
11541                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, offset_reg, offset_reg, 0x7fffffff);
11542                                         idx_reg = alloc_ireg (cfg);
11543                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, idx_reg, offset_reg, 0x3f);
11544                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHL_IMM, idx_reg, idx_reg, sizeof (gpointer) == 8 ? 3 : 2);
11545                                         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, static_data_reg, static_data_reg, idx_reg);
11546                                         array_reg = alloc_ireg (cfg);
11547                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, static_data_reg, 0);
11548                                         offset2_reg = alloc_ireg (cfg);
11549                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHR_UN_IMM, offset2_reg, offset_reg, 6);
11550                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, offset2_reg, offset2_reg, 0x1ffffff);
11551                                         dreg = alloc_ireg (cfg);
11552                                         EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, array_reg, offset2_reg);
11553                                 } else {
11554                                         offset = (gsize)addr & 0x7fffffff;
11555                                         idx = offset & 0x3f;
11556
11557                                         array_reg = alloc_ireg (cfg);
11558                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, static_data_reg, idx * sizeof (gpointer));
11559                                         dreg = alloc_ireg (cfg);
11560                                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_ADD_IMM, dreg, array_reg, ((offset >> 6) & 0x1ffffff));
11561                                 }
11562                         } else if ((cfg->opt & MONO_OPT_SHARED) ||
11563                                         (cfg->compile_aot && is_special_static) ||
11564                                         (context_used && is_special_static)) {
11565                                 MonoInst *iargs [2];
11566
11567                                 g_assert (field->parent);
11568                                 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
11569                                 if (context_used) {
11570                                         iargs [1] = emit_get_rgctx_field (cfg, context_used,
11571                                                 field, MONO_RGCTX_INFO_CLASS_FIELD);
11572                                 } else {
11573                                         EMIT_NEW_FIELDCONST (cfg, iargs [1], field);
11574                                 }
11575                                 ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, iargs);
11576                         } else if (context_used) {
11577                                 MonoInst *static_data;
11578
11579                                 /*
11580                                 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
11581                                         method->klass->name_space, method->klass->name, method->name,
11582                                         depth, field->offset);
11583                                 */
11584
11585                                 if (mono_class_needs_cctor_run (klass, method))
11586                                         emit_class_init (cfg, klass);
11587
11588                                 /*
11589                                  * The pointer we're computing here is
11590                                  *
11591                                  *   super_info.static_data + field->offset
11592                                  */
11593                                 static_data = emit_get_rgctx_klass (cfg, context_used,
11594                                         klass, MONO_RGCTX_INFO_STATIC_DATA);
11595
11596                                 if (mini_is_gsharedvt_klass (klass)) {
11597                                         MonoInst *offset_ins;
11598
11599                                         offset_ins = emit_get_rgctx_field (cfg, context_used, field, MONO_RGCTX_INFO_FIELD_OFFSET);
11600                                         /* The value is offset by 1 */
11601                                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_PSUB_IMM, offset_ins->dreg, offset_ins->dreg, 1);
11602                                         dreg = alloc_ireg_mp (cfg);
11603                                         EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, static_data->dreg, offset_ins->dreg);
11604                                 } else if (field->offset == 0) {
11605                                         ins = static_data;
11606                                 } else {
11607                                         int addr_reg = mono_alloc_preg (cfg);
11608                                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, addr_reg, static_data->dreg, field->offset);
11609                                 }
11610                                 } else if ((cfg->opt & MONO_OPT_SHARED) || (cfg->compile_aot && addr)) {
11611                                 MonoInst *iargs [2];
11612
11613                                 g_assert (field->parent);
11614                                 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
11615                                 EMIT_NEW_FIELDCONST (cfg, iargs [1], field);
11616                                 ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, iargs);
11617                         } else {
11618                                 MonoVTable *vtable = NULL;
11619
11620                                 if (!cfg->compile_aot)
11621                                         vtable = mono_class_vtable (cfg->domain, klass);
11622                                 CHECK_TYPELOAD (klass);
11623
11624                                 if (!addr) {
11625                                         if (mini_field_access_needs_cctor_run (cfg, method, klass, vtable)) {
11626                                                 if (!(g_slist_find (class_inits, klass))) {
11627                                                         emit_class_init (cfg, klass);
11628                                                         if (cfg->verbose_level > 2)
11629                                                                 printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
11630                                                         class_inits = g_slist_prepend (class_inits, klass);
11631                                                 }
11632                                         } else {
11633                                                 if (cfg->run_cctors) {
11634                                                         /* This makes so that inline cannot trigger */
11635                                                         /* .cctors: too many apps depend on them */
11636                                                         /* running with a specific order... */
11637                                                         g_assert (vtable);
11638                                                         if (! vtable->initialized)
11639                                                                 INLINE_FAILURE ("class init");
11640                                                         if (!mono_runtime_class_init_full (vtable, &cfg->error)) {
11641                                                                 mono_cfg_set_exception (cfg, MONO_EXCEPTION_MONO_ERROR);
11642                                                                 g_assert_not_reached ();
11643                                                                 goto exception_exit;
11644                                                         }
11645                                                 }
11646                                         }
11647                                         if (cfg->compile_aot)
11648                                                 EMIT_NEW_SFLDACONST (cfg, ins, field);
11649                                         else {
11650                                                 g_assert (vtable);
11651                                                 addr = (char*)mono_vtable_get_static_field_data (vtable) + field->offset;
11652                                                 g_assert (addr);
11653                                                 EMIT_NEW_PCONST (cfg, ins, addr);
11654                                         }
11655                                 } else {
11656                                         MonoInst *iargs [1];
11657                                         EMIT_NEW_ICONST (cfg, iargs [0], GPOINTER_TO_UINT (addr));
11658                                         ins = mono_emit_jit_icall (cfg, mono_get_special_static_data, iargs);
11659                                 }
11660                         }
11661
11662                         /* Generate IR to do the actual load/store operation */
11663
11664                         if ((op == CEE_STFLD || op == CEE_STSFLD) && (ins_flag & MONO_INST_VOLATILE)) {
11665                                 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11666                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_REL);
11667                         }
11668
11669                         if (op == CEE_LDSFLDA) {
11670                                 ins->klass = mono_class_from_mono_type (ftype);
11671                                 ins->type = STACK_PTR;
11672                                 *sp++ = ins;
11673                         } else if (op == CEE_STSFLD) {
11674                                 MonoInst *store;
11675
11676                                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, ftype, ins->dreg, 0, store_val->dreg);
11677                                 store->flags |= ins_flag;
11678                         } else {
11679                                 gboolean is_const = FALSE;
11680                                 MonoVTable *vtable = NULL;
11681                                 gpointer addr = NULL;
11682
11683                                 if (!context_used) {
11684                                         vtable = mono_class_vtable (cfg->domain, klass);
11685                                         CHECK_TYPELOAD (klass);
11686                                 }
11687                                 if ((ftype->attrs & FIELD_ATTRIBUTE_INIT_ONLY) && (((addr = mono_aot_readonly_field_override (field)) != NULL) ||
11688                                                 (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) && vtable->initialized))) {
11689                                         int ro_type = ftype->type;
11690                                         if (!addr)
11691                                                 addr = (char*)mono_vtable_get_static_field_data (vtable) + field->offset;
11692                                         if (ro_type == MONO_TYPE_VALUETYPE && ftype->data.klass->enumtype) {
11693                                                 ro_type = mono_class_enum_basetype (ftype->data.klass)->type;
11694                                         }
11695
11696                                         GSHAREDVT_FAILURE (op);
11697
11698                                         /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
11699                                         is_const = TRUE;
11700                                         switch (ro_type) {
11701                                         case MONO_TYPE_BOOLEAN:
11702                                         case MONO_TYPE_U1:
11703                                                 EMIT_NEW_ICONST (cfg, *sp, *((guint8 *)addr));
11704                                                 sp++;
11705                                                 break;
11706                                         case MONO_TYPE_I1:
11707                                                 EMIT_NEW_ICONST (cfg, *sp, *((gint8 *)addr));
11708                                                 sp++;
11709                                                 break;
11710                                         case MONO_TYPE_CHAR:
11711                                         case MONO_TYPE_U2:
11712                                                 EMIT_NEW_ICONST (cfg, *sp, *((guint16 *)addr));
11713                                                 sp++;
11714                                                 break;
11715                                         case MONO_TYPE_I2:
11716                                                 EMIT_NEW_ICONST (cfg, *sp, *((gint16 *)addr));
11717                                                 sp++;
11718                                                 break;
11719                                                 break;
11720                                         case MONO_TYPE_I4:
11721                                                 EMIT_NEW_ICONST (cfg, *sp, *((gint32 *)addr));
11722                                                 sp++;
11723                                                 break;
11724                                         case MONO_TYPE_U4:
11725                                                 EMIT_NEW_ICONST (cfg, *sp, *((guint32 *)addr));
11726                                                 sp++;
11727                                                 break;
11728                                         case MONO_TYPE_I:
11729                                         case MONO_TYPE_U:
11730                                         case MONO_TYPE_PTR:
11731                                         case MONO_TYPE_FNPTR:
11732                                                 EMIT_NEW_PCONST (cfg, *sp, *((gpointer *)addr));
11733                                                 type_to_eval_stack_type ((cfg), field->type, *sp);
11734                                                 sp++;
11735                                                 break;
11736                                         case MONO_TYPE_STRING:
11737                                         case MONO_TYPE_OBJECT:
11738                                         case MONO_TYPE_CLASS:
11739                                         case MONO_TYPE_SZARRAY:
11740                                         case MONO_TYPE_ARRAY:
11741                                                 if (!mono_gc_is_moving ()) {
11742                                                         EMIT_NEW_PCONST (cfg, *sp, *((gpointer *)addr));
11743                                                         type_to_eval_stack_type ((cfg), field->type, *sp);
11744                                                         sp++;
11745                                                 } else {
11746                                                         is_const = FALSE;
11747                                                 }
11748                                                 break;
11749                                         case MONO_TYPE_I8:
11750                                         case MONO_TYPE_U8:
11751                                                 EMIT_NEW_I8CONST (cfg, *sp, *((gint64 *)addr));
11752                                                 sp++;
11753                                                 break;
11754                                         case MONO_TYPE_R4:
11755                                         case MONO_TYPE_R8:
11756                                         case MONO_TYPE_VALUETYPE:
11757                                         default:
11758                                                 is_const = FALSE;
11759                                                 break;
11760                                         }
11761                                 }
11762
11763                                 if (!is_const) {
11764                                         MonoInst *load;
11765
11766                                         CHECK_STACK_OVF (1);
11767
11768                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, ins->dreg, 0);
11769                                         load->flags |= ins_flag;
11770                                         ins_flag = 0;
11771                                         *sp++ = load;
11772                                 }
11773                         }
11774
11775                         if ((op == CEE_LDFLD || op == CEE_LDSFLD) && (ins_flag & MONO_INST_VOLATILE)) {
11776                                 /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
11777                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_ACQ);
11778                         }
11779
11780                         ins_flag = 0;
11781                         ip += 5;
11782                         break;
11783                 }
11784                 case CEE_STOBJ:
11785                         CHECK_STACK (2);
11786                         sp -= 2;
11787                         CHECK_OPSIZE (5);
11788                         token = read32 (ip + 1);
11789                         klass = mini_get_class (method, token, generic_context);
11790                         CHECK_TYPELOAD (klass);
11791                         if (ins_flag & MONO_INST_VOLATILE) {
11792                                 /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
11793                                 emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_REL);
11794                         }
11795                         /* FIXME: should check item at sp [1] is compatible with the type of the store. */
11796                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0, sp [1]->dreg);
11797                         ins->flags |= ins_flag;
11798                         if (cfg->gen_write_barriers && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER &&
11799                                         generic_class_is_reference_type (cfg, klass)) {
11800                                 /* insert call to write barrier */
11801                                 emit_write_barrier (cfg, sp [0], sp [1]);
11802                         }
11803                         ins_flag = 0;
11804                         ip += 5;
11805                         inline_costs += 1;
11806                         break;
11807
11808                         /*
11809                          * Array opcodes
11810                          */
11811                 case CEE_NEWARR: {
11812                         MonoInst *len_ins;
11813                         const char *data_ptr;
11814                         int data_size = 0;
11815                         guint32 field_token;
11816
11817                         CHECK_STACK (1);
11818                         --sp;
11819
11820                         CHECK_OPSIZE (5);
11821                         token = read32 (ip + 1);
11822
11823                         klass = mini_get_class (method, token, generic_context);
11824                         CHECK_TYPELOAD (klass);
11825
11826                         context_used = mini_class_check_context_used (cfg, klass);
11827
11828                         if (sp [0]->type == STACK_I8 || (SIZEOF_VOID_P == 8 && sp [0]->type == STACK_PTR)) {
11829                                 MONO_INST_NEW (cfg, ins, OP_LCONV_TO_OVF_U4);
11830                                 ins->sreg1 = sp [0]->dreg;
11831                                 ins->type = STACK_I4;
11832                                 ins->dreg = alloc_ireg (cfg);
11833                                 MONO_ADD_INS (cfg->cbb, ins);
11834                                 *sp = mono_decompose_opcode (cfg, ins);
11835                         }
11836
11837                         if (context_used) {
11838                                 MonoInst *args [3];
11839                                 MonoClass *array_class = mono_array_class_get (klass, 1);
11840                                 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class);
11841
11842                                 /* FIXME: Use OP_NEWARR and decompose later to help abcrem */
11843
11844                                 /* vtable */
11845                                 args [0] = emit_get_rgctx_klass (cfg, context_used,
11846                                         array_class, MONO_RGCTX_INFO_VTABLE);
11847                                 /* array len */
11848                                 args [1] = sp [0];
11849
11850                                 if (managed_alloc)
11851                                         ins = mono_emit_method_call (cfg, managed_alloc, args, NULL);
11852                                 else
11853                                         ins = mono_emit_jit_icall (cfg, ves_icall_array_new_specific, args);
11854                         } else {
11855                                 if (cfg->opt & MONO_OPT_SHARED) {
11856                                         /* Decompose now to avoid problems with references to the domainvar */
11857                                         MonoInst *iargs [3];
11858
11859                                         EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
11860                                         EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
11861                                         iargs [2] = sp [0];
11862
11863                                         ins = mono_emit_jit_icall (cfg, mono_array_new, iargs);
11864                                 } else {
11865                                         /* Decompose later since it is needed by abcrem */
11866                                         MonoClass *array_type = mono_array_class_get (klass, 1);
11867                                         mono_class_vtable (cfg->domain, array_type);
11868                                         CHECK_TYPELOAD (array_type);
11869
11870                                         MONO_INST_NEW (cfg, ins, OP_NEWARR);
11871                                         ins->dreg = alloc_ireg_ref (cfg);
11872                                         ins->sreg1 = sp [0]->dreg;
11873                                         ins->inst_newa_class = klass;
11874                                         ins->type = STACK_OBJ;
11875                                         ins->klass = array_type;
11876                                         MONO_ADD_INS (cfg->cbb, ins);
11877                                         cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
11878                                         cfg->cbb->has_array_access = TRUE;
11879
11880                                         /* Needed so mono_emit_load_get_addr () gets called */
11881                                         mono_get_got_var (cfg);
11882                                 }
11883                         }
11884
11885                         len_ins = sp [0];
11886                         ip += 5;
11887                         *sp++ = ins;
11888                         inline_costs += 1;
11889
11890                         /*
11891                          * we inline/optimize the initialization sequence if possible.
11892                          * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
11893                          * for small sizes open code the memcpy
11894                          * ensure the rva field is big enough
11895                          */
11896                         if ((cfg->opt & MONO_OPT_INTRINS) && ip + 6 < end && ip_in_bb (cfg, cfg->cbb, ip + 6) && (len_ins->opcode == OP_ICONST) && (data_ptr = initialize_array_data (method, cfg->compile_aot, ip, klass, len_ins->inst_c0, &data_size, &field_token))) {
11897                                 MonoMethod *memcpy_method = get_memcpy_method ();
11898                                 MonoInst *iargs [3];
11899                                 int add_reg = alloc_ireg_mp (cfg);
11900
11901                                 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, MONO_STRUCT_OFFSET (MonoArray, vector));
11902                                 if (cfg->compile_aot) {
11903                                         EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
11904                                 } else {
11905                                         EMIT_NEW_PCONST (cfg, iargs [1], (char*)data_ptr);
11906                                 }
11907                                 EMIT_NEW_ICONST (cfg, iargs [2], data_size);
11908                                 mono_emit_method_call (cfg, memcpy_method, iargs, NULL);
11909                                 ip += 11;
11910                         }
11911
11912                         break;
11913                 }
11914                 case CEE_LDLEN:
11915                         CHECK_STACK (1);
11916                         --sp;
11917                         if (sp [0]->type != STACK_OBJ)
11918                                 UNVERIFIED;
11919
11920                         MONO_INST_NEW (cfg, ins, OP_LDLEN);
11921                         ins->dreg = alloc_preg (cfg);
11922                         ins->sreg1 = sp [0]->dreg;
11923                         ins->type = STACK_I4;
11924                         /* This flag will be inherited by the decomposition */
11925                         ins->flags |= MONO_INST_FAULT;
11926                         MONO_ADD_INS (cfg->cbb, ins);
11927                         cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
11928                         cfg->cbb->has_array_access = TRUE;
11929                         ip ++;
11930                         *sp++ = ins;
11931                         break;
11932                 case CEE_LDELEMA:
11933                         CHECK_STACK (2);
11934                         sp -= 2;
11935                         CHECK_OPSIZE (5);
11936                         if (sp [0]->type != STACK_OBJ)
11937                                 UNVERIFIED;
11938
11939                         cfg->flags |= MONO_CFG_HAS_LDELEMA;
11940
11941                         klass = mini_get_class (method, read32 (ip + 1), generic_context);
11942                         CHECK_TYPELOAD (klass);
11943                         /* we need to make sure that this array is exactly the type it needs
11944                          * to be for correctness. the wrappers are lax with their usage
11945                          * so we need to ignore them here
11946                          */
11947                         if (!klass->valuetype && method->wrapper_type == MONO_WRAPPER_NONE && !readonly) {
11948                                 MonoClass *array_class = mono_array_class_get (klass, 1);
11949                                 mini_emit_check_array_type (cfg, sp [0], array_class);
11950                                 CHECK_TYPELOAD (array_class);
11951                         }
11952
11953                         readonly = FALSE;
11954                         ins = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
11955                         *sp++ = ins;
11956                         ip += 5;
11957                         break;
11958                 case CEE_LDELEM:
11959                 case CEE_LDELEM_I1:
11960                 case CEE_LDELEM_U1:
11961                 case CEE_LDELEM_I2:
11962                 case CEE_LDELEM_U2:
11963                 case CEE_LDELEM_I4:
11964                 case CEE_LDELEM_U4:
11965                 case CEE_LDELEM_I8:
11966                 case CEE_LDELEM_I:
11967                 case CEE_LDELEM_R4:
11968                 case CEE_LDELEM_R8:
11969                 case CEE_LDELEM_REF: {
11970                         MonoInst *addr;
11971
11972                         CHECK_STACK (2);
11973                         sp -= 2;
11974
11975                         if (*ip == CEE_LDELEM) {
11976                                 CHECK_OPSIZE (5);
11977                                 token = read32 (ip + 1);
11978                                 klass = mini_get_class (method, token, generic_context);
11979                                 CHECK_TYPELOAD (klass);
11980                                 mono_class_init (klass);
11981                         }
11982                         else
11983                                 klass = array_access_to_klass (*ip);
11984
11985                         if (sp [0]->type != STACK_OBJ)
11986                                 UNVERIFIED;
11987
11988                         cfg->flags |= MONO_CFG_HAS_LDELEMA;
11989
11990                         if (mini_is_gsharedvt_variable_klass (klass)) {
11991                                 // FIXME-VT: OP_ICONST optimization
11992                                 addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
11993                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0);
11994                                 ins->opcode = OP_LOADV_MEMBASE;
11995                         } else if (sp [1]->opcode == OP_ICONST) {
11996                                 int array_reg = sp [0]->dreg;
11997                                 int index_reg = sp [1]->dreg;
11998                                 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + MONO_STRUCT_OFFSET (MonoArray, vector);
11999
12000                                 if (SIZEOF_REGISTER == 8 && COMPILE_LLVM (cfg))
12001                                         MONO_EMIT_NEW_UNALU (cfg, OP_ZEXT_I4, index_reg, index_reg);
12002
12003                                 MONO_EMIT_BOUNDS_CHECK (cfg, array_reg, MonoArray, max_length, index_reg);
12004                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, array_reg, offset);
12005                         } else {
12006                                 addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
12007                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0);
12008                         }
12009                         *sp++ = ins;
12010                         if (*ip == CEE_LDELEM)
12011                                 ip += 5;
12012                         else
12013                                 ++ip;
12014                         break;
12015                 }
12016                 case CEE_STELEM_I:
12017                 case CEE_STELEM_I1:
12018                 case CEE_STELEM_I2:
12019                 case CEE_STELEM_I4:
12020                 case CEE_STELEM_I8:
12021                 case CEE_STELEM_R4:
12022                 case CEE_STELEM_R8:
12023                 case CEE_STELEM_REF:
12024                 case CEE_STELEM: {
12025                         CHECK_STACK (3);
12026                         sp -= 3;
12027
12028                         cfg->flags |= MONO_CFG_HAS_LDELEMA;
12029
12030                         if (*ip == CEE_STELEM) {
12031                                 CHECK_OPSIZE (5);
12032                                 token = read32 (ip + 1);
12033                                 klass = mini_get_class (method, token, generic_context);
12034                                 CHECK_TYPELOAD (klass);
12035                                 mono_class_init (klass);
12036                         }
12037                         else
12038                                 klass = array_access_to_klass (*ip);
12039
12040                         if (sp [0]->type != STACK_OBJ)
12041                                 UNVERIFIED;
12042
12043                         emit_array_store (cfg, klass, sp, TRUE);
12044
12045                         if (*ip == CEE_STELEM)
12046                                 ip += 5;
12047                         else
12048                                 ++ip;
12049                         inline_costs += 1;
12050                         break;
12051                 }
12052                 case CEE_CKFINITE: {
12053                         CHECK_STACK (1);
12054                         --sp;
12055
12056                         if (cfg->llvm_only) {
12057                                 MonoInst *iargs [1];
12058
12059                                 iargs [0] = sp [0];
12060                                 *sp++ = mono_emit_jit_icall (cfg, mono_ckfinite, iargs);
12061                         } else  {
12062                                 MONO_INST_NEW (cfg, ins, OP_CKFINITE);
12063                                 ins->sreg1 = sp [0]->dreg;
12064                                 ins->dreg = alloc_freg (cfg);
12065                                 ins->type = STACK_R8;
12066                                 MONO_ADD_INS (cfg->cbb, ins);
12067
12068                                 *sp++ = mono_decompose_opcode (cfg, ins);
12069                         }
12070
12071                         ++ip;
12072                         break;
12073                 }
12074                 case CEE_REFANYVAL: {
12075                         MonoInst *src_var, *src;
12076
12077                         int klass_reg = alloc_preg (cfg);
12078                         int dreg = alloc_preg (cfg);
12079
12080                         GSHAREDVT_FAILURE (*ip);
12081
12082                         CHECK_STACK (1);
12083                         MONO_INST_NEW (cfg, ins, *ip);
12084                         --sp;
12085                         CHECK_OPSIZE (5);
12086                         klass = mini_get_class (method, read32 (ip + 1), generic_context);
12087                         CHECK_TYPELOAD (klass);
12088
12089                         context_used = mini_class_check_context_used (cfg, klass);
12090
12091                         // FIXME:
12092                         src_var = get_vreg_to_inst (cfg, sp [0]->dreg);
12093                         if (!src_var)
12094                                 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
12095                         EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype);
12096                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass));
12097
12098                         if (context_used) {
12099                                 MonoInst *klass_ins;
12100
12101                                 klass_ins = emit_get_rgctx_klass (cfg, context_used,
12102                                                 klass, MONO_RGCTX_INFO_KLASS);
12103
12104                                 // FIXME:
12105                                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, klass_ins->dreg);
12106                                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
12107                         } else {
12108                                 mini_emit_class_check (cfg, klass_reg, klass);
12109                         }
12110                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value));
12111                         ins->type = STACK_MP;
12112                         ins->klass = klass;
12113                         *sp++ = ins;
12114                         ip += 5;
12115                         break;
12116                 }
12117                 case CEE_MKREFANY: {
12118                         MonoInst *loc, *addr;
12119
12120                         GSHAREDVT_FAILURE (*ip);
12121
12122                         CHECK_STACK (1);
12123                         MONO_INST_NEW (cfg, ins, *ip);
12124                         --sp;
12125                         CHECK_OPSIZE (5);
12126                         klass = mini_get_class (method, read32 (ip + 1), generic_context);
12127                         CHECK_TYPELOAD (klass);
12128
12129                         context_used = mini_class_check_context_used (cfg, klass);
12130
12131                         loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
12132                         EMIT_NEW_TEMPLOADA (cfg, addr, loc->inst_c0);
12133
12134                         if (context_used) {
12135                                 MonoInst *const_ins;
12136                                 int type_reg = alloc_preg (cfg);
12137
12138                                 const_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
12139                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
12140                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12141                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12142                         } else if (cfg->compile_aot) {
12143                                 int const_reg = alloc_preg (cfg);
12144                                 int type_reg = alloc_preg (cfg);
12145
12146                                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
12147                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
12148                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, MONO_STRUCT_OFFSET (MonoClass, byval_arg));
12149                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
12150                         } else {
12151                                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
12152                                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, klass), klass);
12153                         }
12154                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
12155
12156                         EMIT_NEW_TEMPLOAD (cfg, ins, loc->inst_c0);
12157                         ins->type = STACK_VTYPE;
12158                         ins->klass = mono_defaults.typed_reference_class;
12159                         *sp++ = ins;
12160                         ip += 5;
12161                         break;
12162                 }
12163                 case CEE_LDTOKEN: {
12164                         gpointer handle;
12165                         MonoClass *handle_class;
12166
12167                         CHECK_STACK_OVF (1);
12168
12169                         CHECK_OPSIZE (5);
12170                         n = read32 (ip + 1);
12171
12172                         if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD ||
12173                                         method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED) {
12174                                 handle = mono_method_get_wrapper_data (method, n);
12175                                 handle_class = (MonoClass *)mono_method_get_wrapper_data (method, n + 1);
12176                                 if (handle_class == mono_defaults.typehandle_class)
12177                                         handle = &((MonoClass*)handle)->byval_arg;
12178                         }
12179                         else {
12180                                 handle = mono_ldtoken_checked (image, n, &handle_class, generic_context, &cfg->error);
12181                                 CHECK_CFG_ERROR;
12182                         }
12183                         if (!handle)
12184                                 LOAD_ERROR;
12185                         mono_class_init (handle_class);
12186                         if (cfg->gshared) {
12187                                 if (mono_metadata_token_table (n) == MONO_TABLE_TYPEDEF ||
12188                                                 mono_metadata_token_table (n) == MONO_TABLE_TYPEREF) {
12189                                         /* This case handles ldtoken
12190                                            of an open type, like for
12191                                            typeof(Gen<>). */
12192                                         context_used = 0;
12193                                 } else if (handle_class == mono_defaults.typehandle_class) {
12194                                         context_used = mini_class_check_context_used (cfg, mono_class_from_mono_type ((MonoType *)handle));
12195                                 } else if (handle_class == mono_defaults.fieldhandle_class)
12196                                         context_used = mini_class_check_context_used (cfg, ((MonoClassField*)handle)->parent);
12197                                 else if (handle_class == mono_defaults.methodhandle_class)
12198                                         context_used = mini_method_check_context_used (cfg, (MonoMethod *)handle);
12199                                 else
12200                                         g_assert_not_reached ();
12201                         }
12202
12203                         if ((cfg->opt & MONO_OPT_SHARED) &&
12204                                         method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD &&
12205                                         method->wrapper_type != MONO_WRAPPER_SYNCHRONIZED) {
12206                                 MonoInst *addr, *vtvar, *iargs [3];
12207                                 int method_context_used;
12208
12209                                 method_context_used = mini_method_check_context_used (cfg, method);
12210
12211                                 vtvar = mono_compile_create_var (cfg, &handle_class->byval_arg, OP_LOCAL);
12212
12213                                 EMIT_NEW_IMAGECONST (cfg, iargs [0], image);
12214                                 EMIT_NEW_ICONST (cfg, iargs [1], n);
12215                                 if (method_context_used) {
12216                                         iargs [2] = emit_get_rgctx_method (cfg, method_context_used,
12217                                                 method, MONO_RGCTX_INFO_METHOD);
12218                                         ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper_generic_shared, iargs);
12219                                 } else {
12220                                         EMIT_NEW_PCONST (cfg, iargs [2], generic_context);
12221                                         ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper, iargs);
12222                                 }
12223                                 EMIT_NEW_TEMPLOADA (cfg, addr, vtvar->inst_c0);
12224
12225                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, addr->dreg, 0, ins->dreg);
12226
12227                                 EMIT_NEW_TEMPLOAD (cfg, ins, vtvar->inst_c0);
12228                         } else {
12229                                 if ((ip + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 5) &&
12230                                         ((ip [5] == CEE_CALL) || (ip [5] == CEE_CALLVIRT)) &&
12231                                         (cmethod = mini_get_method (cfg, method, read32 (ip + 6), NULL, generic_context)) &&
12232                                         (cmethod->klass == mono_defaults.systemtype_class) &&
12233                                         (strcmp (cmethod->name, "GetTypeFromHandle") == 0)) {
12234                                         MonoClass *tclass = mono_class_from_mono_type ((MonoType *)handle);
12235
12236                                         mono_class_init (tclass);
12237                                         if (context_used) {
12238                                                 ins = emit_get_rgctx_klass (cfg, context_used,
12239                                                         tclass, MONO_RGCTX_INFO_REFLECTION_TYPE);
12240                                         } else if (cfg->compile_aot) {
12241                                                 if (method->wrapper_type) {
12242                                                         mono_error_init (&error); //got to do it since there are multiple conditionals below
12243                                                         if (mono_class_get_checked (tclass->image, tclass->type_token, &error) == tclass && !generic_context) {
12244                                                                 /* Special case for static synchronized wrappers */
12245                                                                 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
12246                                                         } else {
12247                                                                 mono_error_cleanup (&error); /* FIXME don't swallow the error */
12248                                                                 /* FIXME: n is not a normal token */
12249                                                                 DISABLE_AOT (cfg);
12250                                                                 EMIT_NEW_PCONST (cfg, ins, NULL);
12251                                                         }
12252                                                 } else {
12253                                                         EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, image, n, generic_context);
12254                                                 }
12255                                         } else {
12256                                                 MonoReflectionType *rt = mono_type_get_object_checked (cfg->domain, (MonoType *)handle, &cfg->error);
12257                                                 CHECK_CFG_ERROR;
12258                                                 EMIT_NEW_PCONST (cfg, ins, rt);
12259                                         }
12260                                         ins->type = STACK_OBJ;
12261                                         ins->klass = cmethod->klass;
12262                                         ip += 5;
12263                                 } else {
12264                                         MonoInst *addr, *vtvar;
12265
12266                                         vtvar = mono_compile_create_var (cfg, &handle_class->byval_arg, OP_LOCAL);
12267
12268                                         if (context_used) {
12269                                                 if (handle_class == mono_defaults.typehandle_class) {
12270                                                         ins = emit_get_rgctx_klass (cfg, context_used,
12271                                                                         mono_class_from_mono_type ((MonoType *)handle),
12272                                                                         MONO_RGCTX_INFO_TYPE);
12273                                                 } else if (handle_class == mono_defaults.methodhandle_class) {
12274                                                         ins = emit_get_rgctx_method (cfg, context_used,
12275                                                                         (MonoMethod *)handle, MONO_RGCTX_INFO_METHOD);
12276                                                 } else if (handle_class == mono_defaults.fieldhandle_class) {
12277                                                         ins = emit_get_rgctx_field (cfg, context_used,
12278                                                                         (MonoClassField *)handle, MONO_RGCTX_INFO_CLASS_FIELD);
12279                                                 } else {
12280                                                         g_assert_not_reached ();
12281                                                 }
12282                                         } else if (cfg->compile_aot) {
12283                                                 EMIT_NEW_LDTOKENCONST (cfg, ins, image, n, generic_context);
12284                                         } else {
12285                                                 EMIT_NEW_PCONST (cfg, ins, handle);
12286                                         }
12287                                         EMIT_NEW_TEMPLOADA (cfg, addr, vtvar->inst_c0);
12288                                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, addr->dreg, 0, ins->dreg);
12289                                         EMIT_NEW_TEMPLOAD (cfg, ins, vtvar->inst_c0);
12290                                 }
12291                         }
12292
12293                         *sp++ = ins;
12294                         ip += 5;
12295                         break;
12296                 }
12297                 case CEE_THROW:
12298                         CHECK_STACK (1);
12299                         MONO_INST_NEW (cfg, ins, OP_THROW);
12300                         --sp;
12301                         ins->sreg1 = sp [0]->dreg;
12302                         ip++;
12303                         cfg->cbb->out_of_line = TRUE;
12304                         MONO_ADD_INS (cfg->cbb, ins);
12305                         MONO_INST_NEW (cfg, ins, OP_NOT_REACHED);
12306                         MONO_ADD_INS (cfg->cbb, ins);
12307                         sp = stack_start;
12308
12309                         link_bblock (cfg, cfg->cbb, end_bblock);
12310                         start_new_bblock = 1;
12311                         /* This can complicate code generation for llvm since the return value might not be defined */
12312                         if (COMPILE_LLVM (cfg))
12313                                 INLINE_FAILURE ("throw");
12314                         break;
12315                 case CEE_ENDFINALLY:
12316                         /* mono_save_seq_point_info () depends on this */
12317                         if (sp != stack_start)
12318                                 emit_seq_point (cfg, method, ip, FALSE, FALSE);
12319                         MONO_INST_NEW (cfg, ins, OP_ENDFINALLY);
12320                         MONO_ADD_INS (cfg->cbb, ins);
12321                         ip++;
12322                         start_new_bblock = 1;
12323
12324                         /*
12325                          * Control will leave the method so empty the stack, otherwise
12326                          * the next basic block will start with a nonempty stack.
12327                          */
12328                         while (sp != stack_start) {
12329                                 sp--;
12330                         }
12331                         break;
12332                 case CEE_LEAVE:
12333                 case CEE_LEAVE_S: {
12334                         GList *handlers;
12335
12336                         if (*ip == CEE_LEAVE) {
12337                                 CHECK_OPSIZE (5);
12338                                 target = ip + 5 + (gint32)read32(ip + 1);
12339                         } else {
12340                                 CHECK_OPSIZE (2);
12341                                 target = ip + 2 + (signed char)(ip [1]);
12342                         }
12343
12344                         /* empty the stack */
12345                         while (sp != stack_start) {
12346                                 sp--;
12347                         }
12348
12349                         /*
12350                          * If this leave statement is in a catch block, check for a
12351                          * pending exception, and rethrow it if necessary.
12352                          * We avoid doing this in runtime invoke wrappers, since those are called
12353                          * by native code which excepts the wrapper to catch all exceptions.
12354                          */
12355                         for (i = 0; i < header->num_clauses; ++i) {
12356                                 MonoExceptionClause *clause = &header->clauses [i];
12357
12358                                 /*
12359                                  * Use <= in the final comparison to handle clauses with multiple
12360                                  * leave statements, like in bug #78024.
12361                                  * The ordering of the exception clauses guarantees that we find the
12362                                  * innermost clause.
12363                                  */
12364                                 if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && (clause->flags == MONO_EXCEPTION_CLAUSE_NONE) && (ip - header->code + ((*ip == CEE_LEAVE) ? 5 : 2)) <= (clause->handler_offset + clause->handler_len) && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
12365                                         MonoInst *exc_ins;
12366                                         MonoBasicBlock *dont_throw;
12367
12368                                         /*
12369                                           MonoInst *load;
12370
12371                                           NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
12372                                         */
12373
12374                                         exc_ins = mono_emit_jit_icall (cfg, mono_thread_get_undeniable_exception, NULL);
12375
12376                                         NEW_BBLOCK (cfg, dont_throw);
12377
12378                                         /*
12379                                          * Currently, we always rethrow the abort exception, despite the
12380                                          * fact that this is not correct. See thread6.cs for an example.
12381                                          * But propagating the abort exception is more important than
12382                                          * getting the sematics right.
12383                                          */
12384                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, exc_ins->dreg, 0);
12385                                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, dont_throw);
12386                                         MONO_EMIT_NEW_UNALU (cfg, OP_THROW, -1, exc_ins->dreg);
12387
12388                                         MONO_START_BB (cfg, dont_throw);
12389                                 }
12390                         }
12391
12392 #ifdef ENABLE_LLVM
12393                         cfg->cbb->try_end = (intptr_t)(ip - header->code);
12394 #endif
12395
12396                         if ((handlers = mono_find_final_block (cfg, ip, target, MONO_EXCEPTION_CLAUSE_FINALLY))) {
12397                                 GList *tmp;
12398                                 MonoExceptionClause *clause;
12399
12400                                 for (tmp = handlers; tmp; tmp = tmp->next) {
12401                                         clause = (MonoExceptionClause *)tmp->data;
12402                                         tblock = cfg->cil_offset_to_bb [clause->handler_offset];
12403                                         g_assert (tblock);
12404                                         link_bblock (cfg, cfg->cbb, tblock);
12405                                         MONO_INST_NEW (cfg, ins, OP_CALL_HANDLER);
12406                                         ins->inst_target_bb = tblock;
12407                                         ins->inst_eh_block = clause;
12408                                         MONO_ADD_INS (cfg->cbb, ins);
12409                                         cfg->cbb->has_call_handler = 1;
12410                                         if (COMPILE_LLVM (cfg)) {
12411                                                 MonoBasicBlock *target_bb;
12412
12413                                                 /*
12414                                                  * Link the finally bblock with the target, since it will
12415                                                  * conceptually branch there.
12416                                                  */
12417                                                 GET_BBLOCK (cfg, tblock, cfg->cil_start + clause->handler_offset + clause->handler_len - 1);
12418                                                 GET_BBLOCK (cfg, target_bb, target);
12419                                                 link_bblock (cfg, tblock, target_bb);
12420                                         }
12421                                 }
12422                                 g_list_free (handlers);
12423                         }
12424
12425                         MONO_INST_NEW (cfg, ins, OP_BR);
12426                         MONO_ADD_INS (cfg->cbb, ins);
12427                         GET_BBLOCK (cfg, tblock, target);
12428                         link_bblock (cfg, cfg->cbb, tblock);
12429                         ins->inst_target_bb = tblock;
12430
12431                         start_new_bblock = 1;
12432
12433                         if (*ip == CEE_LEAVE)
12434                                 ip += 5;
12435                         else
12436                                 ip += 2;
12437
12438                         break;
12439                 }
12440
12441                         /*
12442                          * Mono specific opcodes
12443                          */
12444                 case MONO_CUSTOM_PREFIX: {
12445
12446                         g_assert (method->wrapper_type != MONO_WRAPPER_NONE);
12447
12448                         CHECK_OPSIZE (2);
12449                         switch (ip [1]) {
12450                         case CEE_MONO_ICALL: {
12451                                 gpointer func;
12452                                 MonoJitICallInfo *info;
12453
12454                                 token = read32 (ip + 2);
12455                                 func = mono_method_get_wrapper_data (method, token);
12456                                 info = mono_find_jit_icall_by_addr (func);
12457                                 if (!info)
12458                                         g_error ("Could not find icall address in wrapper %s", mono_method_full_name (method, 1));
12459                                 g_assert (info);
12460
12461                                 CHECK_STACK (info->sig->param_count);
12462                                 sp -= info->sig->param_count;
12463
12464                                 ins = mono_emit_jit_icall (cfg, info->func, sp);
12465                                 if (!MONO_TYPE_IS_VOID (info->sig->ret))
12466                                         *sp++ = ins;
12467
12468                                 ip += 6;
12469                                 inline_costs += 10 * num_calls++;
12470
12471                                 break;
12472                         }
12473                         case CEE_MONO_LDPTR_CARD_TABLE:
12474                         case CEE_MONO_LDPTR_NURSERY_START:
12475                         case CEE_MONO_LDPTR_NURSERY_BITS:
12476                         case CEE_MONO_LDPTR_INT_REQ_FLAG: {
12477                                 CHECK_STACK_OVF (1);
12478
12479                                 switch (ip [1]) {
12480                                         case CEE_MONO_LDPTR_CARD_TABLE:
12481                                                 ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_GC_CARD_TABLE_ADDR, NULL);
12482                                                 break;
12483                                         case CEE_MONO_LDPTR_NURSERY_START:
12484                                                 ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_GC_NURSERY_START, NULL);
12485                                                 break;
12486                                         case CEE_MONO_LDPTR_NURSERY_BITS:
12487                                                 ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_GC_NURSERY_BITS, NULL);
12488                                                 break;
12489                                         case CEE_MONO_LDPTR_INT_REQ_FLAG:
12490                                                 ins = emit_runtime_constant (cfg, MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG, NULL);
12491                                                 break;
12492                                 }
12493
12494                                 *sp++ = ins;
12495                                 ip += 2;
12496                                 inline_costs += 10 * num_calls++;
12497                                 break;
12498                         }
12499                         case CEE_MONO_LDPTR: {
12500                                 gpointer ptr;
12501
12502                                 CHECK_STACK_OVF (1);
12503                                 CHECK_OPSIZE (6);
12504                                 token = read32 (ip + 2);
12505
12506                                 ptr = mono_method_get_wrapper_data (method, token);
12507                                 EMIT_NEW_PCONST (cfg, ins, ptr);
12508                                 *sp++ = ins;
12509                                 ip += 6;
12510                                 inline_costs += 10 * num_calls++;
12511                                 /* Can't embed random pointers into AOT code */
12512                                 DISABLE_AOT (cfg);
12513                                 break;
12514                         }
12515                         case CEE_MONO_JIT_ICALL_ADDR: {
12516                                 MonoJitICallInfo *callinfo;
12517                                 gpointer ptr;
12518
12519                                 CHECK_STACK_OVF (1);
12520                                 CHECK_OPSIZE (6);
12521                                 token = read32 (ip + 2);
12522
12523                                 ptr = mono_method_get_wrapper_data (method, token);
12524                                 callinfo = mono_find_jit_icall_by_addr (ptr);
12525                                 g_assert (callinfo);
12526                                 EMIT_NEW_JIT_ICALL_ADDRCONST (cfg, ins, (char*)callinfo->name);
12527                                 *sp++ = ins;
12528                                 ip += 6;
12529                                 inline_costs += 10 * num_calls++;
12530                                 break;
12531                         }
12532                         case CEE_MONO_ICALL_ADDR: {
12533                                 MonoMethod *cmethod;
12534                                 gpointer ptr;
12535
12536                                 CHECK_STACK_OVF (1);
12537                                 CHECK_OPSIZE (6);
12538                                 token = read32 (ip + 2);
12539
12540                                 cmethod = (MonoMethod *)mono_method_get_wrapper_data (method, token);
12541
12542                                 if (cfg->compile_aot) {
12543                                         EMIT_NEW_AOTCONST (cfg, ins, MONO_PATCH_INFO_ICALL_ADDR, cmethod);
12544                                 } else {
12545                                         ptr = mono_lookup_internal_call (cmethod);
12546                                         g_assert (ptr);
12547                                         EMIT_NEW_PCONST (cfg, ins, ptr);
12548                                 }
12549                                 *sp++ = ins;
12550                                 ip += 6;
12551                                 break;
12552                         }
12553                         case CEE_MONO_VTADDR: {
12554                                 MonoInst *src_var, *src;
12555
12556                                 CHECK_STACK (1);
12557                                 --sp;
12558
12559                                 // FIXME:
12560                                 src_var = get_vreg_to_inst (cfg, sp [0]->dreg);
12561                                 EMIT_NEW_VARLOADA ((cfg), (src), src_var, src_var->inst_vtype);
12562                                 *sp++ = src;
12563                                 ip += 2;
12564                                 break;
12565                         }
12566                         case CEE_MONO_NEWOBJ: {
12567                                 MonoInst *iargs [2];
12568
12569                                 CHECK_STACK_OVF (1);
12570                                 CHECK_OPSIZE (6);
12571                                 token = read32 (ip + 2);
12572                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
12573                                 mono_class_init (klass);
12574                                 NEW_DOMAINCONST (cfg, iargs [0]);
12575                                 MONO_ADD_INS (cfg->cbb, iargs [0]);
12576                                 NEW_CLASSCONST (cfg, iargs [1], klass);
12577                                 MONO_ADD_INS (cfg->cbb, iargs [1]);
12578                                 *sp++ = mono_emit_jit_icall (cfg, ves_icall_object_new, iargs);
12579                                 ip += 6;
12580                                 inline_costs += 10 * num_calls++;
12581                                 break;
12582                         }
12583                         case CEE_MONO_OBJADDR:
12584                                 CHECK_STACK (1);
12585                                 --sp;
12586                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
12587                                 ins->dreg = alloc_ireg_mp (cfg);
12588                                 ins->sreg1 = sp [0]->dreg;
12589                                 ins->type = STACK_MP;
12590                                 MONO_ADD_INS (cfg->cbb, ins);
12591                                 *sp++ = ins;
12592                                 ip += 2;
12593                                 break;
12594                         case CEE_MONO_LDNATIVEOBJ:
12595                                 /*
12596                                  * Similar to LDOBJ, but instead load the unmanaged
12597                                  * representation of the vtype to the stack.
12598                                  */
12599                                 CHECK_STACK (1);
12600                                 CHECK_OPSIZE (6);
12601                                 --sp;
12602                                 token = read32 (ip + 2);
12603                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
12604                                 g_assert (klass->valuetype);
12605                                 mono_class_init (klass);
12606
12607                                 {
12608                                         MonoInst *src, *dest, *temp;
12609
12610                                         src = sp [0];
12611                                         temp = mono_compile_create_var (cfg, &klass->byval_arg, OP_LOCAL);
12612                                         temp->backend.is_pinvoke = 1;
12613                                         EMIT_NEW_TEMPLOADA (cfg, dest, temp->inst_c0);
12614                                         mini_emit_stobj (cfg, dest, src, klass, TRUE);
12615
12616                                         EMIT_NEW_TEMPLOAD (cfg, dest, temp->inst_c0);
12617                                         dest->type = STACK_VTYPE;
12618                                         dest->klass = klass;
12619
12620                                         *sp ++ = dest;
12621                                         ip += 6;
12622                                 }
12623                                 break;
12624                         case CEE_MONO_RETOBJ: {
12625                                 /*
12626                                  * Same as RET, but return the native representation of a vtype
12627                                  * to the caller.
12628                                  */
12629                                 g_assert (cfg->ret);
12630                                 g_assert (mono_method_signature (method)->pinvoke);
12631                                 CHECK_STACK (1);
12632                                 --sp;
12633
12634                                 CHECK_OPSIZE (6);
12635                                 token = read32 (ip + 2);
12636                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
12637
12638                                 if (!cfg->vret_addr) {
12639                                         g_assert (cfg->ret_var_is_local);
12640
12641                                         EMIT_NEW_VARLOADA (cfg, ins, cfg->ret, cfg->ret->inst_vtype);
12642                                 } else {
12643                                         EMIT_NEW_RETLOADA (cfg, ins);
12644                                 }
12645                                 mini_emit_stobj (cfg, ins, sp [0], klass, TRUE);
12646
12647                                 if (sp != stack_start)
12648                                         UNVERIFIED;
12649
12650                                 MONO_INST_NEW (cfg, ins, OP_BR);
12651                                 ins->inst_target_bb = end_bblock;
12652                                 MONO_ADD_INS (cfg->cbb, ins);
12653                                 link_bblock (cfg, cfg->cbb, end_bblock);
12654                                 start_new_bblock = 1;
12655                                 ip += 6;
12656                                 break;
12657                         }
12658                         case CEE_MONO_CISINST:
12659                         case CEE_MONO_CCASTCLASS: {
12660                                 int token;
12661                                 CHECK_STACK (1);
12662                                 --sp;
12663                                 CHECK_OPSIZE (6);
12664                                 token = read32 (ip + 2);
12665                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
12666                                 if (ip [1] == CEE_MONO_CISINST)
12667                                         ins = handle_cisinst (cfg, klass, sp [0]);
12668                                 else
12669                                         ins = handle_ccastclass (cfg, klass, sp [0]);
12670                                 *sp++ = ins;
12671                                 ip += 6;
12672                                 break;
12673                         }
12674                         case CEE_MONO_SAVE_LMF:
12675                         case CEE_MONO_RESTORE_LMF:
12676                                 ip += 2;
12677                                 break;
12678                         case CEE_MONO_CLASSCONST:
12679                                 CHECK_STACK_OVF (1);
12680                                 CHECK_OPSIZE (6);
12681                                 token = read32 (ip + 2);
12682                                 EMIT_NEW_CLASSCONST (cfg, ins, mono_method_get_wrapper_data (method, token));
12683                                 *sp++ = ins;
12684                                 ip += 6;
12685                                 inline_costs += 10 * num_calls++;
12686                                 break;
12687                         case CEE_MONO_NOT_TAKEN:
12688                                 cfg->cbb->out_of_line = TRUE;
12689                                 ip += 2;
12690                                 break;
12691                         case CEE_MONO_TLS: {
12692                                 MonoTlsKey key;
12693
12694                                 CHECK_STACK_OVF (1);
12695                                 CHECK_OPSIZE (6);
12696                                 key = (MonoTlsKey)read32 (ip + 2);
12697                                 g_assert (key < TLS_KEY_NUM);
12698
12699                                 ins = mono_create_tls_get (cfg, key);
12700                                 if (!ins) {
12701                                         if (cfg->compile_aot) {
12702                                                 DISABLE_AOT (cfg);
12703                                                 MONO_INST_NEW (cfg, ins, OP_TLS_GET);
12704                                                 ins->dreg = alloc_preg (cfg);
12705                                                 ins->type = STACK_PTR;
12706                                         } else {
12707                                                 g_assert_not_reached ();
12708                                         }
12709                                 }
12710                                 ins->type = STACK_PTR;
12711                                 MONO_ADD_INS (cfg->cbb, ins);
12712                                 *sp++ = ins;
12713                                 ip += 6;
12714                                 break;
12715                         }
12716                         case CEE_MONO_DYN_CALL: {
12717                                 MonoCallInst *call;
12718
12719                                 /* It would be easier to call a trampoline, but that would put an
12720                                  * extra frame on the stack, confusing exception handling. So
12721                                  * implement it inline using an opcode for now.
12722                                  */
12723
12724                                 if (!cfg->dyn_call_var) {
12725                                         cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12726                                         /* prevent it from being register allocated */
12727                                         cfg->dyn_call_var->flags |= MONO_INST_VOLATILE;
12728                                 }
12729
12730                                 /* Has to use a call inst since it local regalloc expects it */
12731                                 MONO_INST_NEW_CALL (cfg, call, OP_DYN_CALL);
12732                                 ins = (MonoInst*)call;
12733                                 sp -= 2;
12734                                 ins->sreg1 = sp [0]->dreg;
12735                                 ins->sreg2 = sp [1]->dreg;
12736                                 MONO_ADD_INS (cfg->cbb, ins);
12737
12738                                 cfg->param_area = MAX (cfg->param_area, cfg->backend->dyn_call_param_area);
12739
12740                                 ip += 2;
12741                                 inline_costs += 10 * num_calls++;
12742
12743                                 break;
12744                         }
12745                         case CEE_MONO_MEMORY_BARRIER: {
12746                                 CHECK_OPSIZE (6);
12747                                 emit_memory_barrier (cfg, (int)read32 (ip + 2));
12748                                 ip += 6;
12749                                 break;
12750                         }
12751                         case CEE_MONO_JIT_ATTACH: {
12752                                 MonoInst *args [16], *domain_ins;
12753                                 MonoInst *ad_ins, *jit_tls_ins;
12754                                 MonoBasicBlock *next_bb = NULL, *call_bb = NULL;
12755
12756                                 cfg->attach_cookie = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12757                                 cfg->attach_dummy = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
12758
12759                                 if (mono_threads_is_coop_enabled ()) {
12760                                         /* AOT code is only used in the root domain */
12761                                         EMIT_NEW_PCONST (cfg, args [0], cfg->compile_aot ? NULL : cfg->domain);
12762                                         EMIT_NEW_VARLOADA (cfg, args [1], cfg->attach_dummy, cfg->attach_dummy->inst_vtype);
12763                                         ins = mono_emit_jit_icall (cfg, mono_jit_thread_attach, args);
12764                                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->attach_cookie->dreg, ins->dreg);
12765                                 } else {
12766                                         EMIT_NEW_PCONST (cfg, ins, NULL);
12767                                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->attach_cookie->dreg, ins->dreg);
12768
12769                                         ad_ins = mono_get_domain_intrinsic (cfg);
12770                                         jit_tls_ins = mono_get_jit_tls_intrinsic (cfg);
12771
12772                                         if (cfg->backend->have_tls_get && ad_ins && jit_tls_ins) {
12773                                                 NEW_BBLOCK (cfg, next_bb);
12774                                                 NEW_BBLOCK (cfg, call_bb);
12775
12776                                                 if (cfg->compile_aot) {
12777                                                         /* AOT code is only used in the root domain */
12778                                                         EMIT_NEW_PCONST (cfg, domain_ins, NULL);
12779                                                 } else {
12780                                                         EMIT_NEW_PCONST (cfg, domain_ins, cfg->domain);
12781                                                 }
12782                                                 MONO_ADD_INS (cfg->cbb, ad_ins);
12783                                                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, ad_ins->dreg, domain_ins->dreg);
12784                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, call_bb);
12785
12786                                                 MONO_ADD_INS (cfg->cbb, jit_tls_ins);
12787                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, jit_tls_ins->dreg, 0);
12788                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, call_bb);
12789
12790                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, next_bb);
12791                                                 MONO_START_BB (cfg, call_bb);
12792                                         }
12793
12794                                         /* AOT code is only used in the root domain */
12795                                         EMIT_NEW_PCONST (cfg, args [0], cfg->compile_aot ? NULL : cfg->domain);
12796                                         EMIT_NEW_PCONST (cfg, args [1], NULL);
12797                                         ins = mono_emit_jit_icall (cfg, mono_jit_thread_attach, args);
12798                                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->attach_cookie->dreg, ins->dreg);
12799
12800                                         if (next_bb)
12801                                                 MONO_START_BB (cfg, next_bb);
12802                                 }
12803
12804                                 ip += 2;
12805                                 break;
12806                         }
12807                         case CEE_MONO_JIT_DETACH: {
12808                                 MonoInst *args [16];
12809
12810                                 /* Restore the original domain */
12811                                 dreg = alloc_ireg (cfg);
12812                                 EMIT_NEW_UNALU (cfg, args [0], OP_MOVE, dreg, cfg->attach_cookie->dreg);
12813                                 EMIT_NEW_VARLOADA (cfg, args [1], cfg->attach_dummy, cfg->attach_dummy->inst_vtype);
12814                                 mono_emit_jit_icall (cfg, mono_jit_thread_detach, args);
12815                                 ip += 2;
12816                                 break;
12817                         }
12818                         case CEE_MONO_CALLI_EXTRA_ARG: {
12819                                 MonoInst *addr;
12820                                 MonoMethodSignature *fsig;
12821                                 MonoInst *arg;
12822
12823                                 /*
12824                                  * This is the same as CEE_CALLI, but passes an additional argument
12825                                  * to the called method in llvmonly mode.
12826                                  * This is only used by delegate invoke wrappers to call the
12827                                  * actual delegate method.
12828                                  */
12829                                 g_assert (method->wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE);
12830
12831                                 CHECK_OPSIZE (6);
12832                                 token = read32 (ip + 2);
12833
12834                                 ins = NULL;
12835
12836                                 cmethod = NULL;
12837                                 CHECK_STACK (1);
12838                                 --sp;
12839                                 addr = *sp;
12840                                 fsig = mini_get_signature (method, token, generic_context);
12841
12842                                 if (cfg->llvm_only)
12843                                         cfg->signatures = g_slist_prepend_mempool (cfg->mempool, cfg->signatures, fsig);
12844
12845                                 n = fsig->param_count + fsig->hasthis + 1;
12846
12847                                 CHECK_STACK (n);
12848
12849                                 sp -= n;
12850                                 arg = sp [n - 1];
12851
12852                                 if (cfg->llvm_only) {
12853                                         /*
12854                                          * The lowest bit of 'arg' determines whenever the callee uses the gsharedvt
12855                                          * cconv. This is set by mono_init_delegate ().
12856                                          */
12857                                         if (cfg->gsharedvt && mini_is_gsharedvt_variable_signature (fsig)) {
12858                                                 MonoInst *callee = addr;
12859                                                 MonoInst *call, *localloc_ins;
12860                                                 MonoBasicBlock *is_gsharedvt_bb, *end_bb;
12861                                                 int low_bit_reg = alloc_preg (cfg);
12862
12863                                                 NEW_BBLOCK (cfg, is_gsharedvt_bb);
12864                                                 NEW_BBLOCK (cfg, end_bb);
12865
12866                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PAND_IMM, low_bit_reg, arg->dreg, 1);
12867                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, low_bit_reg, 0);
12868                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, is_gsharedvt_bb);
12869
12870                                                 /* Normal case: callee uses a normal cconv, have to add an out wrapper */
12871                                                 addr = emit_get_rgctx_sig (cfg, context_used,
12872                                                                                                    fsig, MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI);
12873                                                 /*
12874                                                  * ADDR points to a gsharedvt-out wrapper, have to pass <callee, arg> as an extra arg.
12875                                                  */
12876                                                 MONO_INST_NEW (cfg, ins, OP_LOCALLOC_IMM);
12877                                                 ins->dreg = alloc_preg (cfg);
12878                                                 ins->inst_imm = 2 * SIZEOF_VOID_P;
12879                                                 MONO_ADD_INS (cfg->cbb, ins);
12880                                                 localloc_ins = ins;
12881                                                 cfg->flags |= MONO_CFG_HAS_ALLOCA;
12882                                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, 0, callee->dreg);
12883                                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12884
12885                                                 call = emit_extra_arg_calli (cfg, fsig, sp, localloc_ins->dreg, addr);
12886                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
12887
12888                                                 /* Gsharedvt case: callee uses a gsharedvt cconv, no conversion is needed */
12889                                                 MONO_START_BB (cfg, is_gsharedvt_bb);
12890                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PXOR_IMM, arg->dreg, arg->dreg, 1);
12891                                                 ins = emit_extra_arg_calli (cfg, fsig, sp, arg->dreg, callee);
12892                                                 ins->dreg = call->dreg;
12893
12894                                                 MONO_START_BB (cfg, end_bb);
12895                                         } else {
12896                                                 /* Caller uses a normal calling conv */
12897
12898                                                 MonoInst *callee = addr;
12899                                                 MonoInst *call, *localloc_ins;
12900                                                 MonoBasicBlock *is_gsharedvt_bb, *end_bb;
12901                                                 int low_bit_reg = alloc_preg (cfg);
12902
12903                                                 NEW_BBLOCK (cfg, is_gsharedvt_bb);
12904                                                 NEW_BBLOCK (cfg, end_bb);
12905
12906                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PAND_IMM, low_bit_reg, arg->dreg, 1);
12907                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, low_bit_reg, 0);
12908                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, is_gsharedvt_bb);
12909
12910                                                 /* Normal case: callee uses a normal cconv, no conversion is needed */
12911                                                 call = emit_extra_arg_calli (cfg, fsig, sp, arg->dreg, callee);
12912                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
12913                                                 /* Gsharedvt case: callee uses a gsharedvt cconv, have to add an in wrapper */
12914                                                 MONO_START_BB (cfg, is_gsharedvt_bb);
12915                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PXOR_IMM, arg->dreg, arg->dreg, 1);
12916                                                 NEW_AOTCONST (cfg, addr, MONO_PATCH_INFO_GSHAREDVT_IN_WRAPPER, fsig);
12917                                                 MONO_ADD_INS (cfg->cbb, addr);
12918                                                 /*
12919                                                  * ADDR points to a gsharedvt-in wrapper, have to pass <callee, arg> as an extra arg.
12920                                                  */
12921                                                 MONO_INST_NEW (cfg, ins, OP_LOCALLOC_IMM);
12922                                                 ins->dreg = alloc_preg (cfg);
12923                                                 ins->inst_imm = 2 * SIZEOF_VOID_P;
12924                                                 MONO_ADD_INS (cfg->cbb, ins);
12925                                                 localloc_ins = ins;
12926                                                 cfg->flags |= MONO_CFG_HAS_ALLOCA;
12927                                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, 0, callee->dreg);
12928                                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, localloc_ins->dreg, SIZEOF_VOID_P, arg->dreg);
12929
12930                                                 ins = emit_extra_arg_calli (cfg, fsig, sp, localloc_ins->dreg, addr);
12931                                                 ins->dreg = call->dreg;
12932                                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
12933
12934                                                 MONO_START_BB (cfg, end_bb);
12935                                         }
12936                                 } else {
12937                                         /* Same as CEE_CALLI */
12938                                         if (cfg->gsharedvt && mini_is_gsharedvt_signature (fsig)) {
12939                                                 /*
12940                                                  * We pass the address to the gsharedvt trampoline in the rgctx reg
12941                                                  */
12942                                                 MonoInst *callee = addr;
12943
12944                                                 addr = emit_get_rgctx_sig (cfg, context_used,
12945                                                                                                    fsig, MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI);
12946                                                 ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, callee);
12947                                         } else {
12948                                                 ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr, NULL, NULL);
12949                                         }
12950                                 }
12951
12952                                 if (!MONO_TYPE_IS_VOID (fsig->ret))
12953                                         *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
12954
12955                                 CHECK_CFG_EXCEPTION;
12956
12957                                 ip += 6;
12958                                 ins_flag = 0;
12959                                 constrained_class = NULL;
12960                                 break;
12961                         }
12962                         default:
12963                                 g_error ("opcode 0x%02x 0x%02x not handled", MONO_CUSTOM_PREFIX, ip [1]);
12964                                 break;
12965                         }
12966                         break;
12967                 }
12968
12969                 case CEE_PREFIX1: {
12970                         CHECK_OPSIZE (2);
12971                         switch (ip [1]) {
12972                         case CEE_ARGLIST: {
12973                                 /* somewhat similar to LDTOKEN */
12974                                 MonoInst *addr, *vtvar;
12975                                 CHECK_STACK_OVF (1);
12976                                 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
12977
12978                                 EMIT_NEW_TEMPLOADA (cfg, addr, vtvar->inst_c0);
12979                                 EMIT_NEW_UNALU (cfg, ins, OP_ARGLIST, -1, addr->dreg);
12980
12981                                 EMIT_NEW_TEMPLOAD (cfg, ins, vtvar->inst_c0);
12982                                 ins->type = STACK_VTYPE;
12983                                 ins->klass = mono_defaults.argumenthandle_class;
12984                                 *sp++ = ins;
12985                                 ip += 2;
12986                                 break;
12987                         }
12988                         case CEE_CEQ:
12989                         case CEE_CGT:
12990                         case CEE_CGT_UN:
12991                         case CEE_CLT:
12992                         case CEE_CLT_UN: {
12993                                 MonoInst *cmp, *arg1, *arg2;
12994
12995                                 CHECK_STACK (2);
12996                                 sp -= 2;
12997                                 arg1 = sp [0];
12998                                 arg2 = sp [1];
12999
13000                                 /*
13001                                  * The following transforms:
13002                                  *    CEE_CEQ    into OP_CEQ
13003                                  *    CEE_CGT    into OP_CGT
13004                                  *    CEE_CGT_UN into OP_CGT_UN
13005                                  *    CEE_CLT    into OP_CLT
13006                                  *    CEE_CLT_UN into OP_CLT_UN
13007                                  */
13008                                 MONO_INST_NEW (cfg, cmp, (OP_CEQ - CEE_CEQ) + ip [1]);
13009
13010                                 MONO_INST_NEW (cfg, ins, cmp->opcode);
13011                                 cmp->sreg1 = arg1->dreg;
13012                                 cmp->sreg2 = arg2->dreg;
13013                                 type_from_op (cfg, cmp, arg1, arg2);
13014                                 CHECK_TYPE (cmp);
13015                                 add_widen_op (cfg, cmp, &arg1, &arg2);
13016                                 if ((arg1->type == STACK_I8) || ((SIZEOF_VOID_P == 8) && ((arg1->type == STACK_PTR) || (arg1->type == STACK_OBJ) || (arg1->type == STACK_MP))))
13017                                         cmp->opcode = OP_LCOMPARE;
13018                                 else if (arg1->type == STACK_R4)
13019                                         cmp->opcode = OP_RCOMPARE;
13020                                 else if (arg1->type == STACK_R8)
13021                                         cmp->opcode = OP_FCOMPARE;
13022                                 else
13023                                         cmp->opcode = OP_ICOMPARE;
13024                                 MONO_ADD_INS (cfg->cbb, cmp);
13025                                 ins->type = STACK_I4;
13026                                 ins->dreg = alloc_dreg (cfg, (MonoStackType)ins->type);
13027                                 type_from_op (cfg, ins, arg1, arg2);
13028
13029                                 if (cmp->opcode == OP_FCOMPARE || cmp->opcode == OP_RCOMPARE) {
13030                                         /*
13031                                          * The backends expect the fceq opcodes to do the
13032                                          * comparison too.
13033                                          */
13034                                         ins->sreg1 = cmp->sreg1;
13035                                         ins->sreg2 = cmp->sreg2;
13036                                         NULLIFY_INS (cmp);
13037                                 }
13038                                 MONO_ADD_INS (cfg->cbb, ins);
13039                                 *sp++ = ins;
13040                                 ip += 2;
13041                                 break;
13042                         }
13043                         case CEE_LDFTN: {
13044                                 MonoInst *argconst;
13045                                 MonoMethod *cil_method;
13046
13047                                 CHECK_STACK_OVF (1);
13048                                 CHECK_OPSIZE (6);
13049                                 n = read32 (ip + 2);
13050                                 cmethod = mini_get_method (cfg, method, n, NULL, generic_context);
13051                                 CHECK_CFG_ERROR;
13052
13053                                 mono_class_init (cmethod->klass);
13054
13055                                 mono_save_token_info (cfg, image, n, cmethod);
13056
13057                                 context_used = mini_method_check_context_used (cfg, cmethod);
13058
13059                                 cil_method = cmethod;
13060                                 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
13061                                         METHOD_ACCESS_FAILURE (method, cil_method);
13062
13063                                 if (mono_security_core_clr_enabled ())
13064                                         ensure_method_is_allowed_to_call_method (cfg, method, cmethod);
13065
13066                                 /*
13067                                  * Optimize the common case of ldftn+delegate creation
13068                                  */
13069                                 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
13070                                         MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13071                                         if (ctor_method && (ctor_method->klass->parent == mono_defaults.multicastdelegate_class)) {
13072                                                 MonoInst *target_ins, *handle_ins;
13073                                                 MonoMethod *invoke;
13074                                                 int invoke_context_used;
13075
13076                                                 invoke = mono_get_delegate_invoke (ctor_method->klass);
13077                                                 if (!invoke || !mono_method_signature (invoke))
13078                                                         LOAD_ERROR;
13079
13080                                                 invoke_context_used = mini_method_check_context_used (cfg, invoke);
13081
13082                                                 target_ins = sp [-1];
13083
13084                                                 if (mono_security_core_clr_enabled ())
13085                                                         ensure_method_is_allowed_to_call_method (cfg, method, ctor_method);
13086
13087                                                 if (!(cmethod->flags & METHOD_ATTRIBUTE_STATIC)) {
13088                                                         /*LAME IMPL: We must not add a null check for virtual invoke delegates.*/
13089                                                         if (mono_method_signature (invoke)->param_count == mono_method_signature (cmethod)->param_count) {
13090                                                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, target_ins->dreg, 0);
13091                                                                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "ArgumentException");
13092                                                         }
13093                                                 }
13094
13095                                                 /* FIXME: SGEN support */
13096                                                 if (invoke_context_used == 0 || cfg->llvm_only) {
13097                                                         ip += 6;
13098                                                         if (cfg->verbose_level > 3)
13099                                                                 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
13100                                                         if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, FALSE))) {
13101                                                                 sp --;
13102                                                                 *sp = handle_ins;
13103                                                                 CHECK_CFG_EXCEPTION;
13104                                                                 ip += 5;
13105                                                                 sp ++;
13106                                                                 break;
13107                                                         }
13108                                                         ip -= 6;
13109                                                 }
13110                                         }
13111                                 }
13112
13113                                 argconst = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_METHOD);
13114                                 ins = mono_emit_jit_icall (cfg, mono_ldftn, &argconst);
13115                                 *sp++ = ins;
13116
13117                                 ip += 6;
13118                                 inline_costs += 10 * num_calls++;
13119                                 break;
13120                         }
13121                         case CEE_LDVIRTFTN: {
13122                                 MonoInst *args [2];
13123
13124                                 CHECK_STACK (1);
13125                                 CHECK_OPSIZE (6);
13126                                 n = read32 (ip + 2);
13127                                 cmethod = mini_get_method (cfg, method, n, NULL, generic_context);
13128                                 CHECK_CFG_ERROR;
13129
13130                                 mono_class_init (cmethod->klass);
13131
13132                                 context_used = mini_method_check_context_used (cfg, cmethod);
13133
13134                                 if (mono_security_core_clr_enabled ())
13135                                         ensure_method_is_allowed_to_call_method (cfg, method, cmethod);
13136
13137                                 /*
13138                                  * Optimize the common case of ldvirtftn+delegate creation
13139                                  */
13140                                 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, cfg->cbb, ip + 6) && (ip [6] == CEE_NEWOBJ) && (ip > header->code && ip [-1] == CEE_DUP)) {
13141                                         MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
13142                                         if (ctor_method && (ctor_method->klass->parent == mono_defaults.multicastdelegate_class)) {
13143                                                 MonoInst *target_ins, *handle_ins;
13144                                                 MonoMethod *invoke;
13145                                                 int invoke_context_used;
13146                                                 gboolean is_virtual = cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL;
13147
13148                                                 invoke = mono_get_delegate_invoke (ctor_method->klass);
13149                                                 if (!invoke || !mono_method_signature (invoke))
13150                                                         LOAD_ERROR;
13151
13152                                                 invoke_context_used = mini_method_check_context_used (cfg, invoke);
13153
13154                                                 target_ins = sp [-1];
13155
13156                                                 if (mono_security_core_clr_enabled ())
13157                                                         ensure_method_is_allowed_to_call_method (cfg, method, ctor_method);
13158
13159                                                 /* FIXME: SGEN support */
13160                                                 if (invoke_context_used == 0 || cfg->llvm_only) {
13161                                                         ip += 6;
13162                                                         if (cfg->verbose_level > 3)
13163                                                                 g_print ("converting (in B%d: stack: %d) %s", cfg->cbb->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
13164                                                         if ((handle_ins = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used, is_virtual))) {
13165                                                                 sp -= 2;
13166                                                                 *sp = handle_ins;
13167                                                                 CHECK_CFG_EXCEPTION;
13168                                                                 ip += 5;
13169                                                                 sp ++;
13170                                                                 break;
13171                                                         }
13172                                                         ip -= 6;
13173                                                 }
13174                                         }
13175                                 }
13176
13177                                 --sp;
13178                                 args [0] = *sp;
13179
13180                                 args [1] = emit_get_rgctx_method (cfg, context_used,
13181                                                                                                   cmethod, MONO_RGCTX_INFO_METHOD);
13182
13183                                 if (context_used)
13184                                         *sp++ = mono_emit_jit_icall (cfg, mono_ldvirtfn_gshared, args);
13185                                 else
13186                                         *sp++ = mono_emit_jit_icall (cfg, mono_ldvirtfn, args);
13187
13188                                 ip += 6;
13189                                 inline_costs += 10 * num_calls++;
13190                                 break;
13191                         }
13192                         case CEE_LDARG:
13193                                 CHECK_STACK_OVF (1);
13194                                 CHECK_OPSIZE (4);
13195                                 n = read16 (ip + 2);
13196                                 CHECK_ARG (n);
13197                                 EMIT_NEW_ARGLOAD (cfg, ins, n);
13198                                 *sp++ = ins;
13199                                 ip += 4;
13200                                 break;
13201                         case CEE_LDARGA:
13202                                 CHECK_STACK_OVF (1);
13203                                 CHECK_OPSIZE (4);
13204                                 n = read16 (ip + 2);
13205                                 CHECK_ARG (n);
13206                                 NEW_ARGLOADA (cfg, ins, n);
13207                                 MONO_ADD_INS (cfg->cbb, ins);
13208                                 *sp++ = ins;
13209                                 ip += 4;
13210                                 break;
13211                         case CEE_STARG:
13212                                 CHECK_STACK (1);
13213                                 --sp;
13214                                 CHECK_OPSIZE (4);
13215                                 n = read16 (ip + 2);
13216                                 CHECK_ARG (n);
13217                                 if (!dont_verify_stloc && target_type_is_incompatible (cfg, param_types [n], *sp))
13218                                         UNVERIFIED;
13219                                 EMIT_NEW_ARGSTORE (cfg, ins, n, *sp);
13220                                 ip += 4;
13221                                 break;
13222                         case CEE_LDLOC:
13223                                 CHECK_STACK_OVF (1);
13224                                 CHECK_OPSIZE (4);
13225                                 n = read16 (ip + 2);
13226                                 CHECK_LOCAL (n);
13227                                 EMIT_NEW_LOCLOAD (cfg, ins, n);
13228                                 *sp++ = ins;
13229                                 ip += 4;
13230                                 break;
13231                         case CEE_LDLOCA: {
13232                                 unsigned char *tmp_ip;
13233                                 CHECK_STACK_OVF (1);
13234                                 CHECK_OPSIZE (4);
13235                                 n = read16 (ip + 2);
13236                                 CHECK_LOCAL (n);
13237
13238                                 if ((tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 2))) {
13239                                         ip = tmp_ip;
13240                                         inline_costs += 1;
13241                                         break;
13242                                 }
13243
13244                                 EMIT_NEW_LOCLOADA (cfg, ins, n);
13245                                 *sp++ = ins;
13246                                 ip += 4;
13247                                 break;
13248                         }
13249                         case CEE_STLOC:
13250                                 CHECK_STACK (1);
13251                                 --sp;
13252                                 CHECK_OPSIZE (4);
13253                                 n = read16 (ip + 2);
13254                                 CHECK_LOCAL (n);
13255                                 if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [n], *sp))
13256                                         UNVERIFIED;
13257                                 emit_stloc_ir (cfg, sp, header, n);
13258                                 ip += 4;
13259                                 inline_costs += 1;
13260                                 break;
13261                         case CEE_LOCALLOC:
13262                                 CHECK_STACK (1);
13263                                 --sp;
13264                                 if (sp != stack_start)
13265                                         UNVERIFIED;
13266                                 if (cfg->method != method)
13267                                         /*
13268                                          * Inlining this into a loop in a parent could lead to
13269                                          * stack overflows which is different behavior than the
13270                                          * non-inlined case, thus disable inlining in this case.
13271                                          */
13272                                         INLINE_FAILURE("localloc");
13273
13274                                 MONO_INST_NEW (cfg, ins, OP_LOCALLOC);
13275                                 ins->dreg = alloc_preg (cfg);
13276                                 ins->sreg1 = sp [0]->dreg;
13277                                 ins->type = STACK_PTR;
13278                                 MONO_ADD_INS (cfg->cbb, ins);
13279
13280                                 cfg->flags |= MONO_CFG_HAS_ALLOCA;
13281                                 if (init_locals)
13282                                         ins->flags |= MONO_INST_INIT;
13283
13284                                 *sp++ = ins;
13285                                 ip += 2;
13286                                 break;
13287                         case CEE_ENDFILTER: {
13288                                 MonoExceptionClause *clause, *nearest;
13289                                 int cc;
13290
13291                                 CHECK_STACK (1);
13292                                 --sp;
13293                                 if ((sp != stack_start) || (sp [0]->type != STACK_I4))
13294                                         UNVERIFIED;
13295                                 MONO_INST_NEW (cfg, ins, OP_ENDFILTER);
13296                                 ins->sreg1 = (*sp)->dreg;
13297                                 MONO_ADD_INS (cfg->cbb, ins);
13298                                 start_new_bblock = 1;
13299                                 ip += 2;
13300
13301                                 nearest = NULL;
13302                                 for (cc = 0; cc < header->num_clauses; ++cc) {
13303                                         clause = &header->clauses [cc];
13304                                         if ((clause->flags & MONO_EXCEPTION_CLAUSE_FILTER) &&
13305                                                 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
13306                                             (!nearest || (clause->data.filter_offset < nearest->data.filter_offset)))
13307                                                 nearest = clause;
13308                                 }
13309                                 g_assert (nearest);
13310                                 if ((ip - header->code) != nearest->handler_offset)
13311                                         UNVERIFIED;
13312
13313                                 break;
13314                         }
13315                         case CEE_UNALIGNED_:
13316                                 ins_flag |= MONO_INST_UNALIGNED;
13317                                 /* FIXME: record alignment? we can assume 1 for now */
13318                                 CHECK_OPSIZE (3);
13319                                 ip += 3;
13320                                 break;
13321                         case CEE_VOLATILE_:
13322                                 ins_flag |= MONO_INST_VOLATILE;
13323                                 ip += 2;
13324                                 break;
13325                         case CEE_TAIL_:
13326                                 ins_flag   |= MONO_INST_TAILCALL;
13327                                 cfg->flags |= MONO_CFG_HAS_TAIL;
13328                                 /* Can't inline tail calls at this time */
13329                                 inline_costs += 100000;
13330                                 ip += 2;
13331                                 break;
13332                         case CEE_INITOBJ:
13333                                 CHECK_STACK (1);
13334                                 --sp;
13335                                 CHECK_OPSIZE (6);
13336                                 token = read32 (ip + 2);
13337                                 klass = mini_get_class (method, token, generic_context);
13338                                 CHECK_TYPELOAD (klass);
13339                                 if (generic_class_is_reference_type (cfg, klass))
13340                                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, sp [0]->dreg, 0, 0);
13341                                 else
13342                                         mini_emit_initobj (cfg, *sp, NULL, klass);
13343                                 ip += 6;
13344                                 inline_costs += 1;
13345                                 break;
13346                         case CEE_CONSTRAINED_:
13347                                 CHECK_OPSIZE (6);
13348                                 token = read32 (ip + 2);
13349                                 constrained_class = mini_get_class (method, token, generic_context);
13350                                 CHECK_TYPELOAD (constrained_class);
13351                                 ip += 6;
13352                                 break;
13353                         case CEE_CPBLK:
13354                         case CEE_INITBLK: {
13355                                 MonoInst *iargs [3];
13356                                 CHECK_STACK (3);
13357                                 sp -= 3;
13358
13359                                 /* Skip optimized paths for volatile operations. */
13360                                 if ((ip [1] == CEE_CPBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
13361                                         mini_emit_memcpy (cfg, sp [0]->dreg, 0, sp [1]->dreg, 0, sp [2]->inst_c0, 0);
13362                                 } else if ((ip [1] == CEE_INITBLK) && !(ins_flag & MONO_INST_VOLATILE) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5) && (sp [1]->opcode == OP_ICONST) && (sp [1]->inst_c0 == 0)) {
13363                                         /* emit_memset only works when val == 0 */
13364                                         mini_emit_memset (cfg, sp [0]->dreg, 0, sp [2]->inst_c0, sp [1]->inst_c0, 0);
13365                                 } else {
13366                                         MonoInst *call;
13367                                         iargs [0] = sp [0];
13368                                         iargs [1] = sp [1];
13369                                         iargs [2] = sp [2];
13370                                         if (ip [1] == CEE_CPBLK) {
13371                                                 /*
13372                                                  * FIXME: It's unclear whether we should be emitting both the acquire
13373                                                  * and release barriers for cpblk. It is technically both a load and
13374                                                  * store operation, so it seems like that's the sensible thing to do.
13375                                                  *
13376                                                  * FIXME: We emit full barriers on both sides of the operation for
13377                                                  * simplicity. We should have a separate atomic memcpy method instead.
13378                                                  */
13379                                                 MonoMethod *memcpy_method = get_memcpy_method ();
13380
13381                                                 if (ins_flag & MONO_INST_VOLATILE)
13382                                                         emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
13383
13384                                                 call = mono_emit_method_call (cfg, memcpy_method, iargs, NULL);
13385                                                 call->flags |= ins_flag;
13386
13387                                                 if (ins_flag & MONO_INST_VOLATILE)
13388                                                         emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ);
13389                                         } else {
13390                                                 MonoMethod *memset_method = get_memset_method ();
13391                                                 if (ins_flag & MONO_INST_VOLATILE) {
13392                                                         /* Volatile stores have release semantics, see 12.6.7 in Ecma 335 */
13393                                                         emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_REL);
13394                                                 }
13395                                                 call = mono_emit_method_call (cfg, memset_method, iargs, NULL);
13396                                                 call->flags |= ins_flag;
13397                                         }
13398                                 }
13399                                 ip += 2;
13400                                 ins_flag = 0;
13401                                 inline_costs += 1;
13402                                 break;
13403                         }
13404                         case CEE_NO_:
13405                                 CHECK_OPSIZE (3);
13406                                 if (ip [2] & 0x1)
13407                                         ins_flag |= MONO_INST_NOTYPECHECK;
13408                                 if (ip [2] & 0x2)
13409                                         ins_flag |= MONO_INST_NORANGECHECK;
13410                                 /* we ignore the no-nullcheck for now since we
13411                                  * really do it explicitly only when doing callvirt->call
13412                                  */
13413                                 ip += 3;
13414                                 break;
13415                         case CEE_RETHROW: {
13416                                 MonoInst *load;
13417                                 int handler_offset = -1;
13418
13419                                 for (i = 0; i < header->num_clauses; ++i) {
13420                                         MonoExceptionClause *clause = &header->clauses [i];
13421                                         if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
13422                                                 handler_offset = clause->handler_offset;
13423                                                 break;
13424                                         }
13425                                 }
13426
13427                                 cfg->cbb->flags |= BB_EXCEPTION_UNSAFE;
13428
13429                                 if (handler_offset == -1)
13430                                         UNVERIFIED;
13431
13432                                 EMIT_NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, handler_offset)->inst_c0);
13433                                 MONO_INST_NEW (cfg, ins, OP_RETHROW);
13434                                 ins->sreg1 = load->dreg;
13435                                 MONO_ADD_INS (cfg->cbb, ins);
13436
13437                                 MONO_INST_NEW (cfg, ins, OP_NOT_REACHED);
13438                                 MONO_ADD_INS (cfg->cbb, ins);
13439
13440                                 sp = stack_start;
13441                                 link_bblock (cfg, cfg->cbb, end_bblock);
13442                                 start_new_bblock = 1;
13443                                 ip += 2;
13444                                 break;
13445                         }
13446                         case CEE_SIZEOF: {
13447                                 guint32 val;
13448                                 int ialign;
13449
13450                                 CHECK_STACK_OVF (1);
13451                                 CHECK_OPSIZE (6);
13452                                 token = read32 (ip + 2);
13453                                 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !image_is_dynamic (method->klass->image) && !generic_context) {
13454                                         MonoType *type = mono_type_create_from_typespec_checked (image, token, &cfg->error);
13455                                         CHECK_CFG_ERROR;
13456
13457                                         val = mono_type_size (type, &ialign);
13458                                 } else {
13459                                         MonoClass *klass = mini_get_class (method, token, generic_context);
13460                                         CHECK_TYPELOAD (klass);
13461
13462                                         val = mono_type_size (&klass->byval_arg, &ialign);
13463
13464                                         if (mini_is_gsharedvt_klass (klass))
13465                                                 GSHAREDVT_FAILURE (*ip);
13466                                 }
13467                                 EMIT_NEW_ICONST (cfg, ins, val);
13468                                 *sp++= ins;
13469                                 ip += 6;
13470                                 break;
13471                         }
13472                         case CEE_REFANYTYPE: {
13473                                 MonoInst *src_var, *src;
13474
13475                                 GSHAREDVT_FAILURE (*ip);
13476
13477                                 CHECK_STACK (1);
13478                                 --sp;
13479
13480                                 // FIXME:
13481                                 src_var = get_vreg_to_inst (cfg, sp [0]->dreg);
13482                                 if (!src_var)
13483                                         src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
13484                                 EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype);
13485                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, MONO_STRUCT_OFFSET (MonoTypedRef, type));
13486                                 *sp++ = ins;
13487                                 ip += 2;
13488                                 break;
13489                         }
13490                         case CEE_READONLY_:
13491                                 readonly = TRUE;
13492                                 ip += 2;
13493                                 break;
13494
13495                         case CEE_UNUSED56:
13496                         case CEE_UNUSED57:
13497                         case CEE_UNUSED70:
13498                         case CEE_UNUSED:
13499                         case CEE_UNUSED99:
13500                                 UNVERIFIED;
13501
13502                         default:
13503                                 g_warning ("opcode 0xfe 0x%02x not handled", ip [1]);
13504                                 UNVERIFIED;
13505                         }
13506                         break;
13507                 }
13508                 case CEE_UNUSED58:
13509                 case CEE_UNUSED1:
13510                         UNVERIFIED;
13511
13512                 default:
13513                         g_warning ("opcode 0x%02x not handled", *ip);
13514                         UNVERIFIED;
13515                 }
13516         }
13517         if (start_new_bblock != 1)
13518                 UNVERIFIED;
13519
13520         cfg->cbb->cil_length = ip - cfg->cbb->cil_code;
13521         if (cfg->cbb->next_bb) {
13522                 /* This could already be set because of inlining, #693905 */
13523                 MonoBasicBlock *bb = cfg->cbb;
13524
13525                 while (bb->next_bb)
13526                         bb = bb->next_bb;
13527                 bb->next_bb = end_bblock;
13528         } else {
13529                 cfg->cbb->next_bb = end_bblock;
13530         }
13531
13532         if (cfg->method == method && cfg->domainvar) {
13533                 MonoInst *store;
13534                 MonoInst *get_domain;
13535
13536                 cfg->cbb = init_localsbb;
13537
13538                 if ((get_domain = mono_get_domain_intrinsic (cfg))) {
13539                         MONO_ADD_INS (cfg->cbb, get_domain);
13540                 } else {
13541                         get_domain = mono_emit_jit_icall (cfg, mono_domain_get, NULL);
13542                 }
13543                 NEW_TEMPSTORE (cfg, store, cfg->domainvar->inst_c0, get_domain);
13544                 MONO_ADD_INS (cfg->cbb, store);
13545         }
13546
13547 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
13548         if (cfg->compile_aot)
13549                 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
13550                 mono_get_got_var (cfg);
13551 #endif
13552
13553         if (cfg->method == method && cfg->got_var)
13554                 mono_emit_load_got_addr (cfg);
13555
13556         if (init_localsbb) {
13557                 cfg->cbb = init_localsbb;
13558                 cfg->ip = NULL;
13559                 for (i = 0; i < header->num_locals; ++i) {
13560                         emit_init_local (cfg, i, header->locals [i], init_locals);
13561                 }
13562         }
13563
13564         if (cfg->init_ref_vars && cfg->method == method) {
13565                 /* Emit initialization for ref vars */
13566                 // FIXME: Avoid duplication initialization for IL locals.
13567                 for (i = 0; i < cfg->num_varinfo; ++i) {
13568                         MonoInst *ins = cfg->varinfo [i];
13569
13570                         if (ins->opcode == OP_LOCAL && ins->type == STACK_OBJ)
13571                                 MONO_EMIT_NEW_PCONST (cfg, ins->dreg, NULL);
13572                 }
13573         }
13574
13575         if (cfg->lmf_var && cfg->method == method && !cfg->llvm_only) {
13576                 cfg->cbb = init_localsbb;
13577                 emit_push_lmf (cfg);
13578         }
13579
13580         cfg->cbb = init_localsbb;
13581         emit_instrumentation_call (cfg, mono_profiler_method_enter);
13582
13583         if (seq_points) {
13584                 MonoBasicBlock *bb;
13585
13586                 /*
13587                  * Make seq points at backward branch targets interruptable.
13588                  */
13589                 for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
13590                         if (bb->code && bb->in_count > 1 && bb->code->opcode == OP_SEQ_POINT)
13591                                 bb->code->flags |= MONO_INST_SINGLE_STEP_LOC;
13592         }
13593
13594         /* Add a sequence point for method entry/exit events */
13595         if (seq_points && cfg->gen_sdb_seq_points) {
13596                 NEW_SEQ_POINT (cfg, ins, METHOD_ENTRY_IL_OFFSET, FALSE);
13597                 MONO_ADD_INS (init_localsbb, ins);
13598                 NEW_SEQ_POINT (cfg, ins, METHOD_EXIT_IL_OFFSET, FALSE);
13599                 MONO_ADD_INS (cfg->bb_exit, ins);
13600         }
13601
13602         /*
13603          * Add seq points for IL offsets which have line number info, but wasn't generated a seq point during JITting because
13604          * the code they refer to was dead (#11880).
13605          */
13606         if (sym_seq_points) {
13607                 for (i = 0; i < header->code_size; ++i) {
13608                         if (mono_bitset_test_fast (seq_point_locs, i) && !mono_bitset_test_fast (seq_point_set_locs, i)) {
13609                                 MonoInst *ins;
13610
13611                                 NEW_SEQ_POINT (cfg, ins, i, FALSE);
13612                                 mono_add_seq_point (cfg, NULL, ins, SEQ_POINT_NATIVE_OFFSET_DEAD_CODE);
13613                         }
13614                 }
13615         }
13616
13617         cfg->ip = NULL;
13618
13619         if (cfg->method == method) {
13620                 MonoBasicBlock *bb;
13621                 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
13622                         bb->region = mono_find_block_region (cfg, bb->real_offset);
13623                         if (cfg->spvars)
13624                                 mono_create_spvar_for_region (cfg, bb->region);
13625                         if (cfg->verbose_level > 2)
13626                                 printf ("REGION BB%d IL_%04x ID_%08X\n", bb->block_num, bb->real_offset, bb->region);
13627                 }
13628         }
13629
13630         if (inline_costs < 0) {
13631                 char *mname;
13632
13633                 /* Method is too large */
13634                 mname = mono_method_full_name (method, TRUE);
13635                 mono_cfg_set_exception_invalid_program (cfg, g_strdup_printf ("Method %s is too complex.", mname));
13636                 g_free (mname);
13637         }
13638
13639         if ((cfg->verbose_level > 2) && (cfg->method == method))
13640                 mono_print_code (cfg, "AFTER METHOD-TO-IR");
13641
13642         goto cleanup;
13643
13644 mono_error_exit:
13645         g_assert (!mono_error_ok (&cfg->error));
13646         goto cleanup;
13647
13648  exception_exit:
13649         g_assert (cfg->exception_type != MONO_EXCEPTION_NONE);
13650         goto cleanup;
13651
13652  unverified:
13653         set_exception_type_from_invalid_il (cfg, method, ip);
13654         goto cleanup;
13655
13656  cleanup:
13657         g_slist_free (class_inits);
13658         mono_basic_block_free (original_bb);
13659         cfg->dont_inline = g_list_remove (cfg->dont_inline, method);
13660         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
13661         if (cfg->exception_type)
13662                 return -1;
13663         else
13664                 return inline_costs;
13665 }
13666
13667 static int
13668 store_membase_reg_to_store_membase_imm (int opcode)
13669 {
13670         switch (opcode) {
13671         case OP_STORE_MEMBASE_REG:
13672                 return OP_STORE_MEMBASE_IMM;
13673         case OP_STOREI1_MEMBASE_REG:
13674                 return OP_STOREI1_MEMBASE_IMM;
13675         case OP_STOREI2_MEMBASE_REG:
13676                 return OP_STOREI2_MEMBASE_IMM;
13677         case OP_STOREI4_MEMBASE_REG:
13678                 return OP_STOREI4_MEMBASE_IMM;
13679         case OP_STOREI8_MEMBASE_REG:
13680                 return OP_STOREI8_MEMBASE_IMM;
13681         default:
13682                 g_assert_not_reached ();
13683         }
13684
13685         return -1;
13686 }
13687
13688 int
13689 mono_op_to_op_imm (int opcode)
13690 {
13691         switch (opcode) {
13692         case OP_IADD:
13693                 return OP_IADD_IMM;
13694         case OP_ISUB:
13695                 return OP_ISUB_IMM;
13696         case OP_IDIV:
13697                 return OP_IDIV_IMM;
13698         case OP_IDIV_UN:
13699                 return OP_IDIV_UN_IMM;
13700         case OP_IREM:
13701                 return OP_IREM_IMM;
13702         case OP_IREM_UN:
13703                 return OP_IREM_UN_IMM;
13704         case OP_IMUL:
13705                 return OP_IMUL_IMM;
13706         case OP_IAND:
13707                 return OP_IAND_IMM;
13708         case OP_IOR:
13709                 return OP_IOR_IMM;
13710         case OP_IXOR:
13711                 return OP_IXOR_IMM;
13712         case OP_ISHL:
13713                 return OP_ISHL_IMM;
13714         case OP_ISHR:
13715                 return OP_ISHR_IMM;
13716         case OP_ISHR_UN:
13717                 return OP_ISHR_UN_IMM;
13718
13719         case OP_LADD:
13720                 return OP_LADD_IMM;
13721         case OP_LSUB:
13722                 return OP_LSUB_IMM;
13723         case OP_LAND:
13724                 return OP_LAND_IMM;
13725         case OP_LOR:
13726                 return OP_LOR_IMM;
13727         case OP_LXOR:
13728                 return OP_LXOR_IMM;
13729         case OP_LSHL:
13730                 return OP_LSHL_IMM;
13731         case OP_LSHR:
13732                 return OP_LSHR_IMM;
13733         case OP_LSHR_UN:
13734                 return OP_LSHR_UN_IMM;
13735 #if SIZEOF_REGISTER == 8
13736         case OP_LREM:
13737                 return OP_LREM_IMM;
13738 #endif
13739
13740         case OP_COMPARE:
13741                 return OP_COMPARE_IMM;
13742         case OP_ICOMPARE:
13743                 return OP_ICOMPARE_IMM;
13744         case OP_LCOMPARE:
13745                 return OP_LCOMPARE_IMM;
13746
13747         case OP_STORE_MEMBASE_REG:
13748                 return OP_STORE_MEMBASE_IMM;
13749         case OP_STOREI1_MEMBASE_REG:
13750                 return OP_STOREI1_MEMBASE_IMM;
13751         case OP_STOREI2_MEMBASE_REG:
13752                 return OP_STOREI2_MEMBASE_IMM;
13753         case OP_STOREI4_MEMBASE_REG:
13754                 return OP_STOREI4_MEMBASE_IMM;
13755
13756 #if defined(TARGET_X86) || defined (TARGET_AMD64)
13757         case OP_X86_PUSH:
13758                 return OP_X86_PUSH_IMM;
13759         case OP_X86_COMPARE_MEMBASE_REG:
13760                 return OP_X86_COMPARE_MEMBASE_IMM;
13761 #endif
13762 #if defined(TARGET_AMD64)
13763         case OP_AMD64_ICOMPARE_MEMBASE_REG:
13764                 return OP_AMD64_ICOMPARE_MEMBASE_IMM;
13765 #endif
13766         case OP_VOIDCALL_REG:
13767                 return OP_VOIDCALL;
13768         case OP_CALL_REG:
13769                 return OP_CALL;
13770         case OP_LCALL_REG:
13771                 return OP_LCALL;
13772         case OP_FCALL_REG:
13773                 return OP_FCALL;
13774         case OP_LOCALLOC:
13775                 return OP_LOCALLOC_IMM;
13776         }
13777
13778         return -1;
13779 }
13780
13781 static int
13782 ldind_to_load_membase (int opcode)
13783 {
13784         switch (opcode) {
13785         case CEE_LDIND_I1:
13786                 return OP_LOADI1_MEMBASE;
13787         case CEE_LDIND_U1:
13788                 return OP_LOADU1_MEMBASE;
13789         case CEE_LDIND_I2:
13790                 return OP_LOADI2_MEMBASE;
13791         case CEE_LDIND_U2:
13792                 return OP_LOADU2_MEMBASE;
13793         case CEE_LDIND_I4:
13794                 return OP_LOADI4_MEMBASE;
13795         case CEE_LDIND_U4:
13796                 return OP_LOADU4_MEMBASE;
13797         case CEE_LDIND_I:
13798                 return OP_LOAD_MEMBASE;
13799         case CEE_LDIND_REF:
13800                 return OP_LOAD_MEMBASE;
13801         case CEE_LDIND_I8:
13802                 return OP_LOADI8_MEMBASE;
13803         case CEE_LDIND_R4:
13804                 return OP_LOADR4_MEMBASE;
13805         case CEE_LDIND_R8:
13806                 return OP_LOADR8_MEMBASE;
13807         default:
13808                 g_assert_not_reached ();
13809         }
13810
13811         return -1;
13812 }
13813
13814 static int
13815 stind_to_store_membase (int opcode)
13816 {
13817         switch (opcode) {
13818         case CEE_STIND_I1:
13819                 return OP_STOREI1_MEMBASE_REG;
13820         case CEE_STIND_I2:
13821                 return OP_STOREI2_MEMBASE_REG;
13822         case CEE_STIND_I4:
13823                 return OP_STOREI4_MEMBASE_REG;
13824         case CEE_STIND_I:
13825         case CEE_STIND_REF:
13826                 return OP_STORE_MEMBASE_REG;
13827         case CEE_STIND_I8:
13828                 return OP_STOREI8_MEMBASE_REG;
13829         case CEE_STIND_R4:
13830                 return OP_STORER4_MEMBASE_REG;
13831         case CEE_STIND_R8:
13832                 return OP_STORER8_MEMBASE_REG;
13833         default:
13834                 g_assert_not_reached ();
13835         }
13836
13837         return -1;
13838 }
13839
13840 int
13841 mono_load_membase_to_load_mem (int opcode)
13842 {
13843         // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
13844 #if defined(TARGET_X86) || defined(TARGET_AMD64)
13845         switch (opcode) {
13846         case OP_LOAD_MEMBASE:
13847                 return OP_LOAD_MEM;
13848         case OP_LOADU1_MEMBASE:
13849                 return OP_LOADU1_MEM;
13850         case OP_LOADU2_MEMBASE:
13851                 return OP_LOADU2_MEM;
13852         case OP_LOADI4_MEMBASE:
13853                 return OP_LOADI4_MEM;
13854         case OP_LOADU4_MEMBASE:
13855                 return OP_LOADU4_MEM;
13856 #if SIZEOF_REGISTER == 8
13857         case OP_LOADI8_MEMBASE:
13858                 return OP_LOADI8_MEM;
13859 #endif
13860         }
13861 #endif
13862
13863         return -1;
13864 }
13865
13866 static inline int
13867 op_to_op_dest_membase (int store_opcode, int opcode)
13868 {
13869 #if defined(TARGET_X86)
13870         if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG)))
13871                 return -1;
13872
13873         switch (opcode) {
13874         case OP_IADD:
13875                 return OP_X86_ADD_MEMBASE_REG;
13876         case OP_ISUB:
13877                 return OP_X86_SUB_MEMBASE_REG;
13878         case OP_IAND:
13879                 return OP_X86_AND_MEMBASE_REG;
13880         case OP_IOR:
13881                 return OP_X86_OR_MEMBASE_REG;
13882         case OP_IXOR:
13883                 return OP_X86_XOR_MEMBASE_REG;
13884         case OP_ADD_IMM:
13885         case OP_IADD_IMM:
13886                 return OP_X86_ADD_MEMBASE_IMM;
13887         case OP_SUB_IMM:
13888         case OP_ISUB_IMM:
13889                 return OP_X86_SUB_MEMBASE_IMM;
13890         case OP_AND_IMM:
13891         case OP_IAND_IMM:
13892                 return OP_X86_AND_MEMBASE_IMM;
13893         case OP_OR_IMM:
13894         case OP_IOR_IMM:
13895                 return OP_X86_OR_MEMBASE_IMM;
13896         case OP_XOR_IMM:
13897         case OP_IXOR_IMM:
13898                 return OP_X86_XOR_MEMBASE_IMM;
13899         case OP_MOVE:
13900                 return OP_NOP;
13901         }
13902 #endif
13903
13904 #if defined(TARGET_AMD64)
13905         if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
13906                 return -1;
13907
13908         switch (opcode) {
13909         case OP_IADD:
13910                 return OP_X86_ADD_MEMBASE_REG;
13911         case OP_ISUB:
13912                 return OP_X86_SUB_MEMBASE_REG;
13913         case OP_IAND:
13914                 return OP_X86_AND_MEMBASE_REG;
13915         case OP_IOR:
13916                 return OP_X86_OR_MEMBASE_REG;
13917         case OP_IXOR:
13918                 return OP_X86_XOR_MEMBASE_REG;
13919         case OP_IADD_IMM:
13920                 return OP_X86_ADD_MEMBASE_IMM;
13921         case OP_ISUB_IMM:
13922                 return OP_X86_SUB_MEMBASE_IMM;
13923         case OP_IAND_IMM:
13924                 return OP_X86_AND_MEMBASE_IMM;
13925         case OP_IOR_IMM:
13926                 return OP_X86_OR_MEMBASE_IMM;
13927         case OP_IXOR_IMM:
13928                 return OP_X86_XOR_MEMBASE_IMM;
13929         case OP_LADD:
13930                 return OP_AMD64_ADD_MEMBASE_REG;
13931         case OP_LSUB:
13932                 return OP_AMD64_SUB_MEMBASE_REG;
13933         case OP_LAND:
13934                 return OP_AMD64_AND_MEMBASE_REG;
13935         case OP_LOR:
13936                 return OP_AMD64_OR_MEMBASE_REG;
13937         case OP_LXOR:
13938                 return OP_AMD64_XOR_MEMBASE_REG;
13939         case OP_ADD_IMM:
13940         case OP_LADD_IMM:
13941                 return OP_AMD64_ADD_MEMBASE_IMM;
13942         case OP_SUB_IMM:
13943         case OP_LSUB_IMM:
13944                 return OP_AMD64_SUB_MEMBASE_IMM;
13945         case OP_AND_IMM:
13946         case OP_LAND_IMM:
13947                 return OP_AMD64_AND_MEMBASE_IMM;
13948         case OP_OR_IMM:
13949         case OP_LOR_IMM:
13950                 return OP_AMD64_OR_MEMBASE_IMM;
13951         case OP_XOR_IMM:
13952         case OP_LXOR_IMM:
13953                 return OP_AMD64_XOR_MEMBASE_IMM;
13954         case OP_MOVE:
13955                 return OP_NOP;
13956         }
13957 #endif
13958
13959         return -1;
13960 }
13961
13962 static inline int
13963 op_to_op_store_membase (int store_opcode, int opcode)
13964 {
13965 #if defined(TARGET_X86) || defined(TARGET_AMD64)
13966         switch (opcode) {
13967         case OP_ICEQ:
13968                 if (store_opcode == OP_STOREI1_MEMBASE_REG)
13969                         return OP_X86_SETEQ_MEMBASE;
13970         case OP_CNE:
13971                 if (store_opcode == OP_STOREI1_MEMBASE_REG)
13972                         return OP_X86_SETNE_MEMBASE;
13973         }
13974 #endif
13975
13976         return -1;
13977 }
13978
13979 static inline int
13980 op_to_op_src1_membase (MonoCompile *cfg, int load_opcode, int opcode)
13981 {
13982 #ifdef TARGET_X86
13983         /* FIXME: This has sign extension issues */
13984         /*
13985         if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
13986                 return OP_X86_COMPARE_MEMBASE8_IMM;
13987         */
13988
13989         if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
13990                 return -1;
13991
13992         switch (opcode) {
13993         case OP_X86_PUSH:
13994                 return OP_X86_PUSH_MEMBASE;
13995         case OP_COMPARE_IMM:
13996         case OP_ICOMPARE_IMM:
13997                 return OP_X86_COMPARE_MEMBASE_IMM;
13998         case OP_COMPARE:
13999         case OP_ICOMPARE:
14000                 return OP_X86_COMPARE_MEMBASE_REG;
14001         }
14002 #endif
14003
14004 #ifdef TARGET_AMD64
14005         /* FIXME: This has sign extension issues */
14006         /*
14007         if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
14008                 return OP_X86_COMPARE_MEMBASE8_IMM;
14009         */
14010
14011         switch (opcode) {
14012         case OP_X86_PUSH:
14013                 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14014                         return OP_X86_PUSH_MEMBASE;
14015                 break;
14016                 /* FIXME: This only works for 32 bit immediates
14017         case OP_COMPARE_IMM:
14018         case OP_LCOMPARE_IMM:
14019                 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
14020                         return OP_AMD64_COMPARE_MEMBASE_IMM;
14021                 */
14022         case OP_ICOMPARE_IMM:
14023                 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE))
14024                         return OP_AMD64_ICOMPARE_MEMBASE_IMM;
14025                 break;
14026         case OP_COMPARE:
14027         case OP_LCOMPARE:
14028                 if (cfg->backend->ilp32 && load_opcode == OP_LOAD_MEMBASE)
14029                         return OP_AMD64_ICOMPARE_MEMBASE_REG;
14030                 if ((load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32) || (load_opcode == OP_LOADI8_MEMBASE))
14031                         return OP_AMD64_COMPARE_MEMBASE_REG;
14032                 break;
14033         case OP_ICOMPARE:
14034                 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE))
14035                         return OP_AMD64_ICOMPARE_MEMBASE_REG;
14036                 break;
14037         }
14038 #endif
14039
14040         return -1;
14041 }
14042
14043 static inline int
14044 op_to_op_src2_membase (MonoCompile *cfg, int load_opcode, int opcode)
14045 {
14046 #ifdef TARGET_X86
14047         if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
14048                 return -1;
14049
14050         switch (opcode) {
14051         case OP_COMPARE:
14052         case OP_ICOMPARE:
14053                 return OP_X86_COMPARE_REG_MEMBASE;
14054         case OP_IADD:
14055                 return OP_X86_ADD_REG_MEMBASE;
14056         case OP_ISUB:
14057                 return OP_X86_SUB_REG_MEMBASE;
14058         case OP_IAND:
14059                 return OP_X86_AND_REG_MEMBASE;
14060         case OP_IOR:
14061                 return OP_X86_OR_REG_MEMBASE;
14062         case OP_IXOR:
14063                 return OP_X86_XOR_REG_MEMBASE;
14064         }
14065 #endif
14066
14067 #ifdef TARGET_AMD64
14068         if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && cfg->backend->ilp32)) {
14069                 switch (opcode) {
14070                 case OP_ICOMPARE:
14071                         return OP_AMD64_ICOMPARE_REG_MEMBASE;
14072                 case OP_IADD:
14073                         return OP_X86_ADD_REG_MEMBASE;
14074                 case OP_ISUB:
14075                         return OP_X86_SUB_REG_MEMBASE;
14076                 case OP_IAND:
14077                         return OP_X86_AND_REG_MEMBASE;
14078                 case OP_IOR:
14079                         return OP_X86_OR_REG_MEMBASE;
14080                 case OP_IXOR:
14081                         return OP_X86_XOR_REG_MEMBASE;
14082                 }
14083         } else if ((load_opcode == OP_LOADI8_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE && !cfg->backend->ilp32)) {
14084                 switch (opcode) {
14085                 case OP_COMPARE:
14086                 case OP_LCOMPARE:
14087                         return OP_AMD64_COMPARE_REG_MEMBASE;
14088                 case OP_LADD:
14089                         return OP_AMD64_ADD_REG_MEMBASE;
14090                 case OP_LSUB:
14091                         return OP_AMD64_SUB_REG_MEMBASE;
14092                 case OP_LAND:
14093                         return OP_AMD64_AND_REG_MEMBASE;
14094                 case OP_LOR:
14095                         return OP_AMD64_OR_REG_MEMBASE;
14096                 case OP_LXOR:
14097                         return OP_AMD64_XOR_REG_MEMBASE;
14098                 }
14099         }
14100 #endif
14101
14102         return -1;
14103 }
14104
14105 int
14106 mono_op_to_op_imm_noemul (int opcode)
14107 {
14108         switch (opcode) {
14109 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
14110         case OP_LSHR:
14111         case OP_LSHL:
14112         case OP_LSHR_UN:
14113                 return -1;
14114 #endif
14115 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
14116         case OP_IDIV:
14117         case OP_IDIV_UN:
14118         case OP_IREM:
14119         case OP_IREM_UN:
14120                 return -1;
14121 #endif
14122 #if defined(MONO_ARCH_EMULATE_MUL_DIV)
14123         case OP_IMUL:
14124                 return -1;
14125 #endif
14126         default:
14127                 return mono_op_to_op_imm (opcode);
14128         }
14129 }
14130
14131 /**
14132  * mono_handle_global_vregs:
14133  *
14134  *   Make vregs used in more than one bblock 'global', i.e. allocate a variable
14135  * for them.
14136  */
14137 void
14138 mono_handle_global_vregs (MonoCompile *cfg)
14139 {
14140         gint32 *vreg_to_bb;
14141         MonoBasicBlock *bb;
14142         int i, pos;
14143
14144         vreg_to_bb = (gint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
14145
14146 #ifdef MONO_ARCH_SIMD_INTRINSICS
14147         if (cfg->uses_simd_intrinsics)
14148                 mono_simd_simplify_indirection (cfg);
14149 #endif
14150
14151         /* Find local vregs used in more than one bb */
14152         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
14153                 MonoInst *ins = bb->code;
14154                 int block_num = bb->block_num;
14155
14156                 if (cfg->verbose_level > 2)
14157                         printf ("\nHANDLE-GLOBAL-VREGS BLOCK %d:\n", bb->block_num);
14158
14159                 cfg->cbb = bb;
14160                 for (; ins; ins = ins->next) {
14161                         const char *spec = INS_INFO (ins->opcode);
14162                         int regtype = 0, regindex;
14163                         gint32 prev_bb;
14164
14165                         if (G_UNLIKELY (cfg->verbose_level > 2))
14166                                 mono_print_ins (ins);
14167
14168                         g_assert (ins->opcode >= MONO_CEE_LAST);
14169
14170                         for (regindex = 0; regindex < 4; regindex ++) {
14171                                 int vreg = 0;
14172
14173                                 if (regindex == 0) {
14174                                         regtype = spec [MONO_INST_DEST];
14175                                         if (regtype == ' ')
14176                                                 continue;
14177                                         vreg = ins->dreg;
14178                                 } else if (regindex == 1) {
14179                                         regtype = spec [MONO_INST_SRC1];
14180                                         if (regtype == ' ')
14181                                                 continue;
14182                                         vreg = ins->sreg1;
14183                                 } else if (regindex == 2) {
14184                                         regtype = spec [MONO_INST_SRC2];
14185                                         if (regtype == ' ')
14186                                                 continue;
14187                                         vreg = ins->sreg2;
14188                                 } else if (regindex == 3) {
14189                                         regtype = spec [MONO_INST_SRC3];
14190                                         if (regtype == ' ')
14191                                                 continue;
14192                                         vreg = ins->sreg3;
14193                                 }
14194
14195 #if SIZEOF_REGISTER == 4
14196                                 /* In the LLVM case, the long opcodes are not decomposed */
14197                                 if (regtype == 'l' && !COMPILE_LLVM (cfg)) {
14198                                         /*
14199                                          * Since some instructions reference the original long vreg,
14200                                          * and some reference the two component vregs, it is quite hard
14201                                          * to determine when it needs to be global. So be conservative.
14202                                          */
14203                                         if (!get_vreg_to_inst (cfg, vreg)) {
14204                                                 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14205
14206                                                 if (cfg->verbose_level > 2)
14207                                                         printf ("LONG VREG R%d made global.\n", vreg);
14208                                         }
14209
14210                                         /*
14211                                          * Make the component vregs volatile since the optimizations can
14212                                          * get confused otherwise.
14213                                          */
14214                                         get_vreg_to_inst (cfg, MONO_LVREG_LS (vreg))->flags |= MONO_INST_VOLATILE;
14215                                         get_vreg_to_inst (cfg, MONO_LVREG_MS (vreg))->flags |= MONO_INST_VOLATILE;
14216                                 }
14217 #endif
14218
14219                                 g_assert (vreg != -1);
14220
14221                                 prev_bb = vreg_to_bb [vreg];
14222                                 if (prev_bb == 0) {
14223                                         /* 0 is a valid block num */
14224                                         vreg_to_bb [vreg] = block_num + 1;
14225                                 } else if ((prev_bb != block_num + 1) && (prev_bb != -1)) {
14226                                         if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
14227                                                 continue;
14228
14229                                         if (!get_vreg_to_inst (cfg, vreg)) {
14230                                                 if (G_UNLIKELY (cfg->verbose_level > 2))
14231                                                         printf ("VREG R%d used in BB%d and BB%d made global.\n", vreg, vreg_to_bb [vreg], block_num);
14232
14233                                                 switch (regtype) {
14234                                                 case 'i':
14235                                                         if (vreg_is_ref (cfg, vreg))
14236                                                                 mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, vreg);
14237                                                         else
14238                                                                 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL, vreg);
14239                                                         break;
14240                                                 case 'l':
14241                                                         mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
14242                                                         break;
14243                                                 case 'f':
14244                                                         mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
14245                                                         break;
14246                                                 case 'v':
14247                                                         mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, vreg);
14248                                                         break;
14249                                                 default:
14250                                                         g_assert_not_reached ();
14251                                                 }
14252                                         }
14253
14254                                         /* Flag as having been used in more than one bb */
14255                                         vreg_to_bb [vreg] = -1;
14256                                 }
14257                         }
14258                 }
14259         }
14260
14261         /* If a variable is used in only one bblock, convert it into a local vreg */
14262         for (i = 0; i < cfg->num_varinfo; i++) {
14263                 MonoInst *var = cfg->varinfo [i];
14264                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
14265
14266                 switch (var->type) {
14267                 case STACK_I4:
14268                 case STACK_OBJ:
14269                 case STACK_PTR:
14270                 case STACK_MP:
14271                 case STACK_VTYPE:
14272 #if SIZEOF_REGISTER == 8
14273                 case STACK_I8:
14274 #endif
14275 #if !defined(TARGET_X86)
14276                 /* Enabling this screws up the fp stack on x86 */
14277                 case STACK_R8:
14278 #endif
14279                         if (mono_arch_is_soft_float ())
14280                                 break;
14281
14282                         /*
14283                         if (var->type == STACK_VTYPE && cfg->gsharedvt && mini_is_gsharedvt_variable_type (var->inst_vtype))
14284                                 break;
14285                         */
14286
14287                         /* Arguments are implicitly global */
14288                         /* Putting R4 vars into registers doesn't work currently */
14289                         /* The gsharedvt vars are implicitly referenced by ldaddr opcodes, but those opcodes are only generated later */
14290                         if ((var->opcode != OP_ARG) && (var != cfg->ret) && !(var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && (vreg_to_bb [var->dreg] != -1) && (var->klass->byval_arg.type != MONO_TYPE_R4) && !cfg->disable_vreg_to_lvreg && var != cfg->gsharedvt_info_var && var != cfg->gsharedvt_locals_var && var != cfg->lmf_addr_var) {
14291                                 /*
14292                                  * Make that the variable's liveness interval doesn't contain a call, since
14293                                  * that would cause the lvreg to be spilled, making the whole optimization
14294                                  * useless.
14295                                  */
14296                                 /* This is too slow for JIT compilation */
14297 #if 0
14298                                 if (cfg->compile_aot && vreg_to_bb [var->dreg]) {
14299                                         MonoInst *ins;
14300                                         int def_index, call_index, ins_index;
14301                                         gboolean spilled = FALSE;
14302
14303                                         def_index = -1;
14304                                         call_index = -1;
14305                                         ins_index = 0;
14306                                         for (ins = vreg_to_bb [var->dreg]->code; ins; ins = ins->next) {
14307                                                 const char *spec = INS_INFO (ins->opcode);
14308
14309                                                 if ((spec [MONO_INST_DEST] != ' ') && (ins->dreg == var->dreg))
14310                                                         def_index = ins_index;
14311
14312                                                 if (((spec [MONO_INST_SRC1] != ' ') && (ins->sreg1 == var->dreg)) ||
14313                                                         ((spec [MONO_INST_SRC1] != ' ') && (ins->sreg1 == var->dreg))) {
14314                                                         if (call_index > def_index) {
14315                                                                 spilled = TRUE;
14316                                                                 break;
14317                                                         }
14318                                                 }
14319
14320                                                 if (MONO_IS_CALL (ins))
14321                                                         call_index = ins_index;
14322
14323                                                 ins_index ++;
14324                                         }
14325
14326                                         if (spilled)
14327                                                 break;
14328                                 }
14329 #endif
14330
14331                                 if (G_UNLIKELY (cfg->verbose_level > 2))
14332                                         printf ("CONVERTED R%d(%d) TO VREG.\n", var->dreg, vmv->idx);
14333                                 var->flags |= MONO_INST_IS_DEAD;
14334                                 cfg->vreg_to_inst [var->dreg] = NULL;
14335                         }
14336                         break;
14337                 }
14338         }
14339
14340         /*
14341          * Compress the varinfo and vars tables so the liveness computation is faster and
14342          * takes up less space.
14343          */
14344         pos = 0;
14345         for (i = 0; i < cfg->num_varinfo; ++i) {
14346                 MonoInst *var = cfg->varinfo [i];
14347                 if (pos < i && cfg->locals_start == i)
14348                         cfg->locals_start = pos;
14349                 if (!(var->flags & MONO_INST_IS_DEAD)) {
14350                         if (pos < i) {
14351                                 cfg->varinfo [pos] = cfg->varinfo [i];
14352                                 cfg->varinfo [pos]->inst_c0 = pos;
14353                                 memcpy (&cfg->vars [pos], &cfg->vars [i], sizeof (MonoMethodVar));
14354                                 cfg->vars [pos].idx = pos;
14355 #if SIZEOF_REGISTER == 4
14356                                 if (cfg->varinfo [pos]->type == STACK_I8) {
14357                                         /* Modify the two component vars too */
14358                                         MonoInst *var1;
14359
14360                                         var1 = get_vreg_to_inst (cfg, MONO_LVREG_LS (cfg->varinfo [pos]->dreg));
14361                                         var1->inst_c0 = pos;
14362                                         var1 = get_vreg_to_inst (cfg, MONO_LVREG_MS (cfg->varinfo [pos]->dreg));
14363                                         var1->inst_c0 = pos;
14364                                 }
14365 #endif
14366                         }
14367                         pos ++;
14368                 }
14369         }
14370         cfg->num_varinfo = pos;
14371         if (cfg->locals_start > cfg->num_varinfo)
14372                 cfg->locals_start = cfg->num_varinfo;
14373 }
14374
14375 /*
14376  * mono_allocate_gsharedvt_vars:
14377  *
14378  *   Allocate variables with gsharedvt types to entries in the MonoGSharedVtMethodRuntimeInfo.entries array.
14379  * Initialize cfg->gsharedvt_vreg_to_idx with the mapping between vregs and indexes.
14380  */
14381 void
14382 mono_allocate_gsharedvt_vars (MonoCompile *cfg)
14383 {
14384         int i;
14385
14386         cfg->gsharedvt_vreg_to_idx = (int *)mono_mempool_alloc0 (cfg->mempool, sizeof (int) * cfg->next_vreg);
14387
14388         for (i = 0; i < cfg->num_varinfo; ++i) {
14389                 MonoInst *ins = cfg->varinfo [i];
14390                 int idx;
14391
14392                 if (mini_is_gsharedvt_variable_type (ins->inst_vtype)) {
14393                         if (i >= cfg->locals_start) {
14394                                 /* Local */
14395                                 idx = get_gsharedvt_info_slot (cfg, ins->inst_vtype, MONO_RGCTX_INFO_LOCAL_OFFSET);
14396                                 cfg->gsharedvt_vreg_to_idx [ins->dreg] = idx + 1;
14397                                 ins->opcode = OP_GSHAREDVT_LOCAL;
14398                                 ins->inst_imm = idx;
14399                         } else {
14400                                 /* Arg */
14401                                 cfg->gsharedvt_vreg_to_idx [ins->dreg] = -1;
14402                                 ins->opcode = OP_GSHAREDVT_ARG_REGOFFSET;
14403                         }
14404                 }
14405         }
14406 }
14407
14408 /**
14409  * mono_spill_global_vars:
14410  *
14411  *   Generate spill code for variables which are not allocated to registers,
14412  * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
14413  * code is generated which could be optimized by the local optimization passes.
14414  */
14415 void
14416 mono_spill_global_vars (MonoCompile *cfg, gboolean *need_local_opts)
14417 {
14418         MonoBasicBlock *bb;
14419         char spec2 [16];
14420         int orig_next_vreg;
14421         guint32 *vreg_to_lvreg;
14422         guint32 *lvregs;
14423         guint32 i, lvregs_len;
14424         gboolean dest_has_lvreg = FALSE;
14425         MonoStackType stacktypes [128];
14426         MonoInst **live_range_start, **live_range_end;
14427         MonoBasicBlock **live_range_start_bb, **live_range_end_bb;
14428
14429         *need_local_opts = FALSE;
14430
14431         memset (spec2, 0, sizeof (spec2));
14432
14433         /* FIXME: Move this function to mini.c */
14434         stacktypes ['i'] = STACK_PTR;
14435         stacktypes ['l'] = STACK_I8;
14436         stacktypes ['f'] = STACK_R8;
14437 #ifdef MONO_ARCH_SIMD_INTRINSICS
14438         stacktypes ['x'] = STACK_VTYPE;
14439 #endif
14440
14441 #if SIZEOF_REGISTER == 4
14442         /* Create MonoInsts for longs */
14443         for (i = 0; i < cfg->num_varinfo; i++) {
14444                 MonoInst *ins = cfg->varinfo [i];
14445
14446                 if ((ins->opcode != OP_REGVAR) && !(ins->flags & MONO_INST_IS_DEAD)) {
14447                         switch (ins->type) {
14448                         case STACK_R8:
14449                         case STACK_I8: {
14450                                 MonoInst *tree;
14451
14452                                 if (ins->type == STACK_R8 && !COMPILE_SOFT_FLOAT (cfg))
14453                                         break;
14454
14455                                 g_assert (ins->opcode == OP_REGOFFSET);
14456
14457                                 tree = get_vreg_to_inst (cfg, MONO_LVREG_LS (ins->dreg));
14458                                 g_assert (tree);
14459                                 tree->opcode = OP_REGOFFSET;
14460                                 tree->inst_basereg = ins->inst_basereg;
14461                                 tree->inst_offset = ins->inst_offset + MINI_LS_WORD_OFFSET;
14462
14463                                 tree = get_vreg_to_inst (cfg, MONO_LVREG_MS (ins->dreg));
14464                                 g_assert (tree);
14465                                 tree->opcode = OP_REGOFFSET;
14466                                 tree->inst_basereg = ins->inst_basereg;
14467                                 tree->inst_offset = ins->inst_offset + MINI_MS_WORD_OFFSET;
14468                                 break;
14469                         }
14470                         default:
14471                                 break;
14472                         }
14473                 }
14474         }
14475 #endif
14476
14477         if (cfg->compute_gc_maps) {
14478                 /* registers need liveness info even for !non refs */
14479                 for (i = 0; i < cfg->num_varinfo; i++) {
14480                         MonoInst *ins = cfg->varinfo [i];
14481
14482                         if (ins->opcode == OP_REGVAR)
14483                                 ins->flags |= MONO_INST_GC_TRACK;
14484                 }
14485         }
14486
14487         /* FIXME: widening and truncation */
14488
14489         /*
14490          * As an optimization, when a variable allocated to the stack is first loaded into
14491          * an lvreg, we will remember the lvreg and use it the next time instead of loading
14492          * the variable again.
14493          */
14494         orig_next_vreg = cfg->next_vreg;
14495         vreg_to_lvreg = (guint32 *)mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
14496         lvregs = (guint32 *)mono_mempool_alloc (cfg->mempool, sizeof (guint32) * 1024);
14497         lvregs_len = 0;
14498
14499         /*
14500          * These arrays contain the first and last instructions accessing a given
14501          * variable.
14502          * Since we emit bblocks in the same order we process them here, and we
14503          * don't split live ranges, these will precisely describe the live range of
14504          * the variable, i.e. the instruction range where a valid value can be found
14505          * in the variables location.
14506          * The live range is computed using the liveness info computed by the liveness pass.
14507          * We can't use vmv->range, since that is an abstract live range, and we need
14508          * one which is instruction precise.
14509          * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
14510          */
14511         /* FIXME: Only do this if debugging info is requested */
14512         live_range_start = g_new0 (MonoInst*, cfg->next_vreg);
14513         live_range_end = g_new0 (MonoInst*, cfg->next_vreg);
14514         live_range_start_bb = g_new (MonoBasicBlock*, cfg->next_vreg);
14515         live_range_end_bb = g_new (MonoBasicBlock*, cfg->next_vreg);
14516
14517         /* Add spill loads/stores */
14518         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
14519                 MonoInst *ins;
14520
14521                 if (cfg->verbose_level > 2)
14522                         printf ("\nSPILL BLOCK %d:\n", bb->block_num);
14523
14524                 /* Clear vreg_to_lvreg array */
14525                 for (i = 0; i < lvregs_len; i++)
14526                         vreg_to_lvreg [lvregs [i]] = 0;
14527                 lvregs_len = 0;
14528
14529                 cfg->cbb = bb;
14530                 MONO_BB_FOR_EACH_INS (bb, ins) {
14531                         const char *spec = INS_INFO (ins->opcode);
14532                         int regtype, srcindex, sreg, tmp_reg, prev_dreg, num_sregs;
14533                         gboolean store, no_lvreg;
14534                         int sregs [MONO_MAX_SRC_REGS];
14535
14536                         if (G_UNLIKELY (cfg->verbose_level > 2))
14537                                 mono_print_ins (ins);
14538
14539                         if (ins->opcode == OP_NOP)
14540                                 continue;
14541
14542                         /*
14543                          * We handle LDADDR here as well, since it can only be decomposed
14544                          * when variable addresses are known.
14545                          */
14546                         if (ins->opcode == OP_LDADDR) {
14547                                 MonoInst *var = (MonoInst *)ins->inst_p0;
14548
14549                                 if (var->opcode == OP_VTARG_ADDR) {
14550                                         /* Happens on SPARC/S390 where vtypes are passed by reference */
14551                                         MonoInst *vtaddr = var->inst_left;
14552                                         if (vtaddr->opcode == OP_REGVAR) {
14553                                                 ins->opcode = OP_MOVE;
14554                                                 ins->sreg1 = vtaddr->dreg;
14555                                         }
14556                                         else if (var->inst_left->opcode == OP_REGOFFSET) {
14557                                                 ins->opcode = OP_LOAD_MEMBASE;
14558                                                 ins->inst_basereg = vtaddr->inst_basereg;
14559                                                 ins->inst_offset = vtaddr->inst_offset;
14560                                         } else
14561                                                 NOT_IMPLEMENTED;
14562                                 } else if (cfg->gsharedvt && cfg->gsharedvt_vreg_to_idx [var->dreg] < 0) {
14563                                         /* gsharedvt arg passed by ref */
14564                                         g_assert (var->opcode == OP_GSHAREDVT_ARG_REGOFFSET);
14565
14566                                         ins->opcode = OP_LOAD_MEMBASE;
14567                                         ins->inst_basereg = var->inst_basereg;
14568                                         ins->inst_offset = var->inst_offset;
14569                                 } else if (cfg->gsharedvt && cfg->gsharedvt_vreg_to_idx [var->dreg]) {
14570                                         MonoInst *load, *load2, *load3;
14571                                         int idx = cfg->gsharedvt_vreg_to_idx [var->dreg] - 1;
14572                                         int reg1, reg2, reg3;
14573                                         MonoInst *info_var = cfg->gsharedvt_info_var;
14574                                         MonoInst *locals_var = cfg->gsharedvt_locals_var;
14575
14576                                         /*
14577                                          * gsharedvt local.
14578                                          * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
14579                                          */
14580
14581                                         g_assert (var->opcode == OP_GSHAREDVT_LOCAL);
14582
14583                                         g_assert (info_var);
14584                                         g_assert (locals_var);
14585
14586                                         /* Mark the instruction used to compute the locals var as used */
14587                                         cfg->gsharedvt_locals_var_ins = NULL;
14588
14589                                         /* Load the offset */
14590                                         if (info_var->opcode == OP_REGOFFSET) {
14591                                                 reg1 = alloc_ireg (cfg);
14592                                                 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, reg1, info_var->inst_basereg, info_var->inst_offset);
14593                                         } else if (info_var->opcode == OP_REGVAR) {
14594                                                 load = NULL;
14595                                                 reg1 = info_var->dreg;
14596                                         } else {
14597                                                 g_assert_not_reached ();
14598                                         }
14599                                         reg2 = alloc_ireg (cfg);
14600                                         NEW_LOAD_MEMBASE (cfg, load2, OP_LOADI4_MEMBASE, reg2, reg1, MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)));
14601                                         /* Load the locals area address */
14602                                         reg3 = alloc_ireg (cfg);
14603                                         if (locals_var->opcode == OP_REGOFFSET) {
14604                                                 NEW_LOAD_MEMBASE (cfg, load3, OP_LOAD_MEMBASE, reg3, locals_var->inst_basereg, locals_var->inst_offset);
14605                                         } else if (locals_var->opcode == OP_REGVAR) {
14606                                                 NEW_UNALU (cfg, load3, OP_MOVE, reg3, locals_var->dreg);
14607                                         } else {
14608                                                 g_assert_not_reached ();
14609                                         }
14610                                         /* Compute the address */
14611                                         ins->opcode = OP_PADD;
14612                                         ins->sreg1 = reg3;
14613                                         ins->sreg2 = reg2;
14614
14615                                         mono_bblock_insert_before_ins (bb, ins, load3);
14616                                         mono_bblock_insert_before_ins (bb, load3, load2);
14617                                         if (load)
14618                                                 mono_bblock_insert_before_ins (bb, load2, load);
14619                                 } else {
14620                                         g_assert (var->opcode == OP_REGOFFSET);
14621
14622                                         ins->opcode = OP_ADD_IMM;
14623                                         ins->sreg1 = var->inst_basereg;
14624                                         ins->inst_imm = var->inst_offset;
14625                                 }
14626
14627                                 *need_local_opts = TRUE;
14628                                 spec = INS_INFO (ins->opcode);
14629                         }
14630
14631                         if (ins->opcode < MONO_CEE_LAST) {
14632                                 mono_print_ins (ins);
14633                                 g_assert_not_reached ();
14634                         }
14635
14636                         /*
14637                          * Store opcodes have destbasereg in the dreg, but in reality, it is an
14638                          * src register.
14639                          * FIXME:
14640                          */
14641                         if (MONO_IS_STORE_MEMBASE (ins)) {
14642                                 tmp_reg = ins->dreg;
14643                                 ins->dreg = ins->sreg2;
14644                                 ins->sreg2 = tmp_reg;
14645                                 store = TRUE;
14646
14647                                 spec2 [MONO_INST_DEST] = ' ';
14648                                 spec2 [MONO_INST_SRC1] = spec [MONO_INST_SRC1];
14649                                 spec2 [MONO_INST_SRC2] = spec [MONO_INST_DEST];
14650                                 spec2 [MONO_INST_SRC3] = ' ';
14651                                 spec = spec2;
14652                         } else if (MONO_IS_STORE_MEMINDEX (ins))
14653                                 g_assert_not_reached ();
14654                         else
14655                                 store = FALSE;
14656                         no_lvreg = FALSE;
14657
14658                         if (G_UNLIKELY (cfg->verbose_level > 2)) {
14659                                 printf ("\t %.3s %d", spec, ins->dreg);
14660                                 num_sregs = mono_inst_get_src_registers (ins, sregs);
14661                                 for (srcindex = 0; srcindex < num_sregs; ++srcindex)
14662                                         printf (" %d", sregs [srcindex]);
14663                                 printf ("\n");
14664                         }
14665
14666                         /***************/
14667                         /*    DREG     */
14668                         /***************/
14669                         regtype = spec [MONO_INST_DEST];
14670                         g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
14671                         prev_dreg = -1;
14672
14673                         if ((ins->dreg != -1) && get_vreg_to_inst (cfg, ins->dreg)) {
14674                                 MonoInst *var = get_vreg_to_inst (cfg, ins->dreg);
14675                                 MonoInst *store_ins;
14676                                 int store_opcode;
14677                                 MonoInst *def_ins = ins;
14678                                 int dreg = ins->dreg; /* The original vreg */
14679
14680                                 store_opcode = mono_type_to_store_membase (cfg, var->inst_vtype);
14681
14682                                 if (var->opcode == OP_REGVAR) {
14683                                         ins->dreg = var->dreg;
14684                                 } else if ((ins->dreg == ins->sreg1) && (spec [MONO_INST_DEST] == 'i') && (spec [MONO_INST_SRC1] == 'i') && !vreg_to_lvreg [ins->dreg] && (op_to_op_dest_membase (store_opcode, ins->opcode) != -1)) {
14685                                         /*
14686                                          * Instead of emitting a load+store, use a _membase opcode.
14687                                          */
14688                                         g_assert (var->opcode == OP_REGOFFSET);
14689                                         if (ins->opcode == OP_MOVE) {
14690                                                 NULLIFY_INS (ins);
14691                                                 def_ins = NULL;
14692                                         } else {
14693                                                 ins->opcode = op_to_op_dest_membase (store_opcode, ins->opcode);
14694                                                 ins->inst_basereg = var->inst_basereg;
14695                                                 ins->inst_offset = var->inst_offset;
14696                                                 ins->dreg = -1;
14697                                         }
14698                                         spec = INS_INFO (ins->opcode);
14699                                 } else {
14700                                         guint32 lvreg;
14701
14702                                         g_assert (var->opcode == OP_REGOFFSET);
14703
14704                                         prev_dreg = ins->dreg;
14705
14706                                         /* Invalidate any previous lvreg for this vreg */
14707                                         vreg_to_lvreg [ins->dreg] = 0;
14708
14709                                         lvreg = 0;
14710
14711                                         if (COMPILE_SOFT_FLOAT (cfg) && store_opcode == OP_STORER8_MEMBASE_REG) {
14712                                                 regtype = 'l';
14713                                                 store_opcode = OP_STOREI8_MEMBASE_REG;
14714                                         }
14715
14716                                         ins->dreg = alloc_dreg (cfg, stacktypes [regtype]);
14717
14718 #if SIZEOF_REGISTER != 8
14719                                         if (regtype == 'l') {
14720                                                 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, MONO_LVREG_LS (ins->dreg));
14721                                                 mono_bblock_insert_after_ins (bb, ins, store_ins);
14722                                                 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, MONO_LVREG_MS (ins->dreg));
14723                                                 mono_bblock_insert_after_ins (bb, ins, store_ins);
14724                                                 def_ins = store_ins;
14725                                         }
14726                                         else
14727 #endif
14728                                         {
14729                                                 g_assert (store_opcode != OP_STOREV_MEMBASE);
14730
14731                                                 /* Try to fuse the store into the instruction itself */
14732                                                 /* FIXME: Add more instructions */
14733                                                 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
14734                                                         ins->opcode = store_membase_reg_to_store_membase_imm (store_opcode);
14735                                                         ins->inst_imm = ins->inst_c0;
14736                                                         ins->inst_destbasereg = var->inst_basereg;
14737                                                         ins->inst_offset = var->inst_offset;
14738                                                         spec = INS_INFO (ins->opcode);
14739                                                 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE) || (ins->opcode == OP_RMOVE))) {
14740                                                         ins->opcode = store_opcode;
14741                                                         ins->inst_destbasereg = var->inst_basereg;
14742                                                         ins->inst_offset = var->inst_offset;
14743
14744                                                         no_lvreg = TRUE;
14745
14746                                                         tmp_reg = ins->dreg;
14747                                                         ins->dreg = ins->sreg2;
14748                                                         ins->sreg2 = tmp_reg;
14749                                                         store = TRUE;
14750
14751                                                         spec2 [MONO_INST_DEST] = ' ';
14752                                                         spec2 [MONO_INST_SRC1] = spec [MONO_INST_SRC1];
14753                                                         spec2 [MONO_INST_SRC2] = spec [MONO_INST_DEST];
14754                                                         spec2 [MONO_INST_SRC3] = ' ';
14755                                                         spec = spec2;
14756                                                 } else if (!lvreg && (op_to_op_store_membase (store_opcode, ins->opcode) != -1)) {
14757                                                         // FIXME: The backends expect the base reg to be in inst_basereg
14758                                                         ins->opcode = op_to_op_store_membase (store_opcode, ins->opcode);
14759                                                         ins->dreg = -1;
14760                                                         ins->inst_basereg = var->inst_basereg;
14761                                                         ins->inst_offset = var->inst_offset;
14762                                                         spec = INS_INFO (ins->opcode);
14763                                                 } else {
14764                                                         /* printf ("INS: "); mono_print_ins (ins); */
14765                                                         /* Create a store instruction */
14766                                                         NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
14767
14768                                                         /* Insert it after the instruction */
14769                                                         mono_bblock_insert_after_ins (bb, ins, store_ins);
14770
14771                                                         def_ins = store_ins;
14772
14773                                                         /*
14774                                                          * We can't assign ins->dreg to var->dreg here, since the
14775                                                          * sregs could use it. So set a flag, and do it after
14776                                                          * the sregs.
14777                                                          */
14778                                                         if ((!cfg->backend->use_fpstack || ((store_opcode != OP_STORER8_MEMBASE_REG) && (store_opcode != OP_STORER4_MEMBASE_REG))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)))
14779                                                                 dest_has_lvreg = TRUE;
14780                                                 }
14781                                         }
14782                                 }
14783
14784                                 if (def_ins && !live_range_start [dreg]) {
14785                                         live_range_start [dreg] = def_ins;
14786                                         live_range_start_bb [dreg] = bb;
14787                                 }
14788
14789                                 if (cfg->compute_gc_maps && def_ins && (var->flags & MONO_INST_GC_TRACK)) {
14790                                         MonoInst *tmp;
14791
14792                                         MONO_INST_NEW (cfg, tmp, OP_GC_LIVENESS_DEF);
14793                                         tmp->inst_c1 = dreg;
14794                                         mono_bblock_insert_after_ins (bb, def_ins, tmp);
14795                                 }
14796                         }
14797
14798                         /************/
14799                         /*  SREGS   */
14800                         /************/
14801                         num_sregs = mono_inst_get_src_registers (ins, sregs);
14802                         for (srcindex = 0; srcindex < 3; ++srcindex) {
14803                                 regtype = spec [MONO_INST_SRC1 + srcindex];
14804                                 sreg = sregs [srcindex];
14805
14806                                 g_assert (((sreg == -1) && (regtype == ' ')) || ((sreg != -1) && (regtype != ' ')));
14807                                 if ((sreg != -1) && get_vreg_to_inst (cfg, sreg)) {
14808                                         MonoInst *var = get_vreg_to_inst (cfg, sreg);
14809                                         MonoInst *use_ins = ins;
14810                                         MonoInst *load_ins;
14811                                         guint32 load_opcode;
14812
14813                                         if (var->opcode == OP_REGVAR) {
14814                                                 sregs [srcindex] = var->dreg;
14815                                                 //mono_inst_set_src_registers (ins, sregs);
14816                                                 live_range_end [sreg] = use_ins;
14817                                                 live_range_end_bb [sreg] = bb;
14818
14819                                                 if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
14820                                                         MonoInst *tmp;
14821
14822                                                         MONO_INST_NEW (cfg, tmp, OP_GC_LIVENESS_USE);
14823                                                         /* var->dreg is a hreg */
14824                                                         tmp->inst_c1 = sreg;
14825                                                         mono_bblock_insert_after_ins (bb, ins, tmp);
14826                                                 }
14827
14828                                                 continue;
14829                                         }
14830
14831                                         g_assert (var->opcode == OP_REGOFFSET);
14832
14833                                         load_opcode = mono_type_to_load_membase (cfg, var->inst_vtype);
14834
14835                                         g_assert (load_opcode != OP_LOADV_MEMBASE);
14836
14837                                         if (vreg_to_lvreg [sreg]) {
14838                                                 g_assert (vreg_to_lvreg [sreg] != -1);
14839
14840                                                 /* The variable is already loaded to an lvreg */
14841                                                 if (G_UNLIKELY (cfg->verbose_level > 2))
14842                                                         printf ("\t\tUse lvreg R%d for R%d.\n", vreg_to_lvreg [sreg], sreg);
14843                                                 sregs [srcindex] = vreg_to_lvreg [sreg];
14844                                                 //mono_inst_set_src_registers (ins, sregs);
14845                                                 continue;
14846                                         }
14847
14848                                         /* Try to fuse the load into the instruction */
14849                                         if ((srcindex == 0) && (op_to_op_src1_membase (cfg, load_opcode, ins->opcode) != -1)) {
14850                                                 ins->opcode = op_to_op_src1_membase (cfg, load_opcode, ins->opcode);
14851                                                 sregs [0] = var->inst_basereg;
14852                                                 //mono_inst_set_src_registers (ins, sregs);
14853                                                 ins->inst_offset = var->inst_offset;
14854                                         } else if ((srcindex == 1) && (op_to_op_src2_membase (cfg, load_opcode, ins->opcode) != -1)) {
14855                                                 ins->opcode = op_to_op_src2_membase (cfg, load_opcode, ins->opcode);
14856                                                 sregs [1] = var->inst_basereg;
14857                                                 //mono_inst_set_src_registers (ins, sregs);
14858                                                 ins->inst_offset = var->inst_offset;
14859                                         } else {
14860                                                 if (MONO_IS_REAL_MOVE (ins)) {
14861                                                         ins->opcode = OP_NOP;
14862                                                         sreg = ins->dreg;
14863                                                 } else {
14864                                                         //printf ("%d ", srcindex); mono_print_ins (ins);
14865
14866                                                         sreg = alloc_dreg (cfg, stacktypes [regtype]);
14867
14868                                                         if ((!cfg->backend->use_fpstack || ((load_opcode != OP_LOADR8_MEMBASE) && (load_opcode != OP_LOADR4_MEMBASE))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && !no_lvreg) {
14869                                                                 if (var->dreg == prev_dreg) {
14870                                                                         /*
14871                                                                          * sreg refers to the value loaded by the load
14872                                                                          * emitted below, but we need to use ins->dreg
14873                                                                          * since it refers to the store emitted earlier.
14874                                                                          */
14875                                                                         sreg = ins->dreg;
14876                                                                 }
14877                                                                 g_assert (sreg != -1);
14878                                                                 vreg_to_lvreg [var->dreg] = sreg;
14879                                                                 g_assert (lvregs_len < 1024);
14880                                                                 lvregs [lvregs_len ++] = var->dreg;
14881                                                         }
14882                                                 }
14883
14884                                                 sregs [srcindex] = sreg;
14885                                                 //mono_inst_set_src_registers (ins, sregs);
14886
14887 #if SIZEOF_REGISTER != 8
14888                                                 if (regtype == 'l') {
14889                                                         NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_MS (sreg), var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
14890                                                         mono_bblock_insert_before_ins (bb, ins, load_ins);
14891                                                         NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, MONO_LVREG_LS (sreg), var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
14892                                                         mono_bblock_insert_before_ins (bb, ins, load_ins);
14893                                                         use_ins = load_ins;
14894                                                 }
14895                                                 else
14896 #endif
14897                                                 {
14898 #if SIZEOF_REGISTER == 4
14899                                                         g_assert (load_opcode != OP_LOADI8_MEMBASE);
14900 #endif
14901                                                         NEW_LOAD_MEMBASE (cfg, load_ins, load_opcode, sreg, var->inst_basereg, var->inst_offset);
14902                                                         mono_bblock_insert_before_ins (bb, ins, load_ins);
14903                                                         use_ins = load_ins;
14904                                                 }
14905                                         }
14906
14907                                         if (var->dreg < orig_next_vreg) {
14908                                                 live_range_end [var->dreg] = use_ins;
14909                                                 live_range_end_bb [var->dreg] = bb;
14910                                         }
14911
14912                                         if (cfg->compute_gc_maps && var->dreg < orig_next_vreg && (var->flags & MONO_INST_GC_TRACK)) {
14913                                                 MonoInst *tmp;
14914
14915                                                 MONO_INST_NEW (cfg, tmp, OP_GC_LIVENESS_USE);
14916                                                 tmp->inst_c1 = var->dreg;
14917                                                 mono_bblock_insert_after_ins (bb, ins, tmp);
14918                                         }
14919                                 }
14920                         }
14921                         mono_inst_set_src_registers (ins, sregs);
14922
14923                         if (dest_has_lvreg) {
14924                                 g_assert (ins->dreg != -1);
14925                                 vreg_to_lvreg [prev_dreg] = ins->dreg;
14926                                 g_assert (lvregs_len < 1024);
14927                                 lvregs [lvregs_len ++] = prev_dreg;
14928                                 dest_has_lvreg = FALSE;
14929                         }
14930
14931                         if (store) {
14932                                 tmp_reg = ins->dreg;
14933                                 ins->dreg = ins->sreg2;
14934                                 ins->sreg2 = tmp_reg;
14935                         }
14936
14937                         if (MONO_IS_CALL (ins)) {
14938                                 /* Clear vreg_to_lvreg array */
14939                                 for (i = 0; i < lvregs_len; i++)
14940                                         vreg_to_lvreg [lvregs [i]] = 0;
14941                                 lvregs_len = 0;
14942                         } else if (ins->opcode == OP_NOP) {
14943                                 ins->dreg = -1;
14944                                 MONO_INST_NULLIFY_SREGS (ins);
14945                         }
14946
14947                         if (cfg->verbose_level > 2)
14948                                 mono_print_ins_index (1, ins);
14949                 }
14950
14951                 /* Extend the live range based on the liveness info */
14952                 if (cfg->compute_precise_live_ranges && bb->live_out_set && bb->code) {
14953                         for (i = 0; i < cfg->num_varinfo; i ++) {
14954                                 MonoMethodVar *vi = MONO_VARINFO (cfg, i);
14955
14956                                 if (vreg_is_volatile (cfg, vi->vreg))
14957                                         /* The liveness info is incomplete */
14958                                         continue;
14959
14960                                 if (mono_bitset_test_fast (bb->live_in_set, i) && !live_range_start [vi->vreg]) {
14961                                         /* Live from at least the first ins of this bb */
14962                                         live_range_start [vi->vreg] = bb->code;
14963                                         live_range_start_bb [vi->vreg] = bb;
14964                                 }
14965
14966                                 if (mono_bitset_test_fast (bb->live_out_set, i)) {
14967                                         /* Live at least until the last ins of this bb */
14968                                         live_range_end [vi->vreg] = bb->last_ins;
14969                                         live_range_end_bb [vi->vreg] = bb;
14970                                 }
14971                         }
14972                 }
14973         }
14974
14975         /*
14976          * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
14977          * by storing the current native offset into MonoMethodVar->live_range_start/end.
14978          */
14979         if (cfg->backend->have_liverange_ops && cfg->compute_precise_live_ranges && cfg->comp_done & MONO_COMP_LIVENESS) {
14980                 for (i = 0; i < cfg->num_varinfo; ++i) {
14981                         int vreg = MONO_VARINFO (cfg, i)->vreg;
14982                         MonoInst *ins;
14983
14984                         if (live_range_start [vreg]) {
14985                                 MONO_INST_NEW (cfg, ins, OP_LIVERANGE_START);
14986                                 ins->inst_c0 = i;
14987                                 ins->inst_c1 = vreg;
14988                                 mono_bblock_insert_after_ins (live_range_start_bb [vreg], live_range_start [vreg], ins);
14989                         }
14990                         if (live_range_end [vreg]) {
14991                                 MONO_INST_NEW (cfg, ins, OP_LIVERANGE_END);
14992                                 ins->inst_c0 = i;
14993                                 ins->inst_c1 = vreg;
14994                                 if (live_range_end [vreg] == live_range_end_bb [vreg]->last_ins)
14995                                         mono_add_ins_to_end (live_range_end_bb [vreg], ins);
14996                                 else
14997                                         mono_bblock_insert_after_ins (live_range_end_bb [vreg], live_range_end [vreg], ins);
14998                         }
14999                 }
15000         }
15001
15002         if (cfg->gsharedvt_locals_var_ins) {
15003                 /* Nullify if unused */
15004                 cfg->gsharedvt_locals_var_ins->opcode = OP_PCONST;
15005                 cfg->gsharedvt_locals_var_ins->inst_imm = 0;
15006         }
15007
15008         g_free (live_range_start);
15009         g_free (live_range_end);
15010         g_free (live_range_start_bb);
15011         g_free (live_range_end_bb);
15012 }
15013
15014 /**
15015  * FIXME:
15016  * - use 'iadd' instead of 'int_add'
15017  * - handling ovf opcodes: decompose in method_to_ir.
15018  * - unify iregs/fregs
15019  *   -> partly done, the missing parts are:
15020  *   - a more complete unification would involve unifying the hregs as well, so
15021  *     code wouldn't need if (fp) all over the place. but that would mean the hregs
15022  *     would no longer map to the machine hregs, so the code generators would need to
15023  *     be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
15024  *     wouldn't work any more. Duplicating the code in mono_local_regalloc () into
15025  *     fp/non-fp branches speeds it up by about 15%.
15026  * - use sext/zext opcodes instead of shifts
15027  * - add OP_ICALL
15028  * - get rid of TEMPLOADs if possible and use vregs instead
15029  * - clean up usage of OP_P/OP_ opcodes
15030  * - cleanup usage of DUMMY_USE
15031  * - cleanup the setting of ins->type for MonoInst's which are pushed on the
15032  *   stack
15033  * - set the stack type and allocate a dreg in the EMIT_NEW macros
15034  * - get rid of all the <foo>2 stuff when the new JIT is ready.
15035  * - make sure handle_stack_args () is called before the branch is emitted
15036  * - when the new IR is done, get rid of all unused stuff
15037  * - COMPARE/BEQ as separate instructions or unify them ?
15038  *   - keeping them separate allows specialized compare instructions like
15039  *     compare_imm, compare_membase
15040  *   - most back ends unify fp compare+branch, fp compare+ceq
15041  * - integrate mono_save_args into inline_method
15042  * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
15043  * - handle long shift opts on 32 bit platforms somehow: they require
15044  *   3 sregs (2 for arg1 and 1 for arg2)
15045  * - make byref a 'normal' type.
15046  * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
15047  *   variable if needed.
15048  * - do not start a new IL level bblock when cfg->cbb is changed by a function call
15049  *   like inline_method.
15050  * - remove inlining restrictions
15051  * - fix LNEG and enable cfold of INEG
15052  * - generalize x86 optimizations like ldelema as a peephole optimization
15053  * - add store_mem_imm for amd64
15054  * - optimize the loading of the interruption flag in the managed->native wrappers
15055  * - avoid special handling of OP_NOP in passes
15056  * - move code inserting instructions into one function/macro.
15057  * - try a coalescing phase after liveness analysis
15058  * - add float -> vreg conversion + local optimizations on !x86
15059  * - figure out how to handle decomposed branches during optimizations, ie.
15060  *   compare+branch, op_jump_table+op_br etc.
15061  * - promote RuntimeXHandles to vregs
15062  * - vtype cleanups:
15063  *   - add a NEW_VARLOADA_VREG macro
15064  * - the vtype optimizations are blocked by the LDADDR opcodes generated for
15065  *   accessing vtype fields.
15066  * - get rid of I8CONST on 64 bit platforms
15067  * - dealing with the increase in code size due to branches created during opcode
15068  *   decomposition:
15069  *   - use extended basic blocks
15070  *     - all parts of the JIT
15071  *     - handle_global_vregs () && local regalloc
15072  *   - avoid introducing global vregs during decomposition, like 'vtable' in isinst
15073  * - sources of increase in code size:
15074  *   - vtypes
15075  *   - long compares
15076  *   - isinst and castclass
15077  *   - lvregs not allocated to global registers even if used multiple times
15078  * - call cctors outside the JIT, to make -v output more readable and JIT timings more
15079  *   meaningful.
15080  * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
15081  * - add all micro optimizations from the old JIT
15082  * - put tree optimizations into the deadce pass
15083  * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
15084  *   specific function.
15085  * - unify the float comparison opcodes with the other comparison opcodes, i.e.
15086  *   fcompare + branchCC.
15087  * - create a helper function for allocating a stack slot, taking into account
15088  *   MONO_CFG_HAS_SPILLUP.
15089  * - merge r68207.
15090  * - merge the ia64 switch changes.
15091  * - optimize mono_regstate2_alloc_int/float.
15092  * - fix the pessimistic handling of variables accessed in exception handler blocks.
15093  * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
15094  *   parts of the tree could be separated by other instructions, killing the tree
15095  *   arguments, or stores killing loads etc. Also, should we fold loads into other
15096  *   instructions if the result of the load is used multiple times ?
15097  * - make the REM_IMM optimization in mini-x86.c arch-independent.
15098  * - LAST MERGE: 108395.
15099  * - when returning vtypes in registers, generate IR and append it to the end of the
15100  *   last bb instead of doing it in the epilog.
15101  * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
15102  */
15103
15104 /*
15105
15106 NOTES
15107 -----
15108
15109 - When to decompose opcodes:
15110   - earlier: this makes some optimizations hard to implement, since the low level IR
15111   no longer contains the neccessary information. But it is easier to do.
15112   - later: harder to implement, enables more optimizations.
15113 - Branches inside bblocks:
15114   - created when decomposing complex opcodes.
15115     - branches to another bblock: harmless, but not tracked by the branch
15116       optimizations, so need to branch to a label at the start of the bblock.
15117     - branches to inside the same bblock: very problematic, trips up the local
15118       reg allocator. Can be fixed by spitting the current bblock, but that is a
15119       complex operation, since some local vregs can become global vregs etc.
15120 - Local/global vregs:
15121   - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
15122     local register allocator.
15123   - global vregs: used in more than one bblock. Have an associated MonoMethodVar
15124     structure, created by mono_create_var (). Assigned to hregs or the stack by
15125     the global register allocator.
15126 - When to do optimizations like alu->alu_imm:
15127   - earlier -> saves work later on since the IR will be smaller/simpler
15128   - later -> can work on more instructions
15129 - Handling of valuetypes:
15130   - When a vtype is pushed on the stack, a new temporary is created, an
15131     instruction computing its address (LDADDR) is emitted and pushed on
15132     the stack. Need to optimize cases when the vtype is used immediately as in
15133     argument passing, stloc etc.
15134 - Instead of the to_end stuff in the old JIT, simply call the function handling
15135   the values on the stack before emitting the last instruction of the bb.
15136 */
15137
15138 #endif /* DISABLE_JIT */