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  */
  10
  11 #include <config.h>
  12 #include <signal.h>
  13
  14 #ifdef HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif
  17
  18 #include <math.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21
  22 #ifdef HAVE_SYS_TIME_H
  23 #include <sys/time.h>
  24 #endif
  25
  26 #ifdef HAVE_ALLOCA_H
  27 #include <alloca.h>
  28 #endif
  29
  30 #include <mono/utils/memcheck.h>
  31
  32 #include <mono/metadata/assembly.h>
  33 #include <mono/metadata/loader.h>
  34 #include <mono/metadata/tabledefs.h>
  35 #include <mono/metadata/class.h>
  36 #include <mono/metadata/object.h>
  37 #include <mono/metadata/exception.h>
  38 #include <mono/metadata/opcodes.h>
  39 #include <mono/metadata/mono-endian.h>
  40 #include <mono/metadata/tokentype.h>
  41 #include <mono/metadata/tabledefs.h>
  42 #include <mono/metadata/marshal.h>
  43 #include <mono/metadata/debug-helpers.h>
  44 #include <mono/metadata/mono-debug.h>
  45 #include <mono/metadata/gc-internal.h>
  46 #include <mono/metadata/security-manager.h>
  47 #include <mono/metadata/threads-types.h>
  48 #include <mono/metadata/security-core-clr.h>
  49 #include <mono/metadata/monitor.h>
  50 #include <mono/metadata/profiler-private.h>
  51 #include <mono/metadata/profiler.h>
  52 #include <mono/utils/mono-compiler.h>
  53 #include <mono/metadata/mono-basic-block.h>
  54
  55 #include "mini.h"
  56 #include "trace.h"
  57
  58 #include "ir-emit.h"
  59
  60 #include "jit-icalls.h"
  61 #include "jit.h"
  62 #include "debugger-agent.h"
  63
  64 #define BRANCH_COST 10
  65 #define INLINE_LENGTH_LIMIT 20
  66 #define INLINE_FAILURE do {\
  67                 if ((cfg->method != method) && (method->wrapper_type == MONO_WRAPPER_NONE))\
  68                         goto inline_failure;\
  69         } while (0)
  70 #define CHECK_CFG_EXCEPTION do {\
  71                 if (cfg->exception_type != MONO_EXCEPTION_NONE)\
  72                         goto exception_exit;\
  73         } while (0)
  74 #define METHOD_ACCESS_FAILURE do {      \
  75                 char *method_fname = mono_method_full_name (method, TRUE);      \
  76                 char *cil_method_fname = mono_method_full_name (cil_method, TRUE);      \
  77                 cfg->exception_type = MONO_EXCEPTION_METHOD_ACCESS;     \
  78                 cfg->exception_message = g_strdup_printf ("Method `%s' is inaccessible from method `%s'\n", cil_method_fname, method_fname);    \
  79                 g_free (method_fname);  \
  80                 g_free (cil_method_fname);      \
  81                 goto exception_exit;    \
  82         } while (0)
  83 #define FIELD_ACCESS_FAILURE do {       \
  84                 char *method_fname = mono_method_full_name (method, TRUE);      \
  85                 char *field_fname = mono_field_full_name (field);       \
  86                 cfg->exception_type = MONO_EXCEPTION_FIELD_ACCESS;      \
  87                 cfg->exception_message = g_strdup_printf ("Field `%s' is inaccessible from method `%s'\n", field_fname, method_fname);  \
  88                 g_free (method_fname);  \
  89                 g_free (field_fname);   \
  90                 goto exception_exit;    \
  91         } while (0)
  92 #define GENERIC_SHARING_FAILURE(opcode) do {            \
  93                 if (cfg->generic_sharing_context) {     \
  94             if (cfg->verbose_level > 2) \
  95                             printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", method->klass->name_space, method->klass->name, method->name, method->signature->param_count, mono_opcode_name ((opcode)), __LINE__); \
  96                         cfg->exception_type = MONO_EXCEPTION_GENERIC_SHARING_FAILED;    \
  97                         goto exception_exit;    \
  98                 }                       \
  99         } while (0)
 100
 101 /* Determine whenever 'ins' represents a load of the 'this' argument */
 102 #define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && ((ins)->opcode == OP_MOVE) && ((ins)->sreg1 == cfg->args [0]->dreg))
 103
 104 static int ldind_to_load_membase (int opcode);
 105 static int stind_to_store_membase (int opcode);
 106
 107 int mono_op_to_op_imm (int opcode);
 108 int mono_op_to_op_imm_noemul (int opcode);
 109
 110 MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
 111 void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
 112 void mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass);
 113
 114 /* helper methods signature */
 115 extern MonoMethodSignature *helper_sig_class_init_trampoline;
 116 extern MonoMethodSignature *helper_sig_domain_get;
 117 extern MonoMethodSignature *helper_sig_generic_class_init_trampoline;
 118 extern MonoMethodSignature *helper_sig_generic_class_init_trampoline_llvm;
 119 extern MonoMethodSignature *helper_sig_rgctx_lazy_fetch_trampoline;
 120 extern MonoMethodSignature *helper_sig_monitor_enter_exit_trampoline;
 121 extern MonoMethodSignature *helper_sig_monitor_enter_exit_trampoline_llvm;
 122
 123 /*
 124  * Instruction metadata
 125  */
 126 #ifdef MINI_OP
 127 #undef MINI_OP
 128 #endif
 129 #ifdef MINI_OP3
 130 #undef MINI_OP3
 131 #endif
 132 #define MINI_OP(a,b,dest,src1,src2) dest, src1, src2, ' ',
 133 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
 134 #define NONE ' '
 135 #define IREG 'i'
 136 #define FREG 'f'
 137 #define VREG 'v'
 138 #define XREG 'x'
 139 #if SIZEOF_REGISTER == 8
 140 #define LREG IREG
 141 #else
 142 #define LREG 'l'
 143 #endif
 144 /* keep in sync with the enum in mini.h */
 145 const char
 146 ins_info[] = {
 147 #include "mini-ops.h"
 148 };
 149 #undef MINI_OP
 150 #undef MINI_OP3
 151
 152 #define MINI_OP(a,b,dest,src1,src2) ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0)),
 153 #define MINI_OP3(a,b,dest,src1,src2,src3) ((src3) != NONE ? 3 : ((src2) != NONE ? 2 : ((src1) != NONE ? 1 : 0))),
 154 /*
 155  * This should contain the index of the last sreg + 1. This is not the same
 156  * as the number of sregs for opcodes like IA64_CMP_EQ_IMM.
 157  */
 158 const gint8 ins_sreg_counts[] = {
 159 #include "mini-ops.h"
 160 };
 161 #undef MINI_OP
 162 #undef MINI_OP3
 163
 164 #define MONO_INIT_VARINFO(vi,id) do { \
 165         (vi)->range.first_use.pos.bid = 0xffff; \
 166         (vi)->reg = -1; \
 167         (vi)->idx = (id); \
 168 } while (0)
 169
 170 void
 171 mono_inst_set_src_registers (MonoInst *ins, int *regs)
 172 {
 173         ins->sreg1 = regs [0];
 174         ins->sreg2 = regs [1];
 175         ins->sreg3 = regs [2];
 176 }
 177
 178 guint32
 179 mono_alloc_ireg (MonoCompile *cfg)
 180 {
 181         return alloc_ireg (cfg);
 182 }
 183
 184 guint32
 185 mono_alloc_freg (MonoCompile *cfg)
 186 {
 187         return alloc_freg (cfg);
 188 }
 189
 190 guint32
 191 mono_alloc_preg (MonoCompile *cfg)
 192 {
 193         return alloc_preg (cfg);
 194 }
 195
 196 guint32
 197 mono_alloc_dreg (MonoCompile *cfg, MonoStackType stack_type)
 198 {
 199         return alloc_dreg (cfg, stack_type);
 200 }
 201
 202 guint
 203 mono_type_to_regmove (MonoCompile *cfg, MonoType *type)
 204 {
 205         if (type->byref)
 206                 return OP_MOVE;
 207
 208 handle_enum:
 209         switch (type->type) {
 210         case MONO_TYPE_I1:
 211         case MONO_TYPE_U1:
 212         case MONO_TYPE_BOOLEAN:
 213                 return OP_MOVE;
 214         case MONO_TYPE_I2:
 215         case MONO_TYPE_U2:
 216         case MONO_TYPE_CHAR:
 217                 return OP_MOVE;
 218         case MONO_TYPE_I4:
 219         case MONO_TYPE_U4:
 220                 return OP_MOVE;
 221         case MONO_TYPE_I:
 222         case MONO_TYPE_U:
 223         case MONO_TYPE_PTR:
 224         case MONO_TYPE_FNPTR:
 225                 return OP_MOVE;
 226         case MONO_TYPE_CLASS:
 227         case MONO_TYPE_STRING:
 228         case MONO_TYPE_OBJECT:
 229         case MONO_TYPE_SZARRAY:
 230         case MONO_TYPE_ARRAY:
 231                 return OP_MOVE;
 232         case MONO_TYPE_I8:
 233         case MONO_TYPE_U8:
 234 #if SIZEOF_REGISTER == 8
 235                 return OP_MOVE;
 236 #else
 237                 return OP_LMOVE;
 238 #endif
 239         case MONO_TYPE_R4:
 240                 return OP_FMOVE;
 241         case MONO_TYPE_R8:
 242                 return OP_FMOVE;
 243         case MONO_TYPE_VALUETYPE:
 244                 if (type->data.klass->enumtype) {
 245                         type = mono_class_enum_basetype (type->data.klass);
 246                         goto handle_enum;
 247                 }
 248                 if (MONO_CLASS_IS_SIMD (cfg, mono_class_from_mono_type (type)))
 249                         return OP_XMOVE;
 250                 return OP_VMOVE;
 251         case MONO_TYPE_TYPEDBYREF:
 252                 return OP_VMOVE;
 253         case MONO_TYPE_GENERICINST:
 254                 type = &type->data.generic_class->container_class->byval_arg;
 255                 goto handle_enum;
 256         case MONO_TYPE_VAR:
 257         case MONO_TYPE_MVAR:
 258                 g_assert (cfg->generic_sharing_context);
 259                 return OP_MOVE;
 260         default:
 261                 g_error ("unknown type 0x%02x in type_to_regstore", type->type);
 262         }
 263         return -1;
 264 }
 265
 266 void
 267 mono_print_bb (MonoBasicBlock *bb, const char *msg)
 268 {
 269         int i;
 270         MonoInst *tree;
 271
 272         printf ("\n%s %d: [IN: ", msg, bb->block_num);
 273         for (i = 0; i < bb->in_count; ++i)
 274                 printf (" BB%d(%d)", bb->in_bb [i]->block_num, bb->in_bb [i]->dfn);
 275         printf (", OUT: ");
 276         for (i = 0; i < bb->out_count; ++i)
 277                 printf (" BB%d(%d)", bb->out_bb [i]->block_num, bb->out_bb [i]->dfn);
 278         printf (" ]\n");
 279         for (tree = bb->code; tree; tree = tree->next)
 280                 mono_print_ins_index (-1, tree);
 281 }
 282
 283 /*
 284  * Can't put this at the beginning, since other files reference stuff from this
 285  * file.
 286  */
 287 #ifndef DISABLE_JIT
 288
 289 #define UNVERIFIED do { if (mini_get_debug_options ()->break_on_unverified) G_BREAKPOINT (); else goto unverified; } while (0)
 290
 291 #define GET_BBLOCK(cfg,tblock,ip) do {  \
 292                 (tblock) = cfg->cil_offset_to_bb [(ip) - cfg->cil_start]; \
 293                 if (!(tblock)) {        \
 294                         if ((ip) >= end || (ip) < header->code) UNVERIFIED; \
 295             NEW_BBLOCK (cfg, (tblock)); \
 296                         (tblock)->cil_code = (ip);      \
 297                         ADD_BBLOCK (cfg, (tblock));     \
 298                 } \
 299         } while (0)
 300
 301 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 302 #define EMIT_NEW_X86_LEA(cfg,dest,sr1,sr2,shift,imm) do { \
 303                 MONO_INST_NEW (cfg, dest, OP_X86_LEA); \
 304                 (dest)->dreg = alloc_preg ((cfg)); \
 305                 (dest)->sreg1 = (sr1); \
 306                 (dest)->sreg2 = (sr2); \
 307                 (dest)->inst_imm = (imm); \
 308                 (dest)->backend.shift_amount = (shift); \
 309                 MONO_ADD_INS ((cfg)->cbb, (dest)); \
 310         } while (0)
 311 #endif
 312
 313 #if SIZEOF_REGISTER == 8
 314 #define ADD_WIDEN_OP(ins, arg1, arg2) do { \
 315                 /* FIXME: Need to add many more cases */ \
 316                 if ((arg1)->type == STACK_PTR && (arg2)->type == STACK_I4) {    \
 317                         MonoInst *widen; \
 318                         int dr = alloc_preg (cfg); \
 319                         EMIT_NEW_UNALU (cfg, widen, OP_SEXT_I4, dr, (arg2)->dreg); \
 320                         (ins)->sreg2 = widen->dreg; \
 321                 } \
 322         } while (0)
 323 #else
 324 #define ADD_WIDEN_OP(ins, arg1, arg2)
 325 #endif
 326
 327 #define ADD_BINOP(op) do {      \
 328                 MONO_INST_NEW (cfg, ins, (op)); \
 329                 sp -= 2;        \
 330                 ins->sreg1 = sp [0]->dreg;      \
 331                 ins->sreg2 = sp [1]->dreg;      \
 332                 type_from_op (ins, sp [0], sp [1]);     \
 333                 CHECK_TYPE (ins);       \
 334                 /* Have to insert a widening op */               \
 335         ADD_WIDEN_OP (ins, sp [0], sp [1]); \
 336         ins->dreg = alloc_dreg ((cfg), (ins)->type); \
 337         MONO_ADD_INS ((cfg)->cbb, (ins)); \
 338         *sp++ = mono_decompose_opcode ((cfg), (ins)); \
 339         } while (0)
 340
 341 #define ADD_UNOP(op) do {       \
 342                 MONO_INST_NEW (cfg, ins, (op)); \
 343                 sp--;   \
 344                 ins->sreg1 = sp [0]->dreg;      \
 345                 type_from_op (ins, sp [0], NULL);       \
 346                 CHECK_TYPE (ins);       \
 347         (ins)->dreg = alloc_dreg ((cfg), (ins)->type); \
 348         MONO_ADD_INS ((cfg)->cbb, (ins)); \
 349                 *sp++ = mono_decompose_opcode (cfg, ins); \
 350         } while (0)
 351
 352 #define ADD_BINCOND(next_block) do {    \
 353                 MonoInst *cmp;  \
 354                 sp -= 2; \
 355                 MONO_INST_NEW(cfg, cmp, OP_COMPARE);    \
 356                 cmp->sreg1 = sp [0]->dreg;      \
 357                 cmp->sreg2 = sp [1]->dreg;      \
 358                 type_from_op (cmp, sp [0], sp [1]);     \
 359                 CHECK_TYPE (cmp);       \
 360                 type_from_op (ins, sp [0], sp [1]);     \
 361                 ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);      \
 362                 GET_BBLOCK (cfg, tblock, target);               \
 363                 link_bblock (cfg, bblock, tblock);      \
 364                 ins->inst_true_bb = tblock;     \
 365                 if ((next_block)) {     \
 366                         link_bblock (cfg, bblock, (next_block));        \
 367                         ins->inst_false_bb = (next_block);      \
 368                         start_new_bblock = 1;   \
 369                 } else {        \
 370                         GET_BBLOCK (cfg, tblock, ip);           \
 371                         link_bblock (cfg, bblock, tblock);      \
 372                         ins->inst_false_bb = tblock;    \
 373                         start_new_bblock = 2;   \
 374                 }       \
 375                 if (sp != stack_start) {                                                                        \
 376                     handle_stack_args (cfg, stack_start, sp - stack_start); \
 377                         CHECK_UNVERIFIABLE (cfg); \
 378                 } \
 379         MONO_ADD_INS (bblock, cmp); \
 380                 MONO_ADD_INS (bblock, ins);     \
 381         } while (0)
 382
 383 /* *
 384  * link_bblock: Links two basic blocks
 385  *
 386  * links two basic blocks in the control flow graph, the 'from'
 387  * argument is the starting block and the 'to' argument is the block
 388  * the control flow ends to after 'from'.
 389  */
 390 static void
 391 link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to)
 392 {
 393         MonoBasicBlock **newa;
 394         int i, found;
 395
 396 #if 0
 397         if (from->cil_code) {
 398                 if (to->cil_code)
 399                         printf ("edge from IL%04x to IL_%04x\n", from->cil_code - cfg->cil_code, to->cil_code - cfg->cil_code);
 400                 else
 401                         printf ("edge from IL%04x to exit\n", from->cil_code - cfg->cil_code);
 402         } else {
 403                 if (to->cil_code)
 404                         printf ("edge from entry to IL_%04x\n", to->cil_code - cfg->cil_code);
 405                 else
 406                         printf ("edge from entry to exit\n");
 407         }
 408 #endif
 409
 410         found = FALSE;
 411         for (i = 0; i < from->out_count; ++i) {
 412                 if (to == from->out_bb [i]) {
 413                         found = TRUE;
 414                         break;
 415                 }
 416         }
 417         if (!found) {
 418                 newa = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (from->out_count + 1));
 419                 for (i = 0; i < from->out_count; ++i) {
 420                         newa [i] = from->out_bb [i];
 421                 }
 422                 newa [i] = to;
 423                 from->out_count++;
 424                 from->out_bb = newa;
 425         }
 426
 427         found = FALSE;
 428         for (i = 0; i < to->in_count; ++i) {
 429                 if (from == to->in_bb [i]) {
 430                         found = TRUE;
 431                         break;
 432                 }
 433         }
 434         if (!found) {
 435                 newa = mono_mempool_alloc (cfg->mempool, sizeof (gpointer) * (to->in_count + 1));
 436                 for (i = 0; i < to->in_count; ++i) {
 437                         newa [i] = to->in_bb [i];
 438                 }
 439                 newa [i] = from;
 440                 to->in_count++;
 441                 to->in_bb = newa;
 442         }
 443 }
 444
 445 void
 446 mono_link_bblock (MonoCompile *cfg, MonoBasicBlock *from, MonoBasicBlock* to)
 447 {
 448         link_bblock (cfg, from, to);
 449 }
 450
 451 /**
 452  * mono_find_block_region:
 453  *
 454  *   We mark each basic block with a region ID. We use that to avoid BB
 455  *   optimizations when blocks are in different regions.
 456  *
 457  * Returns:
 458  *   A region token that encodes where this region is, and information
 459  *   about the clause owner for this block.
 460  *
 461  *   The region encodes the try/catch/filter clause that owns this block
 462  *   as well as the type.  -1 is a special value that represents a block
 463  *   that is in none of try/catch/filter.
 464  */
 465 static int
 466 mono_find_block_region (MonoCompile *cfg, int offset)
 467 {
 468         MonoMethodHeader *header = cfg->header;
 469         MonoExceptionClause *clause;
 470         int i;
 471
 472         for (i = 0; i < header->num_clauses; ++i) {
 473                 clause = &header->clauses [i];
 474                 if ((clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) && (offset >= clause->data.filter_offset) &&
 475                     (offset < (clause->handler_offset)))
 476                         return ((i + 1) << 8) | MONO_REGION_FILTER | clause->flags;
 477
 478                 if (MONO_OFFSET_IN_HANDLER (clause, offset)) {
 479                         if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY)
 480                                 return ((i + 1) << 8) | MONO_REGION_FINALLY | clause->flags;
 481                         else if (clause->flags == MONO_EXCEPTION_CLAUSE_FAULT)
 482                                 return ((i + 1) << 8) | MONO_REGION_FAULT | clause->flags;
 483                         else
 484                                 return ((i + 1) << 8) | MONO_REGION_CATCH | clause->flags;
 485                 }
 486
 487                 if (MONO_OFFSET_IN_CLAUSE (clause, offset))
 488                         return ((i + 1) << 8) | clause->flags;
 489         }
 490
 491         return -1;
 492 }
 493
 494 static GList*
 495 mono_find_final_block (MonoCompile *cfg, unsigned char *ip, unsigned char *target, int type)
 496 {
 497         MonoMethodHeader *header = cfg->header;
 498         MonoExceptionClause *clause;
 499         int i;
 500         GList *res = NULL;
 501
 502         for (i = 0; i < header->num_clauses; ++i) {
 503                 clause = &header->clauses [i];
 504                 if (MONO_OFFSET_IN_CLAUSE (clause, (ip - header->code)) &&
 505                     (!MONO_OFFSET_IN_CLAUSE (clause, (target - header->code)))) {
 506                         if (clause->flags == type)
 507                                 res = g_list_append (res, clause);
 508                 }
 509         }
 510         return res;
 511 }
 512
 513 static void
 514 mono_create_spvar_for_region (MonoCompile *cfg, int region)
 515 {
 516         MonoInst *var;
 517
 518         var = g_hash_table_lookup (cfg->spvars, GINT_TO_POINTER (region));
 519         if (var)
 520                 return;
 521
 522         var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
 523         /* prevent it from being register allocated */
 524         var->flags |= MONO_INST_INDIRECT;
 525
 526         g_hash_table_insert (cfg->spvars, GINT_TO_POINTER (region), var);
 527 }
 528
 529 MonoInst *
 530 mono_find_exvar_for_offset (MonoCompile *cfg, int offset)
 531 {
 532         return g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
 533 }
 534
 535 static MonoInst*
 536 mono_create_exvar_for_offset (MonoCompile *cfg, int offset)
 537 {
 538         MonoInst *var;
 539
 540         var = g_hash_table_lookup (cfg->exvars, GINT_TO_POINTER (offset));
 541         if (var)
 542                 return var;
 543
 544         var = mono_compile_create_var (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL);
 545         /* prevent it from being register allocated */
 546         var->flags |= MONO_INST_INDIRECT;
 547
 548         g_hash_table_insert (cfg->exvars, GINT_TO_POINTER (offset), var);
 549
 550         return var;
 551 }
 552
 553 /*
 554  * Returns the type used in the eval stack when @type is loaded.
 555  * FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
 556  */
 557 void
 558 type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst)
 559 {
 560         MonoClass *klass;
 561
 562         inst->klass = klass = mono_class_from_mono_type (type);
 563         if (type->byref) {
 564                 inst->type = STACK_MP;
 565                 return;
 566         }
 567
 568 handle_enum:
 569         switch (type->type) {
 570         case MONO_TYPE_VOID:
 571                 inst->type = STACK_INV;
 572                 return;
 573         case MONO_TYPE_I1:
 574         case MONO_TYPE_U1:
 575         case MONO_TYPE_BOOLEAN:
 576         case MONO_TYPE_I2:
 577         case MONO_TYPE_U2:
 578         case MONO_TYPE_CHAR:
 579         case MONO_TYPE_I4:
 580         case MONO_TYPE_U4:
 581                 inst->type = STACK_I4;
 582                 return;
 583         case MONO_TYPE_I:
 584         case MONO_TYPE_U:
 585         case MONO_TYPE_PTR:
 586         case MONO_TYPE_FNPTR:
 587                 inst->type = STACK_PTR;
 588                 return;
 589         case MONO_TYPE_CLASS:
 590         case MONO_TYPE_STRING:
 591         case MONO_TYPE_OBJECT:
 592         case MONO_TYPE_SZARRAY:
 593         case MONO_TYPE_ARRAY:
 594                 inst->type = STACK_OBJ;
 595                 return;
 596         case MONO_TYPE_I8:
 597         case MONO_TYPE_U8:
 598                 inst->type = STACK_I8;
 599                 return;
 600         case MONO_TYPE_R4:
 601         case MONO_TYPE_R8:
 602                 inst->type = STACK_R8;
 603                 return;
 604         case MONO_TYPE_VALUETYPE:
 605                 if (type->data.klass->enumtype) {
 606                         type = mono_class_enum_basetype (type->data.klass);
 607                         goto handle_enum;
 608                 } else {
 609                         inst->klass = klass;
 610                         inst->type = STACK_VTYPE;
 611                         return;
 612                 }
 613         case MONO_TYPE_TYPEDBYREF:
 614                 inst->klass = mono_defaults.typed_reference_class;
 615                 inst->type = STACK_VTYPE;
 616                 return;
 617         case MONO_TYPE_GENERICINST:
 618                 type = &type->data.generic_class->container_class->byval_arg;
 619                 goto handle_enum;
 620         case MONO_TYPE_VAR :
 621         case MONO_TYPE_MVAR :
 622                 /* FIXME: all the arguments must be references for now,
 623                  * later look inside cfg and see if the arg num is
 624                  * really a reference
 625                  */
 626                 g_assert (cfg->generic_sharing_context);
 627                 inst->type = STACK_OBJ;
 628                 return;
 629         default:
 630                 g_error ("unknown type 0x%02x in eval stack type", type->type);
 631         }
 632 }
 633
 634 /*
 635  * The following tables are used to quickly validate the IL code in type_from_op ().
 636  */
 637 static const char
 638 bin_num_table [STACK_MAX] [STACK_MAX] = {
 639         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 640         {STACK_INV, STACK_I4,  STACK_INV, STACK_PTR, STACK_INV, STACK_MP,  STACK_INV, STACK_INV},
 641         {STACK_INV, STACK_INV, STACK_I8,  STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 642         {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_MP,  STACK_INV, STACK_INV},
 643         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_R8,  STACK_INV, STACK_INV, STACK_INV},
 644         {STACK_INV, STACK_MP,  STACK_INV, STACK_MP,  STACK_INV, STACK_PTR, STACK_INV, STACK_INV},
 645         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 646         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
 647 };
 648
 649 static const char
 650 neg_table [] = {
 651         STACK_INV, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_INV, STACK_INV, STACK_INV
 652 };
 653
 654 /* reduce the size of this table */
 655 static const char
 656 bin_int_table [STACK_MAX] [STACK_MAX] = {
 657         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 658         {STACK_INV, STACK_I4,  STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 659         {STACK_INV, STACK_INV, STACK_I8,  STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 660         {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 661         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 662         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 663         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 664         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
 665 };
 666
 667 static const char
 668 bin_comp_table [STACK_MAX] [STACK_MAX] = {
 669 /*      Inv i  L  p  F  &  O  vt */
 670         {0},
 671         {0, 1, 0, 1, 0, 0, 0, 0}, /* i, int32 */
 672         {0, 0, 1, 0, 0, 0, 0, 0}, /* L, int64 */
 673         {0, 1, 0, 1, 0, 2, 4, 0}, /* p, ptr */
 674         {0, 0, 0, 0, 1, 0, 0, 0}, /* F, R8 */
 675         {0, 0, 0, 2, 0, 1, 0, 0}, /* &, managed pointer */
 676         {0, 0, 0, 4, 0, 0, 3, 0}, /* O, reference */
 677         {0, 0, 0, 0, 0, 0, 0, 0}, /* vt value type */
 678 };
 679
 680 /* reduce the size of this table */
 681 static const char
 682 shift_table [STACK_MAX] [STACK_MAX] = {
 683         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 684         {STACK_INV, STACK_I4,  STACK_INV, STACK_I4,  STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 685         {STACK_INV, STACK_I8,  STACK_INV, STACK_I8,  STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 686         {STACK_INV, STACK_PTR, STACK_INV, STACK_PTR, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 687         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 688         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 689         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV},
 690         {STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV, STACK_INV}
 691 };
 692
 693 /*
 694  * Tables to map from the non-specific opcode to the matching
 695  * type-specific opcode.
 696  */
 697 /* handles from CEE_ADD to CEE_SHR_UN (CEE_REM_UN for floats) */
 698 static const guint16
 699 binops_op_map [STACK_MAX] = {
 700         0, OP_IADD-CEE_ADD, OP_LADD-CEE_ADD, OP_PADD-CEE_ADD, OP_FADD-CEE_ADD, OP_PADD-CEE_ADD
 701 };
 702
 703 /* handles from CEE_NEG to CEE_CONV_U8 */
 704 static const guint16
 705 unops_op_map [STACK_MAX] = {
 706         0, OP_INEG-CEE_NEG, OP_LNEG-CEE_NEG, OP_PNEG-CEE_NEG, OP_FNEG-CEE_NEG, OP_PNEG-CEE_NEG
 707 };
 708
 709 /* handles from CEE_CONV_U2 to CEE_SUB_OVF_UN */
 710 static const guint16
 711 ovfops_op_map [STACK_MAX] = {
 712         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
 713 };
 714
 715 /* handles from CEE_CONV_OVF_I1_UN to CEE_CONV_OVF_U_UN */
 716 static const guint16
 717 ovf2ops_op_map [STACK_MAX] = {
 718         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
 719 };
 720
 721 /* handles from CEE_CONV_OVF_I1 to CEE_CONV_OVF_U8 */
 722 static const guint16
 723 ovf3ops_op_map [STACK_MAX] = {
 724         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
 725 };
 726
 727 /* handles from CEE_BEQ to CEE_BLT_UN */
 728 static const guint16
 729 beqops_op_map [STACK_MAX] = {
 730         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
 731 };
 732
 733 /* handles from CEE_CEQ to CEE_CLT_UN */
 734 static const guint16
 735 ceqops_op_map [STACK_MAX] = {
 736         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
 737 };
 738
 739 /*
 740  * Sets ins->type (the type on the eval stack) according to the
 741  * type of the opcode and the arguments to it.
 742  * Invalid IL code is marked by setting ins->type to the invalid value STACK_INV.
 743  *
 744  * FIXME: this function sets ins->type unconditionally in some cases, but
 745  * it should set it to invalid for some types (a conv.x on an object)
 746  */
 747 static void
 748 type_from_op (MonoInst *ins, MonoInst *src1, MonoInst *src2) {
 749
 750         switch (ins->opcode) {
 751         /* binops */
 752         case CEE_ADD:
 753         case CEE_SUB:
 754         case CEE_MUL:
 755         case CEE_DIV:
 756         case CEE_REM:
 757                 /* FIXME: check unverifiable args for STACK_MP */
 758                 ins->type = bin_num_table [src1->type] [src2->type];
 759                 ins->opcode += binops_op_map [ins->type];
 760                 break;
 761         case CEE_DIV_UN:
 762         case CEE_REM_UN:
 763         case CEE_AND:
 764         case CEE_OR:
 765         case CEE_XOR:
 766                 ins->type = bin_int_table [src1->type] [src2->type];
 767                 ins->opcode += binops_op_map [ins->type];
 768                 break;
 769         case CEE_SHL:
 770         case CEE_SHR:
 771         case CEE_SHR_UN:
 772                 ins->type = shift_table [src1->type] [src2->type];
 773                 ins->opcode += binops_op_map [ins->type];
 774                 break;
 775         case OP_COMPARE:
 776         case OP_LCOMPARE:
 777         case OP_ICOMPARE:
 778                 ins->type = bin_comp_table [src1->type] [src2->type] ? STACK_I4: STACK_INV;
 779                 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
 780                         ins->opcode = OP_LCOMPARE;
 781                 else if (src1->type == STACK_R8)
 782                         ins->opcode = OP_FCOMPARE;
 783                 else
 784                         ins->opcode = OP_ICOMPARE;
 785                 break;
 786         case OP_ICOMPARE_IMM:
 787                 ins->type = bin_comp_table [src1->type] [src1->type] ? STACK_I4 : STACK_INV;
 788                 if ((src1->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((src1->type == STACK_PTR) || (src1->type == STACK_OBJ) || (src1->type == STACK_MP))))
 789                         ins->opcode = OP_LCOMPARE_IMM;
 790                 break;
 791         case CEE_BEQ:
 792         case CEE_BGE:
 793         case CEE_BGT:
 794         case CEE_BLE:
 795         case CEE_BLT:
 796         case CEE_BNE_UN:
 797         case CEE_BGE_UN:
 798         case CEE_BGT_UN:
 799         case CEE_BLE_UN:
 800         case CEE_BLT_UN:
 801                 ins->opcode += beqops_op_map [src1->type];
 802                 break;
 803         case OP_CEQ:
 804                 ins->type = bin_comp_table [src1->type] [src2->type] ? STACK_I4: STACK_INV;
 805                 ins->opcode += ceqops_op_map [src1->type];
 806                 break;
 807         case OP_CGT:
 808         case OP_CGT_UN:
 809         case OP_CLT:
 810         case OP_CLT_UN:
 811                 ins->type = (bin_comp_table [src1->type] [src2->type] & 1) ? STACK_I4: STACK_INV;
 812                 ins->opcode += ceqops_op_map [src1->type];
 813                 break;
 814         /* unops */
 815         case CEE_NEG:
 816                 ins->type = neg_table [src1->type];
 817                 ins->opcode += unops_op_map [ins->type];
 818                 break;
 819         case CEE_NOT:
 820                 if (src1->type >= STACK_I4 && src1->type <= STACK_PTR)
 821                         ins->type = src1->type;
 822                 else
 823                         ins->type = STACK_INV;
 824                 ins->opcode += unops_op_map [ins->type];
 825                 break;
 826         case CEE_CONV_I1:
 827         case CEE_CONV_I2:
 828         case CEE_CONV_I4:
 829         case CEE_CONV_U4:
 830                 ins->type = STACK_I4;
 831                 ins->opcode += unops_op_map [src1->type];
 832                 break;
 833         case CEE_CONV_R_UN:
 834                 ins->type = STACK_R8;
 835                 switch (src1->type) {
 836                 case STACK_I4:
 837                 case STACK_PTR:
 838                         ins->opcode = OP_ICONV_TO_R_UN;
 839                         break;
 840                 case STACK_I8:
 841                         ins->opcode = OP_LCONV_TO_R_UN;
 842                         break;
 843                 }
 844                 break;
 845         case CEE_CONV_OVF_I1:
 846         case CEE_CONV_OVF_U1:
 847         case CEE_CONV_OVF_I2:
 848         case CEE_CONV_OVF_U2:
 849         case CEE_CONV_OVF_I4:
 850         case CEE_CONV_OVF_U4:
 851                 ins->type = STACK_I4;
 852                 ins->opcode += ovf3ops_op_map [src1->type];
 853                 break;
 854         case CEE_CONV_OVF_I_UN:
 855         case CEE_CONV_OVF_U_UN:
 856                 ins->type = STACK_PTR;
 857                 ins->opcode += ovf2ops_op_map [src1->type];
 858                 break;
 859         case CEE_CONV_OVF_I1_UN:
 860         case CEE_CONV_OVF_I2_UN:
 861         case CEE_CONV_OVF_I4_UN:
 862         case CEE_CONV_OVF_U1_UN:
 863         case CEE_CONV_OVF_U2_UN:
 864         case CEE_CONV_OVF_U4_UN:
 865                 ins->type = STACK_I4;
 866                 ins->opcode += ovf2ops_op_map [src1->type];
 867                 break;
 868         case CEE_CONV_U:
 869                 ins->type = STACK_PTR;
 870                 switch (src1->type) {
 871                 case STACK_I4:
 872                         ins->opcode = OP_ICONV_TO_U;
 873                         break;
 874                 case STACK_PTR:
 875                 case STACK_MP:
 876 #if SIZEOF_REGISTER == 8
 877                         ins->opcode = OP_LCONV_TO_U;
 878 #else
 879                         ins->opcode = OP_MOVE;
 880 #endif
 881                         break;
 882                 case STACK_I8:
 883                         ins->opcode = OP_LCONV_TO_U;
 884                         break;
 885                 case STACK_R8:
 886                         ins->opcode = OP_FCONV_TO_U;
 887                         break;
 888                 }
 889                 break;
 890         case CEE_CONV_I8:
 891         case CEE_CONV_U8:
 892                 ins->type = STACK_I8;
 893                 ins->opcode += unops_op_map [src1->type];
 894                 break;
 895         case CEE_CONV_OVF_I8:
 896         case CEE_CONV_OVF_U8:
 897                 ins->type = STACK_I8;
 898                 ins->opcode += ovf3ops_op_map [src1->type];
 899                 break;
 900         case CEE_CONV_OVF_U8_UN:
 901         case CEE_CONV_OVF_I8_UN:
 902                 ins->type = STACK_I8;
 903                 ins->opcode += ovf2ops_op_map [src1->type];
 904                 break;
 905         case CEE_CONV_R4:
 906         case CEE_CONV_R8:
 907                 ins->type = STACK_R8;
 908                 ins->opcode += unops_op_map [src1->type];
 909                 break;
 910         case OP_CKFINITE:
 911                 ins->type = STACK_R8;
 912                 break;
 913         case CEE_CONV_U2:
 914         case CEE_CONV_U1:
 915                 ins->type = STACK_I4;
 916                 ins->opcode += ovfops_op_map [src1->type];
 917                 break;
 918         case CEE_CONV_I:
 919         case CEE_CONV_OVF_I:
 920         case CEE_CONV_OVF_U:
 921                 ins->type = STACK_PTR;
 922                 ins->opcode += ovfops_op_map [src1->type];
 923                 break;
 924         case CEE_ADD_OVF:
 925         case CEE_ADD_OVF_UN:
 926         case CEE_MUL_OVF:
 927         case CEE_MUL_OVF_UN:
 928         case CEE_SUB_OVF:
 929         case CEE_SUB_OVF_UN:
 930                 ins->type = bin_num_table [src1->type] [src2->type];
 931                 ins->opcode += ovfops_op_map [src1->type];
 932                 if (ins->type == STACK_R8)
 933                         ins->type = STACK_INV;
 934                 break;
 935         case OP_LOAD_MEMBASE:
 936                 ins->type = STACK_PTR;
 937                 break;
 938         case OP_LOADI1_MEMBASE:
 939         case OP_LOADU1_MEMBASE:
 940         case OP_LOADI2_MEMBASE:
 941         case OP_LOADU2_MEMBASE:
 942         case OP_LOADI4_MEMBASE:
 943         case OP_LOADU4_MEMBASE:
 944                 ins->type = STACK_PTR;
 945                 break;
 946         case OP_LOADI8_MEMBASE:
 947                 ins->type = STACK_I8;
 948                 break;
 949         case OP_LOADR4_MEMBASE:
 950         case OP_LOADR8_MEMBASE:
 951                 ins->type = STACK_R8;
 952                 break;
 953         default:
 954                 g_error ("opcode 0x%04x not handled in type from op", ins->opcode);
 955                 break;
 956         }
 957
 958         if (ins->type == STACK_MP)
 959                 ins->klass = mono_defaults.object_class;
 960 }
 961
 962 static const char
 963 ldind_type [] = {
 964         STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
 965 };
 966
 967 #if 0
 968
 969 static const char
 970 param_table [STACK_MAX] [STACK_MAX] = {
 971         {0},
 972 };
 973
 974 static int
 975 check_values_to_signature (MonoInst *args, MonoType *this, MonoMethodSignature *sig) {
 976         int i;
 977
 978         if (sig->hasthis) {
 979                 switch (args->type) {
 980                 case STACK_I4:
 981                 case STACK_I8:
 982                 case STACK_R8:
 983                 case STACK_VTYPE:
 984                 case STACK_INV:
 985                         return 0;
 986                 }
 987                 args++;
 988         }
 989         for (i = 0; i < sig->param_count; ++i) {
 990                 switch (args [i].type) {
 991                 case STACK_INV:
 992                         return 0;
 993                 case STACK_MP:
 994                         if (!sig->params [i]->byref)
 995                                 return 0;
 996                         continue;
 997                 case STACK_OBJ:
 998                         if (sig->params [i]->byref)
 999                                 return 0;
1000                         switch (sig->params [i]->type) {
1001                         case MONO_TYPE_CLASS:
1002                         case MONO_TYPE_STRING:
1003                         case MONO_TYPE_OBJECT:
1004                         case MONO_TYPE_SZARRAY:
1005                         case MONO_TYPE_ARRAY:
1006                                 break;
1007                         default:
1008                                 return 0;
1009                         }
1010                         continue;
1011                 case STACK_R8:
1012                         if (sig->params [i]->byref)
1013                                 return 0;
1014                         if (sig->params [i]->type != MONO_TYPE_R4 && sig->params [i]->type != MONO_TYPE_R8)
1015                                 return 0;
1016                         continue;
1017                 case STACK_PTR:
1018                 case STACK_I4:
1019                 case STACK_I8:
1020                 case STACK_VTYPE:
1021                         break;
1022                 }
1023                 /*if (!param_table [args [i].type] [sig->params [i]->type])
1024                         return 0;*/
1025         }
1026         return 1;
1027 }
1028 #endif
1029
1030 /*
1031  * When we need a pointer to the current domain many times in a method, we
1032  * call mono_domain_get() once and we store the result in a local variable.
1033  * This function returns the variable that represents the MonoDomain*.
1034  */
1035 inline static MonoInst *
1036 mono_get_domainvar (MonoCompile *cfg)
1037 {
1038         if (!cfg->domainvar)
1039                 cfg->domainvar = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1040         return cfg->domainvar;
1041 }
1042
1043 /*
1044  * The got_var contains the address of the Global Offset Table when AOT
1045  * compiling.
1046  */
1047 MonoInst *
1048 mono_get_got_var (MonoCompile *cfg)
1049 {
1050 #ifdef MONO_ARCH_NEED_GOT_VAR
1051         if (!cfg->compile_aot)
1052                 return NULL;
1053         if (!cfg->got_var) {
1054                 cfg->got_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1055         }
1056         return cfg->got_var;
1057 #else
1058         return NULL;
1059 #endif
1060 }
1061
1062 static MonoInst *
1063 mono_get_vtable_var (MonoCompile *cfg)
1064 {
1065         g_assert (cfg->generic_sharing_context);
1066
1067         if (!cfg->rgctx_var) {
1068                 cfg->rgctx_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1069                 /* force the var to be stack allocated */
1070                 cfg->rgctx_var->flags |= MONO_INST_INDIRECT;
1071         }
1072
1073         return cfg->rgctx_var;
1074 }
1075
1076 static MonoType*
1077 type_from_stack_type (MonoInst *ins) {
1078         switch (ins->type) {
1079         case STACK_I4: return &mono_defaults.int32_class->byval_arg;
1080         case STACK_I8: return &mono_defaults.int64_class->byval_arg;
1081         case STACK_PTR: return &mono_defaults.int_class->byval_arg;
1082         case STACK_R8: return &mono_defaults.double_class->byval_arg;
1083         case STACK_MP:
1084                 return &ins->klass->this_arg;
1085         case STACK_OBJ: return &mono_defaults.object_class->byval_arg;
1086         case STACK_VTYPE: return &ins->klass->byval_arg;
1087         default:
1088                 g_error ("stack type %d to monotype not handled\n", ins->type);
1089         }
1090         return NULL;
1091 }
1092
1093 static G_GNUC_UNUSED int
1094 type_to_stack_type (MonoType *t)
1095 {
1096         t = mono_type_get_underlying_type (t);
1097         switch (t->type) {
1098         case MONO_TYPE_I1:
1099         case MONO_TYPE_U1:
1100         case MONO_TYPE_BOOLEAN:
1101         case MONO_TYPE_I2:
1102         case MONO_TYPE_U2:
1103         case MONO_TYPE_CHAR:
1104         case MONO_TYPE_I4:
1105         case MONO_TYPE_U4:
1106                 return STACK_I4;
1107         case MONO_TYPE_I:
1108         case MONO_TYPE_U:
1109         case MONO_TYPE_PTR:
1110         case MONO_TYPE_FNPTR:
1111                 return STACK_PTR;
1112         case MONO_TYPE_CLASS:
1113         case MONO_TYPE_STRING:
1114         case MONO_TYPE_OBJECT:
1115         case MONO_TYPE_SZARRAY:
1116         case MONO_TYPE_ARRAY:
1117                 return STACK_OBJ;
1118         case MONO_TYPE_I8:
1119         case MONO_TYPE_U8:
1120                 return STACK_I8;
1121         case MONO_TYPE_R4:
1122         case MONO_TYPE_R8:
1123                 return STACK_R8;
1124         case MONO_TYPE_VALUETYPE:
1125         case MONO_TYPE_TYPEDBYREF:
1126                 return STACK_VTYPE;
1127         case MONO_TYPE_GENERICINST:
1128                 if (mono_type_generic_inst_is_valuetype (t))
1129                         return STACK_VTYPE;
1130                 else
1131                         return STACK_OBJ;
1132                 break;
1133         default:
1134                 g_assert_not_reached ();
1135         }
1136
1137         return -1;
1138 }
1139
1140 static MonoClass*
1141 array_access_to_klass (int opcode)
1142 {
1143         switch (opcode) {
1144         case CEE_LDELEM_U1:
1145                 return mono_defaults.byte_class;
1146         case CEE_LDELEM_U2:
1147                 return mono_defaults.uint16_class;
1148         case CEE_LDELEM_I:
1149         case CEE_STELEM_I:
1150                 return mono_defaults.int_class;
1151         case CEE_LDELEM_I1:
1152         case CEE_STELEM_I1:
1153                 return mono_defaults.sbyte_class;
1154         case CEE_LDELEM_I2:
1155         case CEE_STELEM_I2:
1156                 return mono_defaults.int16_class;
1157         case CEE_LDELEM_I4:
1158         case CEE_STELEM_I4:
1159                 return mono_defaults.int32_class;
1160         case CEE_LDELEM_U4:
1161                 return mono_defaults.uint32_class;
1162         case CEE_LDELEM_I8:
1163         case CEE_STELEM_I8:
1164                 return mono_defaults.int64_class;
1165         case CEE_LDELEM_R4:
1166         case CEE_STELEM_R4:
1167                 return mono_defaults.single_class;
1168         case CEE_LDELEM_R8:
1169         case CEE_STELEM_R8:
1170                 return mono_defaults.double_class;
1171         case CEE_LDELEM_REF:
1172         case CEE_STELEM_REF:
1173                 return mono_defaults.object_class;
1174         default:
1175                 g_assert_not_reached ();
1176         }
1177         return NULL;
1178 }
1179
1180 /*
1181  * We try to share variables when possible
1182  */
1183 static MonoInst *
1184 mono_compile_get_interface_var (MonoCompile *cfg, int slot, MonoInst *ins)
1185 {
1186         MonoInst *res;
1187         int pos, vnum;
1188
1189         /* inlining can result in deeper stacks */
1190         if (slot >= cfg->header->max_stack)
1191                 return mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
1192
1193         pos = ins->type - 1 + slot * STACK_MAX;
1194
1195         switch (ins->type) {
1196         case STACK_I4:
1197         case STACK_I8:
1198         case STACK_R8:
1199         case STACK_PTR:
1200         case STACK_MP:
1201         case STACK_OBJ:
1202                 if ((vnum = cfg->intvars [pos]))
1203                         return cfg->varinfo [vnum];
1204                 res = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
1205                 cfg->intvars [pos] = res->inst_c0;
1206                 break;
1207         default:
1208                 res = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
1209         }
1210         return res;
1211 }
1212
1213 static void
1214 mono_save_token_info (MonoCompile *cfg, MonoImage *image, guint32 token, gpointer key)
1215 {
1216         /*
1217          * Don't use this if a generic_context is set, since that means AOT can't
1218          * look up the method using just the image+token.
1219          * table == 0 means this is a reference made from a wrapper.
1220          */
1221         if (cfg->compile_aot && !cfg->generic_context && (mono_metadata_token_table (token) > 0)) {
1222                 MonoJumpInfoToken *jump_info_token = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoJumpInfoToken));
1223                 jump_info_token->image = image;
1224                 jump_info_token->token = token;
1225                 g_hash_table_insert (cfg->token_info_hash, key, jump_info_token);
1226         }
1227 }
1228
1229 /*
1230  * This function is called to handle items that are left on the evaluation stack
1231  * at basic block boundaries. What happens is that we save the values to local variables
1232  * and we reload them later when first entering the target basic block (with the
1233  * handle_loaded_temps () function).
1234  * A single joint point will use the same variables (stored in the array bb->out_stack or
1235  * bb->in_stack, if the basic block is before or after the joint point).
1236  *
1237  * This function needs to be called _before_ emitting the last instruction of
1238  * the bb (i.e. before emitting a branch).
1239  * If the stack merge fails at a join point, cfg->unverifiable is set.
1240  */
1241 static void
1242 handle_stack_args (MonoCompile *cfg, MonoInst **sp, int count)
1243 {
1244         int i, bindex;
1245         MonoBasicBlock *bb = cfg->cbb;
1246         MonoBasicBlock *outb;
1247         MonoInst *inst, **locals;
1248         gboolean found;
1249
1250         if (!count)
1251                 return;
1252         if (cfg->verbose_level > 3)
1253                 printf ("%d item(s) on exit from B%d\n", count, bb->block_num);
1254         if (!bb->out_scount) {
1255                 bb->out_scount = count;
1256                 //printf ("bblock %d has out:", bb->block_num);
1257                 found = FALSE;
1258                 for (i = 0; i < bb->out_count; ++i) {
1259                         outb = bb->out_bb [i];
1260                         /* exception handlers are linked, but they should not be considered for stack args */
1261                         if (outb->flags & BB_EXCEPTION_HANDLER)
1262                                 continue;
1263                         //printf (" %d", outb->block_num);
1264                         if (outb->in_stack) {
1265                                 found = TRUE;
1266                                 bb->out_stack = outb->in_stack;
1267                                 break;
1268                         }
1269                 }
1270                 //printf ("\n");
1271                 if (!found) {
1272                         bb->out_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * count);
1273                         for (i = 0; i < count; ++i) {
1274                                 /*
1275                                  * try to reuse temps already allocated for this purpouse, if they occupy the same
1276                                  * stack slot and if they are of the same type.
1277                                  * This won't cause conflicts since if 'local' is used to
1278                                  * store one of the values in the in_stack of a bblock, then
1279                                  * the same variable will be used for the same outgoing stack
1280                                  * slot as well.
1281                                  * This doesn't work when inlining methods, since the bblocks
1282                                  * in the inlined methods do not inherit their in_stack from
1283                                  * the bblock they are inlined to. See bug #58863 for an
1284                                  * example.
1285                                  */
1286                                 if (cfg->inlined_method)
1287                                         bb->out_stack [i] = mono_compile_create_var (cfg, type_from_stack_type (sp [i]), OP_LOCAL);
1288                                 else
1289                                         bb->out_stack [i] = mono_compile_get_interface_var (cfg, i, sp [i]);
1290                         }
1291                 }
1292         }
1293
1294         for (i = 0; i < bb->out_count; ++i) {
1295                 outb = bb->out_bb [i];
1296                 /* exception handlers are linked, but they should not be considered for stack args */
1297                 if (outb->flags & BB_EXCEPTION_HANDLER)
1298                         continue;
1299                 if (outb->in_scount) {
1300                         if (outb->in_scount != bb->out_scount) {
1301                                 cfg->unverifiable = TRUE;
1302                                 return;
1303                         }
1304                         continue; /* check they are the same locals */
1305                 }
1306                 outb->in_scount = count;
1307                 outb->in_stack = bb->out_stack;
1308         }
1309
1310         locals = bb->out_stack;
1311         cfg->cbb = bb;
1312         for (i = 0; i < count; ++i) {
1313                 EMIT_NEW_TEMPSTORE (cfg, inst, locals [i]->inst_c0, sp [i]);
1314                 inst->cil_code = sp [i]->cil_code;
1315                 sp [i] = locals [i];
1316                 if (cfg->verbose_level > 3)
1317                         printf ("storing %d to temp %d\n", i, (int)locals [i]->inst_c0);
1318         }
1319
1320         /*
1321          * It is possible that the out bblocks already have in_stack assigned, and
1322          * the in_stacks differ. In this case, we will store to all the different
1323          * in_stacks.
1324          */
1325
1326         found = TRUE;
1327         bindex = 0;
1328         while (found) {
1329                 /* Find a bblock which has a different in_stack */
1330                 found = FALSE;
1331                 while (bindex < bb->out_count) {
1332                         outb = bb->out_bb [bindex];
1333                         /* exception handlers are linked, but they should not be considered for stack args */
1334                         if (outb->flags & BB_EXCEPTION_HANDLER) {
1335                                 bindex++;
1336                                 continue;
1337                         }
1338                         if (outb->in_stack != locals) {
1339                                 for (i = 0; i < count; ++i) {
1340                                         EMIT_NEW_TEMPSTORE (cfg, inst, outb->in_stack [i]->inst_c0, sp [i]);
1341                                         inst->cil_code = sp [i]->cil_code;
1342                                         sp [i] = locals [i];
1343                                         if (cfg->verbose_level > 3)
1344                                                 printf ("storing %d to temp %d\n", i, (int)outb->in_stack [i]->inst_c0);
1345                                 }
1346                                 locals = outb->in_stack;
1347                                 found = TRUE;
1348                                 break;
1349                         }
1350                         bindex ++;
1351                 }
1352         }
1353 }
1354
1355 /* Emit code which loads interface_offsets [klass->interface_id]
1356  * The array is stored in memory before vtable.
1357 */
1358 static void
1359 mini_emit_load_intf_reg_vtable (MonoCompile *cfg, int intf_reg, int vtable_reg, MonoClass *klass)
1360 {
1361         if (cfg->compile_aot) {
1362                 int ioffset_reg = alloc_preg (cfg);
1363                 int iid_reg = alloc_preg (cfg);
1364
1365                 MONO_EMIT_NEW_AOTCONST (cfg, iid_reg, klass, MONO_PATCH_INFO_ADJUSTED_IID);
1366                 MONO_EMIT_NEW_BIALU (cfg, OP_PADD, ioffset_reg, iid_reg, vtable_reg);
1367                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, ioffset_reg, 0);
1368         }
1369         else {
1370                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1371         }
1372 }
1373
1374 static void
1375 mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_reg, int offset, MonoClass *klass)
1376 {
1377         int ibitmap_reg = alloc_preg (cfg);
1378 #ifdef COMPRESSED_INTERFACE_BITMAP
1379         MonoInst *args [2];
1380         MonoInst *res, *ins;
1381         NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, ibitmap_reg, base_reg, offset);
1382         MONO_ADD_INS (cfg->cbb, ins);
1383         args [0] = ins;
1384         if (cfg->compile_aot)
1385                 EMIT_NEW_AOTCONST (cfg, args [1], MONO_PATCH_INFO_IID, klass);
1386         else
1387                 EMIT_NEW_ICONST (cfg, args [1], klass->interface_id);
1388         res = mono_emit_jit_icall (cfg, mono_class_interface_match, args);
1389         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, intf_bit_reg, res->dreg);
1390 #else
1391         int ibitmap_byte_reg = alloc_preg (cfg);
1392
1393         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, base_reg, offset);
1394
1395         if (cfg->compile_aot) {
1396                 int iid_reg = alloc_preg (cfg);
1397                 int shifted_iid_reg = alloc_preg (cfg);
1398                 int ibitmap_byte_address_reg = alloc_preg (cfg);
1399                 int masked_iid_reg = alloc_preg (cfg);
1400                 int iid_one_bit_reg = alloc_preg (cfg);
1401                 int iid_bit_reg = alloc_preg (cfg);
1402                 MONO_EMIT_NEW_AOTCONST (cfg, iid_reg, klass, MONO_PATCH_INFO_IID);
1403                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_IMM, shifted_iid_reg, iid_reg, 3);
1404                 MONO_EMIT_NEW_BIALU (cfg, OP_PADD, ibitmap_byte_address_reg, ibitmap_reg, shifted_iid_reg);
1405                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1406                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, masked_iid_reg, iid_reg, 7);
1407                 MONO_EMIT_NEW_ICONST (cfg, iid_one_bit_reg, 1);
1408                 MONO_EMIT_NEW_BIALU (cfg, OP_ISHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg);
1409                 MONO_EMIT_NEW_BIALU (cfg, OP_IAND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg);
1410         } else {
1411                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1412                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1413         }
1414 #endif
1415 }
1416
1417 /*
1418  * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1419  * stored in "klass_reg" implements the interface "klass".
1420  */
1421 static void
1422 mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass)
1423 {
1424         mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap), klass);
1425 }
1426
1427 /*
1428  * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1429  * stored in "vtable_reg" implements the interface "klass".
1430  */
1431 static void
1432 mini_emit_load_intf_bit_reg_vtable (MonoCompile *cfg, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1433 {
1434         mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap), klass);
1435 }
1436
1437 /*
1438  * Emit code which checks whenever the interface id of @klass is smaller than
1439  * than the value given by max_iid_reg.
1440 */
1441 static void
1442 mini_emit_max_iid_check (MonoCompile *cfg, int max_iid_reg, MonoClass *klass,
1443                                                  MonoBasicBlock *false_target)
1444 {
1445         if (cfg->compile_aot) {
1446                 int iid_reg = alloc_preg (cfg);
1447                 MONO_EMIT_NEW_AOTCONST (cfg, iid_reg, klass, MONO_PATCH_INFO_IID);
1448                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, max_iid_reg, iid_reg);
1449         }
1450         else
1451                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, max_iid_reg, klass->interface_id);
1452         if (false_target)
1453                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target);
1454         else
1455                 MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "InvalidCastException");
1456 }
1457
1458 /* Same as above, but obtains max_iid from a vtable */
1459 static void
1460 mini_emit_max_iid_check_vtable (MonoCompile *cfg, int vtable_reg, MonoClass *klass,
1461                                                                  MonoBasicBlock *false_target)
1462 {
1463         int max_iid_reg = alloc_preg (cfg);
1464
1465         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1466         mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
1467 }
1468
1469 /* Same as above, but obtains max_iid from a klass */
1470 static void
1471 mini_emit_max_iid_check_class (MonoCompile *cfg, int klass_reg, MonoClass *klass,
1472                                                                  MonoBasicBlock *false_target)
1473 {
1474         int max_iid_reg = alloc_preg (cfg);
1475
1476         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1477         mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
1478 }
1479
1480 static void
1481 mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_ins, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1482 {
1483         int idepth_reg = alloc_preg (cfg);
1484         int stypes_reg = alloc_preg (cfg);
1485         int stype = alloc_preg (cfg);
1486
1487         if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1488                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1489                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
1490                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target);
1491         }
1492         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1493         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1494         if (klass_ins) {
1495                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, stype, klass_ins->dreg);
1496         } else if (cfg->compile_aot) {
1497                 int const_reg = alloc_preg (cfg);
1498                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
1499                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, stype, const_reg);
1500         } else {
1501                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, stype, klass);
1502         }
1503         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, true_target);
1504 }
1505
1506 static void
1507 mini_emit_isninst_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1508 {
1509         mini_emit_isninst_cast_inst (cfg, klass_reg, klass, NULL, false_target, true_target);
1510 }
1511
1512 static void
1513 mini_emit_iface_cast (MonoCompile *cfg, int vtable_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1514 {
1515         int intf_reg = alloc_preg (cfg);
1516
1517         mini_emit_max_iid_check_vtable (cfg, vtable_reg, klass, false_target);
1518         mini_emit_load_intf_bit_reg_vtable (cfg, intf_reg, vtable_reg, klass);
1519         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, intf_reg, 0);
1520         if (true_target)
1521                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, true_target);
1522         else
1523                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "InvalidCastException");
1524 }
1525
1526 /*
1527  * Variant of the above that takes a register to the class, not the vtable.
1528  */
1529 static void
1530 mini_emit_iface_class_cast (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoBasicBlock *false_target, MonoBasicBlock *true_target)
1531 {
1532         int intf_bit_reg = alloc_preg (cfg);
1533
1534         mini_emit_max_iid_check_class (cfg, klass_reg, klass, false_target);
1535         mini_emit_load_intf_bit_reg_class (cfg, intf_bit_reg, klass_reg, klass);
1536         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, intf_bit_reg, 0);
1537         if (true_target)
1538                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, true_target);
1539         else
1540                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "InvalidCastException");
1541 }
1542
1543 static inline void
1544 mini_emit_class_check_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, MonoInst *klass_inst)
1545 {
1546         if (klass_inst) {
1547                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, klass_inst->dreg);
1548         } else if (cfg->compile_aot) {
1549                 int const_reg = alloc_preg (cfg);
1550                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
1551                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, const_reg);
1552         } else {
1553                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
1554         }
1555         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
1556 }
1557
1558 static inline void
1559 mini_emit_class_check (MonoCompile *cfg, int klass_reg, MonoClass *klass)
1560 {
1561         return mini_emit_class_check_inst (cfg, klass_reg, klass, NULL);
1562 }
1563
1564 static inline void
1565 mini_emit_class_check_branch (MonoCompile *cfg, int klass_reg, MonoClass *klass, int branch_op, MonoBasicBlock *target)
1566 {
1567         if (cfg->compile_aot) {
1568                 int const_reg = alloc_preg (cfg);
1569                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
1570                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, const_reg);
1571         } else {
1572                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
1573         }
1574         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, branch_op, target);
1575 }
1576
1577 static void
1578 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null);
1579
1580 static void
1581 mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null)
1582 {
1583         if (klass->rank) {
1584                 int rank_reg = alloc_preg (cfg);
1585                 int eclass_reg = alloc_preg (cfg);
1586
1587                 g_assert (!klass_inst);
1588                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1589                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
1590                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
1591                 //              MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1592                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1593                 if (klass->cast_class == mono_defaults.object_class) {
1594                         int parent_reg = alloc_preg (cfg);
1595                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
1596                         mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null);
1597                         mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
1598                 } else if (klass->cast_class == mono_defaults.enum_class->parent) {
1599                         mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null);
1600                         mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
1601                 } else if (klass->cast_class == mono_defaults.enum_class) {
1602                         mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class);
1603                 } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
1604                         mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, NULL, NULL);
1605                 } else {
1606                         // Pass -1 as obj_reg to skip the check below for arrays of arrays
1607                         mini_emit_castclass (cfg, -1, eclass_reg, klass->cast_class, object_is_null);
1608                 }
1609
1610                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY) && (obj_reg != -1)) {
1611                         /* Check that the object is a vector too */
1612                         int bounds_reg = alloc_preg (cfg);
1613                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
1614                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, bounds_reg, 0);
1615                         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
1616                 }
1617         } else {
1618                 int idepth_reg = alloc_preg (cfg);
1619                 int stypes_reg = alloc_preg (cfg);
1620                 int stype = alloc_preg (cfg);
1621
1622                 if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1623                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1624                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
1625                         MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "InvalidCastException");
1626                 }
1627                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1628                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1629                 mini_emit_class_check_inst (cfg, stype, klass, klass_inst);
1630         }
1631 }
1632
1633 static void
1634 mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoBasicBlock *object_is_null)
1635 {
1636         return mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, NULL, object_is_null);
1637 }
1638
1639 static void
1640 mini_emit_memset (MonoCompile *cfg, int destreg, int offset, int size, int val, int align)
1641 {
1642         int val_reg;
1643
1644         g_assert (val == 0);
1645
1646         if (align == 0)
1647                 align = 4;
1648
1649         if ((size <= 4) && (size <= align)) {
1650                 switch (size) {
1651                 case 1:
1652                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI1_MEMBASE_IMM, destreg, offset, val);
1653                         return;
1654                 case 2:
1655                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI2_MEMBASE_IMM, destreg, offset, val);
1656                         return;
1657                 case 4:
1658                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI4_MEMBASE_IMM, destreg, offset, val);
1659                         return;
1660 #if SIZEOF_REGISTER == 8
1661                 case 8:
1662                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREI8_MEMBASE_IMM, destreg, offset, val);
1663                         return;
1664 #endif
1665                 }
1666         }
1667
1668         val_reg = alloc_preg (cfg);
1669
1670         if (SIZEOF_REGISTER == 8)
1671                 MONO_EMIT_NEW_I8CONST (cfg, val_reg, val);
1672         else
1673                 MONO_EMIT_NEW_ICONST (cfg, val_reg, val);
1674
1675         if (align < 4) {
1676                 /* This could be optimized further if neccesary */
1677                 while (size >= 1) {
1678                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
1679                         offset += 1;
1680                         size -= 1;
1681                 }
1682                 return;
1683         }
1684
1685 #if !NO_UNALIGNED_ACCESS
1686         if (SIZEOF_REGISTER == 8) {
1687                 if (offset % 8) {
1688                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
1689                         offset += 4;
1690                         size -= 4;
1691                 }
1692                 while (size >= 8) {
1693                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI8_MEMBASE_REG, destreg, offset, val_reg);
1694                         offset += 8;
1695                         size -= 8;
1696                 }
1697         }
1698 #endif
1699
1700         while (size >= 4) {
1701                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
1702                 offset += 4;
1703                 size -= 4;
1704         }
1705         while (size >= 2) {
1706                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, destreg, offset, val_reg);
1707                 offset += 2;
1708                 size -= 2;
1709         }
1710         while (size >= 1) {
1711                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
1712                 offset += 1;
1713                 size -= 1;
1714         }
1715 }
1716
1717 void
1718 mini_emit_memcpy (MonoCompile *cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1719 {
1720         int cur_reg;
1721
1722         if (align == 0)
1723                 align = 4;
1724
1725         /*FIXME arbitrary hack to avoid unbound code expansion.*/
1726         g_assert (size < 10000);
1727
1728         if (align < 4) {
1729                 /* This could be optimized further if neccesary */
1730                 while (size >= 1) {
1731                         cur_reg = alloc_preg (cfg);
1732                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
1733                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
1734                         doffset += 1;
1735                         soffset += 1;
1736                         size -= 1;
1737                 }
1738         }
1739
1740 #if !NO_UNALIGNED_ACCESS
1741         if (SIZEOF_REGISTER == 8) {
1742                 while (size >= 8) {
1743                         cur_reg = alloc_preg (cfg);
1744                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI8_MEMBASE, cur_reg, srcreg, soffset);
1745                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI8_MEMBASE_REG, destreg, doffset, cur_reg);
1746                         doffset += 8;
1747                         soffset += 8;
1748                         size -= 8;
1749                 }
1750         }
1751 #endif
1752
1753         while (size >= 4) {
1754                 cur_reg = alloc_preg (cfg);
1755                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, cur_reg, srcreg, soffset);
1756                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, doffset, cur_reg);
1757                 doffset += 4;
1758                 soffset += 4;
1759                 size -= 4;
1760         }
1761         while (size >= 2) {
1762                 cur_reg = alloc_preg (cfg);
1763                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI2_MEMBASE, cur_reg, srcreg, soffset);
1764                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, destreg, doffset, cur_reg);
1765                 doffset += 2;
1766                 soffset += 2;
1767                 size -= 2;
1768         }
1769         while (size >= 1) {
1770                 cur_reg = alloc_preg (cfg);
1771                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
1772                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
1773                 doffset += 1;
1774                 soffset += 1;
1775                 size -= 1;
1776         }
1777 }
1778
1779 static int
1780 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
1781 {
1782         if (type->byref)
1783                 return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
1784
1785 handle_enum:
1786         type = mini_get_basic_type_from_generic (gsctx, type);
1787         switch (type->type) {
1788         case MONO_TYPE_VOID:
1789                 return calli? OP_VOIDCALL_REG: virt? OP_VOIDCALLVIRT: OP_VOIDCALL;
1790         case MONO_TYPE_I1:
1791         case MONO_TYPE_U1:
1792         case MONO_TYPE_BOOLEAN:
1793         case MONO_TYPE_I2:
1794         case MONO_TYPE_U2:
1795         case MONO_TYPE_CHAR:
1796         case MONO_TYPE_I4:
1797         case MONO_TYPE_U4:
1798                 return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
1799         case MONO_TYPE_I:
1800         case MONO_TYPE_U:
1801         case MONO_TYPE_PTR:
1802         case MONO_TYPE_FNPTR:
1803                 return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
1804         case MONO_TYPE_CLASS:
1805         case MONO_TYPE_STRING:
1806         case MONO_TYPE_OBJECT:
1807         case MONO_TYPE_SZARRAY:
1808         case MONO_TYPE_ARRAY:
1809                 return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
1810         case MONO_TYPE_I8:
1811         case MONO_TYPE_U8:
1812                 return calli? OP_LCALL_REG: virt? OP_LCALLVIRT: OP_LCALL;
1813         case MONO_TYPE_R4:
1814         case MONO_TYPE_R8:
1815                 return calli? OP_FCALL_REG: virt? OP_FCALLVIRT: OP_FCALL;
1816         case MONO_TYPE_VALUETYPE:
1817                 if (type->data.klass->enumtype) {
1818                         type = mono_class_enum_basetype (type->data.klass);
1819                         goto handle_enum;
1820                 } else
1821                         return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
1822         case MONO_TYPE_TYPEDBYREF:
1823                 return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
1824         case MONO_TYPE_GENERICINST:
1825                 type = &type->data.generic_class->container_class->byval_arg;
1826                 goto handle_enum;
1827         default:
1828                 g_error ("unknown type 0x%02x in ret_type_to_call_opcode", type->type);
1829         }
1830         return -1;
1831 }
1832
1833 /*
1834  * target_type_is_incompatible:
1835  * @cfg: MonoCompile context
1836  *
1837  * Check that the item @arg on the evaluation stack can be stored
1838  * in the target type (can be a local, or field, etc).
1839  * The cfg arg can be used to check if we need verification or just
1840  * validity checks.
1841  *
1842  * Returns: non-0 value if arg can't be stored on a target.
1843  */
1844 static int
1845 target_type_is_incompatible (MonoCompile *cfg, MonoType *target, MonoInst *arg)
1846 {
1847         MonoType *simple_type;
1848         MonoClass *klass;
1849
1850         if (target->byref) {
1851                 /* FIXME: check that the pointed to types match */
1852                 if (arg->type == STACK_MP)
1853                         return arg->klass != mono_class_from_mono_type (target);
1854                 if (arg->type == STACK_PTR)
1855                         return 0;
1856                 return 1;
1857         }
1858
1859         simple_type = mono_type_get_underlying_type (target);
1860         switch (simple_type->type) {
1861         case MONO_TYPE_VOID:
1862                 return 1;
1863         case MONO_TYPE_I1:
1864         case MONO_TYPE_U1:
1865         case MONO_TYPE_BOOLEAN:
1866         case MONO_TYPE_I2:
1867         case MONO_TYPE_U2:
1868         case MONO_TYPE_CHAR:
1869         case MONO_TYPE_I4:
1870         case MONO_TYPE_U4:
1871                 if (arg->type != STACK_I4 && arg->type != STACK_PTR)
1872                         return 1;
1873                 return 0;
1874         case MONO_TYPE_PTR:
1875                 /* STACK_MP is needed when setting pinned locals */
1876                 if (arg->type != STACK_I4 && arg->type != STACK_PTR && arg->type != STACK_MP)
1877                         return 1;
1878                 return 0;
1879         case MONO_TYPE_I:
1880         case MONO_TYPE_U:
1881         case MONO_TYPE_FNPTR:
1882                 if (arg->type != STACK_I4 && arg->type != STACK_PTR)
1883                         return 1;
1884                 return 0;
1885         case MONO_TYPE_CLASS:
1886         case MONO_TYPE_STRING:
1887         case MONO_TYPE_OBJECT:
1888         case MONO_TYPE_SZARRAY:
1889         case MONO_TYPE_ARRAY:
1890                 if (arg->type != STACK_OBJ)
1891                         return 1;
1892                 /* FIXME: check type compatibility */
1893                 return 0;
1894         case MONO_TYPE_I8:
1895         case MONO_TYPE_U8:
1896                 if (arg->type != STACK_I8)
1897                         return 1;
1898                 return 0;
1899         case MONO_TYPE_R4:
1900         case MONO_TYPE_R8:
1901                 if (arg->type != STACK_R8)
1902                         return 1;
1903                 return 0;
1904         case MONO_TYPE_VALUETYPE:
1905                 if (arg->type != STACK_VTYPE)
1906                         return 1;
1907                 klass = mono_class_from_mono_type (simple_type);
1908                 if (klass != arg->klass)
1909                         return 1;
1910                 return 0;
1911         case MONO_TYPE_TYPEDBYREF:
1912                 if (arg->type != STACK_VTYPE)
1913                         return 1;
1914                 klass = mono_class_from_mono_type (simple_type);
1915                 if (klass != arg->klass)
1916                         return 1;
1917                 return 0;
1918         case MONO_TYPE_GENERICINST:
1919                 if (mono_type_generic_inst_is_valuetype (simple_type)) {
1920                         if (arg->type != STACK_VTYPE)
1921                                 return 1;
1922                         klass = mono_class_from_mono_type (simple_type);
1923                         if (klass != arg->klass)
1924                                 return 1;
1925                         return 0;
1926                 } else {
1927                         if (arg->type != STACK_OBJ)
1928                                 return 1;
1929                         /* FIXME: check type compatibility */
1930                         return 0;
1931                 }
1932         case MONO_TYPE_VAR:
1933         case MONO_TYPE_MVAR:
1934                 /* FIXME: all the arguments must be references for now,
1935                  * later look inside cfg and see if the arg num is
1936                  * really a reference
1937                  */
1938                 g_assert (cfg->generic_sharing_context);
1939                 if (arg->type != STACK_OBJ)
1940                         return 1;
1941                 return 0;
1942         default:
1943                 g_error ("unknown type 0x%02x in target_type_is_incompatible", simple_type->type);
1944         }
1945         return 1;
1946 }
1947
1948 /*
1949  * Prepare arguments for passing to a function call.
1950  * Return a non-zero value if the arguments can't be passed to the given
1951  * signature.
1952  * The type checks are not yet complete and some conversions may need
1953  * casts on 32 or 64 bit architectures.
1954  *
1955  * FIXME: implement this using target_type_is_incompatible ()
1956  */
1957 static int
1958 check_call_signature (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args)
1959 {
1960         MonoType *simple_type;
1961         int i;
1962
1963         if (sig->hasthis) {
1964                 if (args [0]->type != STACK_OBJ && args [0]->type != STACK_MP && args [0]->type != STACK_PTR)
1965                         return 1;
1966                 args++;
1967         }
1968         for (i = 0; i < sig->param_count; ++i) {
1969                 if (sig->params [i]->byref) {
1970                         if (args [i]->type != STACK_MP && args [i]->type != STACK_PTR)
1971                                 return 1;
1972                         continue;
1973                 }
1974                 simple_type = sig->params [i];
1975                 simple_type = mini_get_basic_type_from_generic (cfg->generic_sharing_context, simple_type);
1976 handle_enum:
1977                 switch (simple_type->type) {
1978                 case MONO_TYPE_VOID:
1979                         return 1;
1980                         continue;
1981                 case MONO_TYPE_I1:
1982                 case MONO_TYPE_U1:
1983                 case MONO_TYPE_BOOLEAN:
1984                 case MONO_TYPE_I2:
1985                 case MONO_TYPE_U2:
1986                 case MONO_TYPE_CHAR:
1987                 case MONO_TYPE_I4:
1988                 case MONO_TYPE_U4:
1989                         if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR)
1990                                 return 1;
1991                         continue;
1992                 case MONO_TYPE_I:
1993                 case MONO_TYPE_U:
1994                 case MONO_TYPE_PTR:
1995                 case MONO_TYPE_FNPTR:
1996                         if (args [i]->type != STACK_I4 && args [i]->type != STACK_PTR && args [i]->type != STACK_MP && args [i]->type != STACK_OBJ)
1997                                 return 1;
1998                         continue;
1999                 case MONO_TYPE_CLASS:
2000                 case MONO_TYPE_STRING:
2001                 case MONO_TYPE_OBJECT:
2002                 case MONO_TYPE_SZARRAY:
2003                 case MONO_TYPE_ARRAY:
2004                         if (args [i]->type != STACK_OBJ)
2005                                 return 1;
2006                         continue;
2007                 case MONO_TYPE_I8:
2008                 case MONO_TYPE_U8:
2009                         if (args [i]->type != STACK_I8)
2010                                 return 1;
2011                         continue;
2012                 case MONO_TYPE_R4:
2013                 case MONO_TYPE_R8:
2014                         if (args [i]->type != STACK_R8)
2015                                 return 1;
2016                         continue;
2017                 case MONO_TYPE_VALUETYPE:
2018                         if (simple_type->data.klass->enumtype) {
2019                                 simple_type = mono_class_enum_basetype (simple_type->data.klass);
2020                                 goto handle_enum;
2021                         }
2022                         if (args [i]->type != STACK_VTYPE)
2023                                 return 1;
2024                         continue;
2025                 case MONO_TYPE_TYPEDBYREF:
2026                         if (args [i]->type != STACK_VTYPE)
2027                                 return 1;
2028                         continue;
2029                 case MONO_TYPE_GENERICINST:
2030                         simple_type = &simple_type->data.generic_class->container_class->byval_arg;
2031                         goto handle_enum;
2032
2033                 default:
2034                         g_error ("unknown type 0x%02x in check_call_signature",
2035                                  simple_type->type);
2036                 }
2037         }
2038         return 0;
2039 }
2040
2041 static int
2042 callvirt_to_call (int opcode)
2043 {
2044         switch (opcode) {
2045         case OP_CALLVIRT:
2046                 return OP_CALL;
2047         case OP_VOIDCALLVIRT:
2048                 return OP_VOIDCALL;
2049         case OP_FCALLVIRT:
2050                 return OP_FCALL;
2051         case OP_VCALLVIRT:
2052                 return OP_VCALL;
2053         case OP_LCALLVIRT:
2054                 return OP_LCALL;
2055         default:
2056                 g_assert_not_reached ();
2057         }
2058
2059         return -1;
2060 }
2061
2062 static int
2063 callvirt_to_call_membase (int opcode)
2064 {
2065         switch (opcode) {
2066         case OP_CALLVIRT:
2067                 return OP_CALL_MEMBASE;
2068         case OP_VOIDCALLVIRT:
2069                 return OP_VOIDCALL_MEMBASE;
2070         case OP_FCALLVIRT:
2071                 return OP_FCALL_MEMBASE;
2072         case OP_LCALLVIRT:
2073                 return OP_LCALL_MEMBASE;
2074         case OP_VCALLVIRT:
2075                 return OP_VCALL_MEMBASE;
2076         default:
2077                 g_assert_not_reached ();
2078         }
2079
2080         return -1;
2081 }
2082
2083 #ifdef MONO_ARCH_HAVE_IMT
2084 static void
2085 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoInst *imt_arg)
2086 {
2087         int method_reg;
2088
2089         if (COMPILE_LLVM (cfg)) {
2090                 method_reg = alloc_preg (cfg);
2091
2092                 if (imt_arg) {
2093                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, method_reg, imt_arg->dreg);
2094                 } else if (cfg->compile_aot) {
2095                         MONO_EMIT_NEW_AOTCONST (cfg, method_reg, call->method, MONO_PATCH_INFO_METHODCONST);
2096                 } else {
2097                         MonoInst *ins;
2098                         MONO_INST_NEW (cfg, ins, OP_PCONST);
2099                         ins->inst_p0 = call->method;
2100                         ins->dreg = method_reg;
2101                         MONO_ADD_INS (cfg->cbb, ins);
2102                 }
2103
2104 #ifdef ENABLE_LLVM
2105                 call->imt_arg_reg = method_reg;
2106 #endif
2107 #ifdef MONO_ARCH_IMT_REG
2108         mono_call_inst_add_outarg_reg (cfg, call, method_reg, MONO_ARCH_IMT_REG, FALSE);
2109 #else
2110         /* Need this to keep the IMT arg alive */
2111         mono_call_inst_add_outarg_reg (cfg, call, method_reg, 0, FALSE);
2112 #endif
2113                 return;
2114         }
2115
2116 #ifdef MONO_ARCH_IMT_REG
2117         method_reg = alloc_preg (cfg);
2118
2119         if (imt_arg) {
2120                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, method_reg, imt_arg->dreg);
2121         } else if (cfg->compile_aot) {
2122                 MONO_EMIT_NEW_AOTCONST (cfg, method_reg, call->method, MONO_PATCH_INFO_METHODCONST);
2123         } else {
2124                 MonoInst *ins;
2125                 MONO_INST_NEW (cfg, ins, OP_PCONST);
2126                 ins->inst_p0 = call->method;
2127                 ins->dreg = method_reg;
2128                 MONO_ADD_INS (cfg->cbb, ins);
2129         }
2130
2131         mono_call_inst_add_outarg_reg (cfg, call, method_reg, MONO_ARCH_IMT_REG, FALSE);
2132 #else
2133         mono_arch_emit_imt_argument (cfg, call, imt_arg);
2134 #endif
2135 }
2136 #endif
2137
2138 static MonoJumpInfo *
2139 mono_patch_info_new (MonoMemPool *mp, int ip, MonoJumpInfoType type, gconstpointer target)
2140 {
2141         MonoJumpInfo *ji = mono_mempool_alloc (mp, sizeof (MonoJumpInfo));
2142
2143         ji->ip.i = ip;
2144         ji->type = type;
2145         ji->data.target = target;
2146
2147         return ji;
2148 }
2149
2150 inline static MonoCallInst *
2151 mono_emit_call_args (MonoCompile *cfg, MonoMethodSignature *sig,
2152                                          MonoInst **args, int calli, int virtual, int tail)
2153 {
2154         MonoCallInst *call;
2155 #ifdef MONO_ARCH_SOFT_FLOAT
2156         int i;
2157 #endif
2158
2159         if (tail)
2160                 MONO_INST_NEW_CALL (cfg, call, OP_TAILCALL);
2161         else
2162                 MONO_INST_NEW_CALL (cfg, call, ret_type_to_call_opcode (sig->ret, calli, virtual, cfg->generic_sharing_context));
2163
2164         call->args = args;
2165         call->signature = sig;
2166
2167         type_to_eval_stack_type ((cfg), sig->ret, &call->inst);
2168
2169         if (tail) {
2170                 if (MONO_TYPE_ISSTRUCT (sig->ret)) {
2171                         call->vret_var = cfg->vret_addr;
2172                         //g_assert_not_reached ();
2173                 }
2174         } else if (MONO_TYPE_ISSTRUCT (sig->ret)) {
2175                 MonoInst *temp = mono_compile_create_var (cfg, sig->ret, OP_LOCAL);
2176                 MonoInst *loada;
2177
2178                 temp->backend.is_pinvoke = sig->pinvoke;
2179
2180                 /*
2181                  * We use a new opcode OP_OUTARG_VTRETADDR instead of LDADDR for emitting the
2182                  * address of return value to increase optimization opportunities.
2183                  * Before vtype decomposition, the dreg of the call ins itself represents the
2184                  * fact the call modifies the return value. After decomposition, the call will
2185                  * be transformed into one of the OP_VOIDCALL opcodes, and the VTRETADDR opcode
2186                  * will be transformed into an LDADDR.
2187                  */
2188                 MONO_INST_NEW (cfg, loada, OP_OUTARG_VTRETADDR);
2189                 loada->dreg = alloc_preg (cfg);
2190                 loada->inst_p0 = temp;
2191                 /* We reference the call too since call->dreg could change during optimization */
2192                 loada->inst_p1 = call;
2193                 MONO_ADD_INS (cfg->cbb, loada);
2194
2195                 call->inst.dreg = temp->dreg;
2196
2197                 call->vret_var = loada;
2198         } else if (!MONO_TYPE_IS_VOID (sig->ret))
2199                 call->inst.dreg = alloc_dreg (cfg, call->inst.type);
2200
2201 #ifdef MONO_ARCH_SOFT_FLOAT
2202         if (COMPILE_SOFT_FLOAT (cfg)) {
2203                 /*
2204                  * If the call has a float argument, we would need to do an r8->r4 conversion using
2205                  * an icall, but that cannot be done during the call sequence since it would clobber
2206                  * the call registers + the stack. So we do it before emitting the call.
2207                  */
2208                 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
2209                         MonoType *t;
2210                         MonoInst *in = call->args [i];
2211
2212                         if (i >= sig->hasthis)
2213                                 t = sig->params [i - sig->hasthis];
2214                         else
2215                                 t = &mono_defaults.int_class->byval_arg;
2216                         t = mono_type_get_underlying_type (t);
2217
2218                         if (!t->byref && t->type == MONO_TYPE_R4) {
2219                                 MonoInst *iargs [1];
2220                                 MonoInst *conv;
2221
2222                                 iargs [0] = in;
2223                                 conv = mono_emit_jit_icall (cfg, mono_fload_r4_arg, iargs);
2224
2225                                 /* The result will be in an int vreg */
2226                                 call->args [i] = conv;
2227                         }
2228                 }
2229         }
2230 #endif
2231
2232 #ifdef ENABLE_LLVM
2233         if (COMPILE_LLVM (cfg))
2234                 mono_llvm_emit_call (cfg, call);
2235         else
2236                 mono_arch_emit_call (cfg, call);
2237 #else
2238         mono_arch_emit_call (cfg, call);
2239 #endif
2240
2241         cfg->param_area = MAX (cfg->param_area, call->stack_usage);
2242         cfg->flags |= MONO_CFG_HAS_CALLS;
2243
2244         return call;
2245 }
2246
2247 inline static MonoInst*
2248 mono_emit_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr)
2249 {
2250         MonoCallInst *call = mono_emit_call_args (cfg, sig, args, TRUE, FALSE, FALSE);
2251
2252         call->inst.sreg1 = addr->dreg;
2253
2254         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2255
2256         return (MonoInst*)call;
2257 }
2258
2259 static void
2260 set_rgctx_arg (MonoCompile *cfg, MonoCallInst *call, int rgctx_reg, MonoInst *rgctx_arg)
2261 {
2262 #ifdef MONO_ARCH_RGCTX_REG
2263         mono_call_inst_add_outarg_reg (cfg, call, rgctx_reg, MONO_ARCH_RGCTX_REG, FALSE);
2264         cfg->uses_rgctx_reg = TRUE;
2265         call->rgctx_reg = TRUE;
2266 #ifdef ENABLE_LLVM
2267         call->rgctx_arg_reg = rgctx_reg;
2268 #endif
2269 #else
2270         NOT_IMPLEMENTED;
2271 #endif
2272 }
2273
2274 inline static MonoInst*
2275 mono_emit_rgctx_calli (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **args, MonoInst *addr, MonoInst *rgctx_arg)
2276 {
2277         MonoCallInst *call;
2278         int rgctx_reg = -1;
2279
2280         if (rgctx_arg) {
2281                 rgctx_reg = mono_alloc_preg (cfg);
2282                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, rgctx_reg, rgctx_arg->dreg);
2283         }
2284         call = (MonoCallInst*)mono_emit_calli (cfg, sig, args, addr);
2285         if (rgctx_arg)
2286                 set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
2287         return (MonoInst*)call;
2288 }
2289
2290 static MonoInst*
2291 emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
2292 static MonoInst*
2293 emit_get_rgctx_klass (MonoCompile *cfg, int context_used, MonoClass *klass, int rgctx_type);
2294
2295 static MonoInst*
2296 mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
2297                                                         MonoInst **args, MonoInst *this, MonoInst *imt_arg)
2298 {
2299         gboolean might_be_remote;
2300         gboolean virtual = this != NULL;
2301         gboolean enable_for_aot = TRUE;
2302         int context_used;
2303         MonoCallInst *call;
2304
2305         if (method->string_ctor) {
2306                 /* Create the real signature */
2307                 /* FIXME: Cache these */
2308                 MonoMethodSignature *ctor_sig = mono_metadata_signature_dup_mempool (cfg->mempool, sig);
2309                 ctor_sig->ret = &mono_defaults.string_class->byval_arg;
2310
2311                 sig = ctor_sig;
2312         }
2313
2314         might_be_remote = this && sig->hasthis &&
2315                 (method->klass->marshalbyref || method->klass == mono_defaults.object_class) &&
2316                 !(method->flags & METHOD_ATTRIBUTE_VIRTUAL) && !MONO_CHECK_THIS (this);
2317
2318         context_used = mono_method_check_context_used (method);
2319         if (might_be_remote && context_used) {
2320                 MonoInst *addr;
2321
2322                 g_assert (cfg->generic_sharing_context);
2323
2324                 addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
2325
2326                 return mono_emit_calli (cfg, sig, args, addr);
2327         }
2328
2329         call = mono_emit_call_args (cfg, sig, args, FALSE, virtual, FALSE);
2330
2331         if (might_be_remote)
2332                 call->method = mono_marshal_get_remoting_invoke_with_check (method);
2333         else
2334                 call->method = method;
2335         call->inst.flags |= MONO_INST_HAS_METHOD;
2336         call->inst.inst_left = this;
2337
2338         if (virtual) {
2339                 int vtable_reg, slot_reg, this_reg;
2340
2341                 this_reg = this->dreg;
2342
2343 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
2344                 if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
2345                         MONO_EMIT_NULL_CHECK (cfg, this_reg);
2346
2347                         /* Make a call to delegate->invoke_impl */
2348                         call->inst.opcode = callvirt_to_call_membase (call->inst.opcode);
2349                         call->inst.inst_basereg = this_reg;
2350                         call->inst.inst_offset = G_STRUCT_OFFSET (MonoDelegate, invoke_impl);
2351                         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2352
2353                         return (MonoInst*)call;
2354                 }
2355 #endif
2356
2357                 if ((!cfg->compile_aot || enable_for_aot) &&
2358                         (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
2359                          (MONO_METHOD_IS_FINAL (method) &&
2360                           method->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)) &&
2361                         !(method->klass->marshalbyref && context_used)) {
2362                         /*
2363                          * the method is not virtual, we just need to ensure this is not null
2364                          * and then we can call the method directly.
2365                          */
2366                         if (method->klass->marshalbyref || method->klass == mono_defaults.object_class) {
2367                                 /*
2368                                  * The check above ensures method is not gshared, this is needed since
2369                                  * gshared methods can't have wrappers.
2370                                  */
2371                                 method = call->method = mono_marshal_get_remoting_invoke_with_check (method);
2372                         }
2373
2374                         if (!method->string_ctor)
2375                                 MONO_EMIT_NEW_CHECK_THIS (cfg, this_reg);
2376
2377                         call->inst.opcode = callvirt_to_call (call->inst.opcode);
2378
2379                         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2380
2381                         return (MonoInst*)call;
2382                 }
2383
2384                 if ((method->flags & METHOD_ATTRIBUTE_VIRTUAL) && MONO_METHOD_IS_FINAL (method)) {
2385                         /*
2386                          * the method is virtual, but we can statically dispatch since either
2387                          * it's class or the method itself are sealed.
2388                          * But first we need to ensure it's not a null reference.
2389                          */
2390                         MONO_EMIT_NEW_CHECK_THIS (cfg, this_reg);
2391
2392                         call->inst.opcode = callvirt_to_call (call->inst.opcode);
2393                         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2394
2395                         return (MonoInst*)call;
2396                 }
2397
2398                 call->inst.opcode = callvirt_to_call_membase (call->inst.opcode);
2399
2400                 vtable_reg = alloc_preg (cfg);
2401                 MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
2402                 if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
2403                         slot_reg = -1;
2404 #ifdef MONO_ARCH_HAVE_IMT
2405                         if (mono_use_imt) {
2406                                 guint32 imt_slot = mono_method_get_imt_slot (method);
2407                                 emit_imt_argument (cfg, call, imt_arg);
2408                                 slot_reg = vtable_reg;
2409                                 call->inst.inst_offset = ((gint32)imt_slot - MONO_IMT_SIZE) * SIZEOF_VOID_P;
2410                         }
2411 #endif
2412                         if (slot_reg == -1) {
2413                                 slot_reg = alloc_preg (cfg);
2414                                 mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, method->klass);
2415                                 call->inst.inst_offset = mono_method_get_vtable_index (method) * SIZEOF_VOID_P;
2416                         }
2417                 } else {
2418                         slot_reg = vtable_reg;
2419                         call->inst.inst_offset = G_STRUCT_OFFSET (MonoVTable, vtable) +
2420                                 ((mono_method_get_vtable_index (method)) * (SIZEOF_VOID_P));
2421 #ifdef MONO_ARCH_HAVE_IMT
2422                         if (imt_arg) {
2423                                 g_assert (mono_method_signature (method)->generic_param_count);
2424                                 emit_imt_argument (cfg, call, imt_arg);
2425                         }
2426 #endif
2427                 }
2428
2429                 call->inst.sreg1 = slot_reg;
2430                 call->virtual = TRUE;
2431         }
2432
2433         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2434
2435         return (MonoInst*)call;
2436 }
2437
2438 static MonoInst*
2439 mono_emit_rgctx_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
2440                 MonoInst **args, MonoInst *this, MonoInst *imt_arg, MonoInst *vtable_arg)
2441 {
2442         int rgctx_reg = 0;
2443         MonoInst *ins;
2444         MonoCallInst *call;
2445
2446         if (vtable_arg) {
2447                 rgctx_reg = mono_alloc_preg (cfg);
2448                 MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, rgctx_reg, vtable_arg->dreg);
2449         }
2450         ins = mono_emit_method_call_full (cfg, method, sig, args, this, imt_arg);
2451
2452         call = (MonoCallInst*)ins;
2453         if (vtable_arg)
2454                 set_rgctx_arg (cfg, call, rgctx_reg, vtable_arg);
2455
2456         return ins;
2457 }
2458
2459 MonoInst*
2460 mono_emit_method_call (MonoCompile *cfg, MonoMethod *method, MonoInst **args, MonoInst *this)
2461 {
2462         return mono_emit_method_call_full (cfg, method, mono_method_signature (method), args, this, NULL);
2463 }
2464
2465 MonoInst*
2466 mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig,
2467                                            MonoInst **args)
2468 {
2469         MonoCallInst *call;
2470
2471         g_assert (sig);
2472
2473         call = mono_emit_call_args (cfg, sig, args, FALSE, FALSE, FALSE);
2474         call->fptr = func;
2475
2476         MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
2477
2478         return (MonoInst*)call;
2479 }
2480
2481 MonoInst*
2482 mono_emit_jit_icall (MonoCompile *cfg, gconstpointer func, MonoInst **args)
2483 {
2484         MonoJitICallInfo *info = mono_find_jit_icall_by_addr (func);
2485
2486         g_assert (info);
2487
2488         return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, args);
2489 }
2490
2491 /*
2492  * mono_emit_abs_call:
2493  *
2494  *   Emit a call to the runtime function described by PATCH_TYPE and DATA.
2495  */
2496 inline static MonoInst*
2497 mono_emit_abs_call (MonoCompile *cfg, MonoJumpInfoType patch_type, gconstpointer data,
2498                                         MonoMethodSignature *sig, MonoInst **args)
2499 {
2500         MonoJumpInfo *ji = mono_patch_info_new (cfg->mempool, 0, patch_type, data);
2501         MonoInst *ins;
2502
2503         /*
2504          * We pass ji as the call address, the PATCH_INFO_ABS resolving code will
2505          * handle it.
2506          */
2507         if (cfg->abs_patches == NULL)
2508                 cfg->abs_patches = g_hash_table_new (NULL, NULL);
2509         g_hash_table_insert (cfg->abs_patches, ji, ji);
2510         ins = mono_emit_native_call (cfg, ji, sig, args);
2511         ((MonoCallInst*)ins)->fptr_is_patch = TRUE;
2512         return ins;
2513 }
2514
2515 static MonoInst*
2516 mono_emit_widen_call_res (MonoCompile *cfg, MonoInst *ins, MonoMethodSignature *fsig)
2517 {
2518         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
2519                 if ((fsig->pinvoke || LLVM_ENABLED) && !fsig->ret->byref) {
2520                         int widen_op = -1;
2521
2522                         /*
2523                          * Native code might return non register sized integers
2524                          * without initializing the upper bits.
2525                          */
2526                         switch (mono_type_to_load_membase (cfg, fsig->ret)) {
2527                         case OP_LOADI1_MEMBASE:
2528                                 widen_op = OP_ICONV_TO_I1;
2529                                 break;
2530                         case OP_LOADU1_MEMBASE:
2531                                 widen_op = OP_ICONV_TO_U1;
2532                                 break;
2533                         case OP_LOADI2_MEMBASE:
2534                                 widen_op = OP_ICONV_TO_I2;
2535                                 break;
2536                         case OP_LOADU2_MEMBASE:
2537                                 widen_op = OP_ICONV_TO_U2;
2538                                 break;
2539                         default:
2540                                 break;
2541                         }
2542
2543                         if (widen_op != -1) {
2544                                 int dreg = alloc_preg (cfg);
2545                                 MonoInst *widen;
2546
2547                                 EMIT_NEW_UNALU (cfg, widen, widen_op, dreg, ins->dreg);
2548                                 widen->type = ins->type;
2549                                 ins = widen;
2550                         }
2551                 }
2552         }
2553
2554         return ins;
2555 }
2556
2557 static MonoMethod*
2558 get_memcpy_method (void)
2559 {
2560         static MonoMethod *memcpy_method = NULL;
2561         if (!memcpy_method) {
2562                 memcpy_method = mono_class_get_method_from_name (mono_defaults.string_class, "memcpy", 3);
2563                 if (!memcpy_method)
2564                         g_error ("Old corlib found. Install a new one");
2565         }
2566         return memcpy_method;
2567 }
2568
2569 static void
2570 create_write_barrier_bitmap (MonoClass *klass, unsigned *wb_bitmap, int offset)
2571 {
2572         MonoClassField *field;
2573         gpointer iter = NULL;
2574
2575         while ((field = mono_class_get_fields (klass, &iter))) {
2576                 int foffset;
2577
2578                 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
2579                         continue;
2580                 foffset = klass->valuetype ? field->offset - sizeof (MonoObject): field->offset;
2581                 if (mono_type_is_reference (field->type)) {
2582                         g_assert ((foffset % SIZEOF_VOID_P) == 0);
2583                         *wb_bitmap |= 1 << ((offset + foffset) / SIZEOF_VOID_P);
2584                 } else {
2585                         /*FIXME support nested value types so this works for: struct X { Y y; int z;} struct Y { object a,b; }*/
2586                         MonoClass *field_class = mono_class_from_mono_type (field->type);
2587                         if (field_class->has_references)
2588                                 create_write_barrier_bitmap (field_class, wb_bitmap, offset + foffset);
2589                 }
2590         }
2591 }
2592
2593 static gboolean
2594 mono_emit_wb_aware_memcpy (MonoCompile *cfg, MonoClass *klass, MonoInst *iargs[4], int size, int align)
2595 {
2596         int dest_ptr_reg, tmp_reg, destreg, srcreg, offset;
2597         unsigned need_wb = 0;
2598
2599         if (align == 0)
2600                 align = 4;
2601
2602         /*types with references can't have alignment smaller than sizeof(void*) */
2603         if (align < SIZEOF_VOID_P)
2604                 return FALSE;
2605
2606         /*This value cannot be bigger than 32 due to the way we calculate the required wb bitmap.*/
2607         if (size > 32 * SIZEOF_VOID_P)
2608                 return FALSE;
2609
2610         create_write_barrier_bitmap (klass, &need_wb, 0);
2611
2612         /* We don't unroll more than 5 stores to avoid code bloat. */
2613         if (size > 5 * SIZEOF_VOID_P) {
2614                 /*This is harmless and simplify mono_gc_wbarrier_value_copy_bitmap */
2615                 size += (SIZEOF_VOID_P - 1);
2616                 size &= ~(SIZEOF_VOID_P - 1);
2617
2618                 EMIT_NEW_ICONST (cfg, iargs [2], size);
2619                 EMIT_NEW_ICONST (cfg, iargs [3], need_wb);
2620                 mono_emit_jit_icall (cfg, mono_gc_wbarrier_value_copy_bitmap, iargs);
2621                 return TRUE;
2622         }
2623
2624         destreg = iargs [0]->dreg;
2625         srcreg = iargs [1]->dreg;
2626         offset = 0;
2627
2628         dest_ptr_reg = alloc_preg (cfg);
2629         tmp_reg = alloc_preg (cfg);
2630
2631         /*tmp = dreg*/
2632         EMIT_NEW_UNALU (cfg, iargs [0], OP_MOVE, dest_ptr_reg, destreg);
2633
2634         while (size >= SIZEOF_VOID_P) {
2635                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOAD_MEMBASE, tmp_reg, srcreg, offset);
2636                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, dest_ptr_reg, 0, tmp_reg);
2637
2638                 if (need_wb & 0x1) {
2639                         MonoInst *dummy_use;
2640
2641                         MonoMethod *write_barrier = mono_gc_get_write_barrier ();
2642                         mono_emit_method_call (cfg, write_barrier, &iargs [0], NULL);
2643
2644                         MONO_INST_NEW (cfg, dummy_use, OP_DUMMY_USE);
2645                         dummy_use->sreg1 = dest_ptr_reg;
2646                         MONO_ADD_INS (cfg->cbb, dummy_use);
2647                 }
2648
2649
2650                 offset += SIZEOF_VOID_P;
2651                 size -= SIZEOF_VOID_P;
2652                 need_wb >>= 1;
2653
2654                 /*tmp += sizeof (void*)*/
2655                 if (size >= SIZEOF_VOID_P) {
2656                         NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, dest_ptr_reg, dest_ptr_reg, SIZEOF_VOID_P);
2657                         MONO_ADD_INS (cfg->cbb, iargs [0]);
2658                 }
2659         }
2660
2661         /* Those cannot be references since size < sizeof (void*) */
2662         while (size >= 4) {
2663                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, tmp_reg, srcreg, offset);
2664                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, destreg, offset, tmp_reg);
2665                 offset += 4;
2666                 size -= 4;
2667         }
2668
2669         while (size >= 2) {
2670                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI2_MEMBASE, tmp_reg, srcreg, offset);
2671                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, destreg, offset, tmp_reg);
2672                 offset += 2;
2673                 size -= 2;
2674         }
2675
2676         while (size >= 1) {
2677                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, tmp_reg, srcreg, offset);
2678                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, destreg, offset, tmp_reg);
2679                 offset += 1;
2680                 size -= 1;
2681         }
2682
2683         return TRUE;
2684 }
2685
2686 /*
2687  * Emit code to copy a valuetype of type @klass whose address is stored in
2688  * @src->dreg to memory whose address is stored at @dest->dreg.
2689  */
2690 void
2691 mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
2692 {
2693         MonoInst *iargs [4];
2694         int n;
2695         guint32 align = 0;
2696         MonoMethod *memcpy_method;
2697
2698         g_assert (klass);
2699         /*
2700          * This check breaks with spilled vars... need to handle it during verification anyway.
2701          * g_assert (klass && klass == src->klass && klass == dest->klass);
2702          */
2703
2704         if (native)
2705                 n = mono_class_native_size (klass, &align);
2706         else
2707                 n = mono_class_value_size (klass, &align);
2708
2709         /* if native is true there should be no references in the struct */
2710         if (cfg->gen_write_barriers && klass->has_references && !native) {
2711                 /* Avoid barriers when storing to the stack */
2712                 if (!((dest->opcode == OP_ADD_IMM && dest->sreg1 == cfg->frame_reg) ||
2713                           (dest->opcode == OP_LDADDR))) {
2714                         int context_used = 0;
2715
2716                         iargs [0] = dest;
2717                         iargs [1] = src;
2718
2719                         if (cfg->generic_sharing_context)
2720                                 context_used = mono_class_check_context_used (klass);
2721
2722                         /* It's ok to intrinsify under gsharing since shared code types are layout stable. */
2723                         if ((cfg->opt & MONO_OPT_INTRINS) && mono_emit_wb_aware_memcpy (cfg, klass, iargs, n, align)) {
2724                                 return;
2725                         } else if (context_used) {
2726                                 iargs [2] = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
2727                         }  else {
2728                                 if (cfg->compile_aot) {
2729                                         EMIT_NEW_CLASSCONST (cfg, iargs [2], klass);
2730                                 } else {
2731                                         EMIT_NEW_PCONST (cfg, iargs [2], klass);
2732                                         mono_class_compute_gc_descriptor (klass);
2733                                 }
2734                         }
2735
2736                         mono_emit_jit_icall (cfg, mono_value_copy, iargs);
2737                         return;
2738                 }
2739         }
2740
2741         if ((cfg->opt & MONO_OPT_INTRINS) && n <= sizeof (gpointer) * 5) {
2742                 /* FIXME: Optimize the case when src/dest is OP_LDADDR */
2743                 mini_emit_memcpy (cfg, dest->dreg, 0, src->dreg, 0, n, align);
2744         } else {
2745                 iargs [0] = dest;
2746                 iargs [1] = src;
2747                 EMIT_NEW_ICONST (cfg, iargs [2], n);
2748
2749                 memcpy_method = get_memcpy_method ();
2750                 mono_emit_method_call (cfg, memcpy_method, iargs, NULL);
2751         }
2752 }
2753
2754 static MonoMethod*
2755 get_memset_method (void)
2756 {
2757         static MonoMethod *memset_method = NULL;
2758         if (!memset_method) {
2759                 memset_method = mono_class_get_method_from_name (mono_defaults.string_class, "memset", 3);
2760                 if (!memset_method)
2761                         g_error ("Old corlib found. Install a new one");
2762         }
2763         return memset_method;
2764 }
2765
2766 void
2767 mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass)
2768 {
2769         MonoInst *iargs [3];
2770         int n;
2771         guint32 align;
2772         MonoMethod *memset_method;
2773
2774         /* FIXME: Optimize this for the case when dest is an LDADDR */
2775
2776         mono_class_init (klass);
2777         n = mono_class_value_size (klass, &align);
2778
2779         if (n <= sizeof (gpointer) * 5) {
2780                 mini_emit_memset (cfg, dest->dreg, 0, n, 0, align);
2781         }
2782         else {
2783                 memset_method = get_memset_method ();
2784                 iargs [0] = dest;
2785                 EMIT_NEW_ICONST (cfg, iargs [1], 0);
2786                 EMIT_NEW_ICONST (cfg, iargs [2], n);
2787                 mono_emit_method_call (cfg, memset_method, iargs, NULL);
2788         }
2789 }
2790
2791 static MonoInst*
2792 emit_get_rgctx (MonoCompile *cfg, MonoMethod *method, int context_used)
2793 {
2794         MonoInst *this = NULL;
2795
2796         g_assert (cfg->generic_sharing_context);
2797
2798         if (!(method->flags & METHOD_ATTRIBUTE_STATIC) &&
2799                         !(context_used & MONO_GENERIC_CONTEXT_USED_METHOD) &&
2800                         !method->klass->valuetype)
2801                 EMIT_NEW_ARGLOAD (cfg, this, 0);
2802
2803         if (context_used & MONO_GENERIC_CONTEXT_USED_METHOD) {
2804                 MonoInst *mrgctx_loc, *mrgctx_var;
2805
2806                 g_assert (!this);
2807                 g_assert (method->is_inflated && mono_method_get_context (method)->method_inst);
2808
2809                 mrgctx_loc = mono_get_vtable_var (cfg);
2810                 EMIT_NEW_TEMPLOAD (cfg, mrgctx_var, mrgctx_loc->inst_c0);
2811
2812                 return mrgctx_var;
2813         } else if (method->flags & METHOD_ATTRIBUTE_STATIC || method->klass->valuetype) {
2814                 MonoInst *vtable_loc, *vtable_var;
2815
2816                 g_assert (!this);
2817
2818                 vtable_loc = mono_get_vtable_var (cfg);
2819                 EMIT_NEW_TEMPLOAD (cfg, vtable_var, vtable_loc->inst_c0);
2820
2821                 if (method->is_inflated && mono_method_get_context (method)->method_inst) {
2822                         MonoInst *mrgctx_var = vtable_var;
2823                         int vtable_reg;
2824
2825                         vtable_reg = alloc_preg (cfg);
2826                         EMIT_NEW_LOAD_MEMBASE (cfg, vtable_var, OP_LOAD_MEMBASE, vtable_reg, mrgctx_var->dreg, G_STRUCT_OFFSET (MonoMethodRuntimeGenericContext, class_vtable));
2827                         vtable_var->type = STACK_PTR;
2828                 }
2829
2830                 return vtable_var;
2831         } else {
2832                 MonoInst *ins;
2833                 int vtable_reg, res_reg;
2834
2835                 vtable_reg = alloc_preg (cfg);
2836                 res_reg = alloc_preg (cfg);
2837                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, vtable_reg, this->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2838                 return ins;
2839         }
2840 }
2841
2842 static MonoJumpInfoRgctxEntry *
2843 mono_patch_info_rgctx_entry_new (MonoMemPool *mp, MonoMethod *method, gboolean in_mrgctx, MonoJumpInfoType patch_type, gconstpointer patch_data, int info_type)
2844 {
2845         MonoJumpInfoRgctxEntry *res = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfoRgctxEntry));
2846         res->method = method;
2847         res->in_mrgctx = in_mrgctx;
2848         res->data = mono_mempool_alloc0 (mp, sizeof (MonoJumpInfo));
2849         res->data->type = patch_type;
2850         res->data->data.target = patch_data;
2851         res->info_type = info_type;
2852
2853         return res;
2854 }
2855
2856 static inline MonoInst*
2857 emit_rgctx_fetch (MonoCompile *cfg, MonoInst *rgctx, MonoJumpInfoRgctxEntry *entry)
2858 {
2859         return mono_emit_abs_call (cfg, MONO_PATCH_INFO_RGCTX_FETCH, entry, helper_sig_rgctx_lazy_fetch_trampoline, &rgctx);
2860 }
2861
2862 static MonoInst*
2863 emit_get_rgctx_klass (MonoCompile *cfg, int context_used,
2864                                           MonoClass *klass, int rgctx_type)
2865 {
2866         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);
2867         MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
2868
2869         return emit_rgctx_fetch (cfg, rgctx, entry);
2870 }
2871
2872 /*
2873  * emit_get_rgctx_method:
2874  *
2875  *   Emit IR to load the property RGCTX_TYPE of CMETHOD. If context_used is 0, emit
2876  * normal constants, else emit a load from the rgctx.
2877  */
2878 static MonoInst*
2879 emit_get_rgctx_method (MonoCompile *cfg, int context_used,
2880                                            MonoMethod *cmethod, int rgctx_type)
2881 {
2882         if (!context_used) {
2883                 MonoInst *ins;
2884
2885                 switch (rgctx_type) {
2886                 case MONO_RGCTX_INFO_METHOD:
2887                         EMIT_NEW_METHODCONST (cfg, ins, cmethod);
2888                         return ins;
2889                 case MONO_RGCTX_INFO_METHOD_RGCTX:
2890                         EMIT_NEW_METHOD_RGCTX_CONST (cfg, ins, cmethod);
2891                         return ins;
2892                 default:
2893                         g_assert_not_reached ();
2894                 }
2895         } else {
2896                 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);
2897                 MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
2898
2899                 return emit_rgctx_fetch (cfg, rgctx, entry);
2900         }
2901 }
2902
2903 static MonoInst*
2904 emit_get_rgctx_field (MonoCompile *cfg, int context_used,
2905                                           MonoClassField *field, int rgctx_type)
2906 {
2907         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);
2908         MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
2909
2910         return emit_rgctx_fetch (cfg, rgctx, entry);
2911 }
2912
2913 /*
2914  * On return the caller must check @klass for load errors.
2915  */
2916 static void
2917 emit_generic_class_init (MonoCompile *cfg, MonoClass *klass)
2918 {
2919         MonoInst *vtable_arg;
2920         MonoCallInst *call;
2921         int context_used = 0;
2922
2923         if (cfg->generic_sharing_context)
2924                 context_used = mono_class_check_context_used (klass);
2925
2926         if (context_used) {
2927                 vtable_arg = emit_get_rgctx_klass (cfg, context_used,
2928                                                                                    klass, MONO_RGCTX_INFO_VTABLE);
2929         } else {
2930                 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
2931
2932                 if (!vtable)
2933                         return;
2934                 EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
2935         }
2936
2937         if (COMPILE_LLVM (cfg))
2938                 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline_llvm, &vtable_arg);
2939         else
2940                 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
2941 #ifdef MONO_ARCH_VTABLE_REG
2942         mono_call_inst_add_outarg_reg (cfg, call, vtable_arg->dreg, MONO_ARCH_VTABLE_REG, FALSE);
2943         cfg->uses_vtable_reg = TRUE;
2944 #else
2945         NOT_IMPLEMENTED;
2946 #endif
2947 }
2948
2949 /*
2950  * On return the caller must check @array_class for load errors
2951  */
2952 static void
2953 mini_emit_check_array_type (MonoCompile *cfg, MonoInst *obj, MonoClass *array_class)
2954 {
2955         int vtable_reg = alloc_preg (cfg);
2956         int context_used = 0;
2957
2958         if (cfg->generic_sharing_context)
2959                 context_used = mono_class_check_context_used (array_class);
2960
2961         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
2962
2963         if (cfg->opt & MONO_OPT_SHARED) {
2964                 int class_reg = alloc_preg (cfg);
2965                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, class_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
2966                 if (cfg->compile_aot) {
2967                         int klass_reg = alloc_preg (cfg);
2968                         MONO_EMIT_NEW_CLASSCONST (cfg, klass_reg, array_class);
2969                         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, class_reg, klass_reg);
2970                 } else {
2971                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, class_reg, array_class);
2972                 }
2973         } else if (context_used) {
2974                 MonoInst *vtable_ins;
2975
2976                 vtable_ins = emit_get_rgctx_klass (cfg, context_used, array_class, MONO_RGCTX_INFO_VTABLE);
2977                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, vtable_reg, vtable_ins->dreg);
2978         } else {
2979                 if (cfg->compile_aot) {
2980                         int vt_reg;
2981                         MonoVTable *vtable;
2982
2983                         if (!(vtable = mono_class_vtable (cfg->domain, array_class)))
2984                                 return;
2985                         vt_reg = alloc_preg (cfg);
2986                         MONO_EMIT_NEW_VTABLECONST (cfg, vt_reg, vtable);
2987                         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, vtable_reg, vt_reg);
2988                 } else {
2989                         MonoVTable *vtable;
2990                         if (!(vtable = mono_class_vtable (cfg->domain, array_class)))
2991                                 return;
2992                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, vtable);
2993                 }
2994         }
2995
2996         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "ArrayTypeMismatchException");
2997 }
2998
2999 static void
3000 save_cast_details (MonoCompile *cfg, MonoClass *klass, int obj_reg)
3001 {
3002         if (mini_get_debug_options ()->better_cast_details) {
3003                 int to_klass_reg = alloc_preg (cfg);
3004                 int vtable_reg = alloc_preg (cfg);
3005                 int klass_reg = alloc_preg (cfg);
3006                 MonoInst *tls_get = mono_get_jit_tls_intrinsic (cfg);
3007
3008                 if (!tls_get) {
3009                         fprintf (stderr, "error: --debug=casts not supported on this platform.\n.");
3010                         exit (1);
3011                 }
3012
3013                 MONO_ADD_INS (cfg->cbb, tls_get);
3014                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3015                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3016
3017                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg);
3018                 MONO_EMIT_NEW_PCONST (cfg, to_klass_reg, klass);
3019                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg);
3020         }
3021 }
3022
3023 static void
3024 reset_cast_details (MonoCompile *cfg)
3025 {
3026         /* Reset the variables holding the cast details */
3027         if (mini_get_debug_options ()->better_cast_details) {
3028                 MonoInst *tls_get = mono_get_jit_tls_intrinsic (cfg);
3029
3030                 MONO_ADD_INS (cfg->cbb, tls_get);
3031                 /* It is enough to reset the from field */
3032                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0);
3033         }
3034 }
3035
3036 /**
3037  * Handles unbox of a Nullable<T>. If context_used is non zero, then shared
3038  * generic code is generated.
3039  */
3040 static MonoInst*
3041 handle_unbox_nullable (MonoCompile* cfg, MonoInst* val, MonoClass* klass, int context_used)
3042 {
3043         MonoMethod* method = mono_class_get_method_from_name (klass, "Unbox", 1);
3044
3045         if (context_used) {
3046                 MonoInst *rgctx, *addr;
3047
3048                 /* FIXME: What if the class is shared?  We might not
3049                    have to get the address of the method from the
3050                    RGCTX. */
3051                 addr = emit_get_rgctx_method (cfg, context_used, method,
3052                                                                           MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3053
3054                 rgctx = emit_get_rgctx (cfg, method, context_used);
3055
3056                 return mono_emit_rgctx_calli (cfg, mono_method_signature (method), &val, addr, rgctx);
3057         } else {
3058                 return mono_emit_method_call (cfg, method, &val, NULL);
3059         }
3060 }
3061
3062 static MonoInst*
3063 handle_unbox (MonoCompile *cfg, MonoClass *klass, MonoInst **sp, int context_used)
3064 {
3065         MonoInst *add;
3066         int obj_reg;
3067         int vtable_reg = alloc_dreg (cfg ,STACK_PTR);
3068         int klass_reg = alloc_dreg (cfg ,STACK_PTR);
3069         int eclass_reg = alloc_dreg (cfg ,STACK_PTR);
3070         int rank_reg = alloc_dreg (cfg ,STACK_I4);
3071
3072         obj_reg = sp [0]->dreg;
3073         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3074         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3075
3076         /* FIXME: generics */
3077         g_assert (klass->rank == 0);
3078
3079         // Check rank == 0
3080         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, 0);
3081         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
3082
3083         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3084         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
3085
3086         if (context_used) {
3087                 MonoInst *element_class;
3088
3089                 /* This assertion is from the unboxcast insn */
3090                 g_assert (klass->rank == 0);
3091
3092                 element_class = emit_get_rgctx_klass (cfg, context_used,
3093                                 klass->element_class, MONO_RGCTX_INFO_KLASS);
3094
3095                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, eclass_reg, element_class->dreg);
3096                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
3097         } else {
3098                 save_cast_details (cfg, klass->element_class, obj_reg);
3099                 mini_emit_class_check (cfg, eclass_reg, klass->element_class);
3100                 reset_cast_details (cfg);
3101         }
3102
3103         NEW_BIALU_IMM (cfg, add, OP_ADD_IMM, alloc_dreg (cfg, STACK_PTR), obj_reg, sizeof (MonoObject));
3104         MONO_ADD_INS (cfg->cbb, add);
3105         add->type = STACK_MP;
3106         add->klass = klass;
3107
3108         return add;
3109 }
3110
3111 /*
3112  * Returns NULL and set the cfg exception on error.
3113  */
3114 static MonoInst*
3115 handle_alloc (MonoCompile *cfg, MonoClass *klass, gboolean for_box, int context_used)
3116 {
3117         MonoInst *iargs [2];
3118         void *alloc_ftn;
3119
3120         if (context_used) {
3121                 MonoInst *data;
3122                 int rgctx_info;
3123                 MonoInst *iargs [2];
3124
3125                 /*
3126                   FIXME: we cannot get managed_alloc here because we can't get
3127                   the class's vtable (because it's not a closed class)
3128
3129                   MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3130                   MonoMethod *managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3131                 */
3132
3133                 if (cfg->opt & MONO_OPT_SHARED)
3134                         rgctx_info = MONO_RGCTX_INFO_KLASS;
3135                 else
3136                         rgctx_info = MONO_RGCTX_INFO_VTABLE;
3137                 data = emit_get_rgctx_klass (cfg, context_used, klass, rgctx_info);
3138
3139                 if (cfg->opt & MONO_OPT_SHARED) {
3140                         EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
3141                         iargs [1] = data;
3142                         alloc_ftn = mono_object_new;
3143                 } else {
3144                         iargs [0] = data;
3145                         alloc_ftn = mono_object_new_specific;
3146                 }
3147
3148                 return mono_emit_jit_icall (cfg, alloc_ftn, iargs);
3149         }
3150
3151         if (cfg->opt & MONO_OPT_SHARED) {
3152                 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
3153                 EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
3154
3155                 alloc_ftn = mono_object_new;
3156         } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
3157                 /* This happens often in argument checking code, eg. throw new FooException... */
3158                 /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
3159                 EMIT_NEW_ICONST (cfg, iargs [0], mono_metadata_token_index (klass->type_token));
3160                 return mono_emit_jit_icall (cfg, mono_helper_newobj_mscorlib, iargs);
3161         } else {
3162                 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
3163                 MonoMethod *managed_alloc = NULL;
3164                 gboolean pass_lw;
3165
3166                 if (!vtable) {
3167                         cfg->exception_type = MONO_EXCEPTION_TYPE_LOAD;
3168                         cfg->exception_ptr = klass;
3169                         return NULL;
3170                 }
3171
3172 #ifndef MONO_CROSS_COMPILE
3173                 managed_alloc = mono_gc_get_managed_allocator (vtable, for_box);
3174 #endif
3175
3176                 if (managed_alloc) {
3177                         EMIT_NEW_VTABLECONST (cfg, iargs [0], vtable);
3178                         return mono_emit_method_call (cfg, managed_alloc, iargs, NULL);
3179                 }
3180                 alloc_ftn = mono_class_get_allocation_ftn (vtable, for_box, &pass_lw);
3181                 if (pass_lw) {
3182                         guint32 lw = vtable->klass->instance_size;
3183                         lw = ((lw + (sizeof (gpointer) - 1)) & ~(sizeof (gpointer) - 1)) / sizeof (gpointer);
3184                         EMIT_NEW_ICONST (cfg, iargs [0], lw);
3185                         EMIT_NEW_VTABLECONST (cfg, iargs [1], vtable);
3186                 }
3187                 else {
3188                         EMIT_NEW_VTABLECONST (cfg, iargs [0], vtable);
3189                 }
3190         }
3191
3192         return mono_emit_jit_icall (cfg, alloc_ftn, iargs);
3193 }
3194
3195 /*
3196  * Returns NULL and set the cfg exception on error.
3197  */
3198 static MonoInst*
3199 handle_box (MonoCompile *cfg, MonoInst *val, MonoClass *klass, int context_used)
3200 {
3201         MonoInst *alloc, *ins;
3202
3203         if (mono_class_is_nullable (klass)) {
3204                 MonoMethod* method = mono_class_get_method_from_name (klass, "Box", 1);
3205
3206                 if (context_used) {
3207                         /* FIXME: What if the class is shared?  We might not
3208                            have to get the method address from the RGCTX. */
3209                         MonoInst *addr = emit_get_rgctx_method (cfg, context_used, method,
3210                                                                                                         MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
3211                         MonoInst *rgctx = emit_get_rgctx (cfg, cfg->current_method, context_used);
3212
3213                         return mono_emit_rgctx_calli (cfg, mono_method_signature (method), &val, addr, rgctx);
3214                 } else {
3215                         return mono_emit_method_call (cfg, method, &val, NULL);
3216                 }
3217         }
3218
3219         alloc = handle_alloc (cfg, klass, TRUE, context_used);
3220         if (!alloc)
3221                 return NULL;
3222
3223         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, alloc->dreg, sizeof (MonoObject), val->dreg);
3224
3225         return alloc;
3226 }
3227
3228 // FIXME: This doesn't work yet (class libs tests fail?)
3229 #define is_complex_isinst(klass) (TRUE || (klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || klass->marshalbyref || (klass->flags & TYPE_ATTRIBUTE_SEALED) || mono_class_has_variant_generic_params (klass) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
3230
3231 /*
3232  * Returns NULL and set the cfg exception on error.
3233  */
3234 static MonoInst*
3235 handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_used)
3236 {
3237         MonoBasicBlock *is_null_bb;
3238         int obj_reg = src->dreg;
3239         int vtable_reg = alloc_preg (cfg);
3240         MonoInst *klass_inst = NULL;
3241
3242         if (context_used) {
3243                 MonoInst *args [2];
3244
3245                 klass_inst = emit_get_rgctx_klass (cfg, context_used,
3246                                                                                    klass, MONO_RGCTX_INFO_KLASS);
3247
3248                 if (is_complex_isinst (klass)) {
3249                         /* Complex case, handle by an icall */
3250
3251                         /* obj */
3252                         args [0] = src;
3253
3254                         /* klass */
3255                         args [1] = klass_inst;
3256
3257                         return mono_emit_jit_icall (cfg, mono_object_castclass, args);
3258                 } else {
3259                         /* Simple case, handled by the code below */
3260                 }
3261         }
3262
3263         NEW_BBLOCK (cfg, is_null_bb);
3264
3265         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
3266         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, is_null_bb);
3267
3268         save_cast_details (cfg, klass, obj_reg);
3269
3270         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
3271                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3272                 mini_emit_iface_cast (cfg, vtable_reg, klass, NULL, NULL);
3273         } else {
3274                 int klass_reg = alloc_preg (cfg);
3275
3276                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3277
3278                 if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3279                         /* the remoting code is broken, access the class for now */
3280                         if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3281                                 MonoVTable *vt = mono_class_vtable (cfg->domain, klass);
3282                                 if (!vt) {
3283                                         cfg->exception_type = MONO_EXCEPTION_TYPE_LOAD;
3284                                         cfg->exception_ptr = klass;
3285                                         return NULL;
3286                                 }
3287                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, vt);
3288                         } else {
3289                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3290                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
3291                         }
3292                         MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
3293                 } else {
3294                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3295                         mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, klass_inst, is_null_bb);
3296                 }
3297         }
3298
3299         MONO_START_BB (cfg, is_null_bb);
3300
3301         reset_cast_details (cfg);
3302
3303         return src;
3304 }
3305
3306 /*
3307  * Returns NULL and set the cfg exception on error.
3308  */
3309 static MonoInst*
3310 handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_used)
3311 {
3312         MonoInst *ins;
3313         MonoBasicBlock *is_null_bb, *false_bb, *end_bb;
3314         int obj_reg = src->dreg;
3315         int vtable_reg = alloc_preg (cfg);
3316         int res_reg = alloc_preg (cfg);
3317         MonoInst *klass_inst = NULL;
3318
3319         if (context_used) {
3320                 klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
3321
3322                 if (is_complex_isinst (klass)) {
3323                         MonoInst *args [2];
3324
3325                         /* Complex case, handle by an icall */
3326
3327                         /* obj */
3328                         args [0] = src;
3329
3330                         /* klass */
3331                         args [1] = klass_inst;
3332
3333                         return mono_emit_jit_icall (cfg, mono_object_isinst, args);
3334                 } else {
3335                         /* Simple case, the code below can handle it */
3336                 }
3337         }
3338
3339         NEW_BBLOCK (cfg, is_null_bb);
3340         NEW_BBLOCK (cfg, false_bb);
3341         NEW_BBLOCK (cfg, end_bb);
3342
3343         /* Do the assignment at the beginning, so the other assignment can be if converted */
3344         EMIT_NEW_UNALU (cfg, ins, OP_MOVE, res_reg, obj_reg);
3345         ins->type = STACK_OBJ;
3346         ins->klass = klass;
3347
3348         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
3349         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, is_null_bb);
3350
3351         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3352
3353         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
3354                 g_assert (!context_used);
3355                 /* the is_null_bb target simply copies the input register to the output */
3356                 mini_emit_iface_cast (cfg, vtable_reg, klass, false_bb, is_null_bb);
3357         } else {
3358                 int klass_reg = alloc_preg (cfg);
3359
3360                 if (klass->rank) {
3361                         int rank_reg = alloc_preg (cfg);
3362                         int eclass_reg = alloc_preg (cfg);
3363
3364                         g_assert (!context_used);
3365                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
3366                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
3367                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb);
3368                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3369                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
3370                         if (klass->cast_class == mono_defaults.object_class) {
3371                                 int parent_reg = alloc_preg (cfg);
3372                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
3373                                 mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb);
3374                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb);
3375                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb);
3376                         } else if (klass->cast_class == mono_defaults.enum_class->parent) {
3377                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb);
3378                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb);
3379                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb);
3380                         } else if (klass->cast_class == mono_defaults.enum_class) {
3381                                 mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb);
3382                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb);
3383                         } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
3384                                 mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb);
3385                         } else {
3386                                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
3387                                         /* Check that the object is a vector too */
3388                                         int bounds_reg = alloc_preg (cfg);
3389                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
3390                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, bounds_reg, 0);
3391                                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb);
3392                                 }
3393
3394                                 /* the is_null_bb target simply copies the input register to the output */
3395                                 mini_emit_isninst_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb);
3396                         }
3397                 } else if (mono_class_is_nullable (klass)) {
3398                         g_assert (!context_used);
3399                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3400                         /* the is_null_bb target simply copies the input register to the output */
3401                         mini_emit_isninst_cast (cfg, klass_reg, klass->cast_class, false_bb, is_null_bb);
3402                 } else {
3403                         if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
3404                                 g_assert (!context_used);
3405                                 /* the remoting code is broken, access the class for now */
3406                                 if (0) {/*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/
3407                                         MonoVTable *vt = mono_class_vtable (cfg->domain, klass);
3408                                         if (!vt) {
3409                                                 cfg->exception_type = MONO_EXCEPTION_TYPE_LOAD;
3410                                                 cfg->exception_ptr = klass;
3411                                                 return NULL;
3412                                         }
3413                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, vtable_reg, vt);
3414                                 } else {
3415                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3416                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, klass_reg, klass);
3417                                 }
3418                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb);
3419                                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, is_null_bb);
3420                         } else {
3421                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3422                                 /* the is_null_bb target simply copies the input register to the output */
3423                                 mini_emit_isninst_cast_inst (cfg, klass_reg, klass, klass_inst, false_bb, is_null_bb);
3424                         }
3425                 }
3426         }
3427
3428         MONO_START_BB (cfg, false_bb);
3429
3430         MONO_EMIT_NEW_PCONST (cfg, res_reg, 0);
3431         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3432
3433         MONO_START_BB (cfg, is_null_bb);
3434
3435         MONO_START_BB (cfg, end_bb);
3436
3437         return ins;
3438 }
3439
3440 static MonoInst*
3441 handle_cisinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src)
3442 {
3443         /* This opcode takes as input an object reference and a class, and returns:
3444         0) if the object is an instance of the class,
3445         1) if the object is not instance of the class,
3446         2) if the object is a proxy whose type cannot be determined */
3447
3448         MonoInst *ins;
3449         MonoBasicBlock *true_bb, *false_bb, *false2_bb, *end_bb, *no_proxy_bb, *interface_fail_bb;
3450         int obj_reg = src->dreg;
3451         int dreg = alloc_ireg (cfg);
3452         int tmp_reg;
3453         int klass_reg = alloc_preg (cfg);
3454
3455         NEW_BBLOCK (cfg, true_bb);
3456         NEW_BBLOCK (cfg, false_bb);
3457         NEW_BBLOCK (cfg, false2_bb);
3458         NEW_BBLOCK (cfg, end_bb);
3459         NEW_BBLOCK (cfg, no_proxy_bb);
3460
3461         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
3462         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, false_bb);
3463
3464         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
3465                 NEW_BBLOCK (cfg, interface_fail_bb);
3466
3467                 tmp_reg = alloc_preg (cfg);
3468                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3469                 mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, true_bb);
3470                 MONO_START_BB (cfg, interface_fail_bb);
3471                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3472
3473                 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, false_bb);
3474
3475                 tmp_reg = alloc_preg (cfg);
3476                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3477                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
3478                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false2_bb);
3479         } else {
3480                 tmp_reg = alloc_preg (cfg);
3481                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3482                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3483
3484                 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3485                 tmp_reg = alloc_preg (cfg);
3486                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3487                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3488
3489                 tmp_reg = alloc_preg (cfg);
3490                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3491                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
3492                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, no_proxy_bb);
3493
3494                 mini_emit_isninst_cast (cfg, klass_reg, klass, false2_bb, true_bb);
3495                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false2_bb);
3496
3497                 MONO_START_BB (cfg, no_proxy_bb);
3498
3499                 mini_emit_isninst_cast (cfg, klass_reg, klass, false_bb, true_bb);
3500         }
3501
3502         MONO_START_BB (cfg, false_bb);
3503
3504         MONO_EMIT_NEW_ICONST (cfg, dreg, 1);
3505         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3506
3507         MONO_START_BB (cfg, false2_bb);
3508
3509         MONO_EMIT_NEW_ICONST (cfg, dreg, 2);
3510         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3511
3512         MONO_START_BB (cfg, true_bb);
3513
3514         MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
3515
3516         MONO_START_BB (cfg, end_bb);
3517
3518         /* FIXME: */
3519         MONO_INST_NEW (cfg, ins, OP_ICONST);
3520         ins->dreg = dreg;
3521         ins->type = STACK_I4;
3522
3523         return ins;
3524 }
3525
3526 static MonoInst*
3527 handle_ccastclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src)
3528 {
3529         /* This opcode takes as input an object reference and a class, and returns:
3530         0) if the object is an instance of the class,
3531         1) if the object is a proxy whose type cannot be determined
3532         an InvalidCastException exception is thrown otherwhise*/
3533
3534         MonoInst *ins;
3535         MonoBasicBlock *end_bb, *ok_result_bb, *no_proxy_bb, *interface_fail_bb, *fail_1_bb;
3536         int obj_reg = src->dreg;
3537         int dreg = alloc_ireg (cfg);
3538         int tmp_reg = alloc_preg (cfg);
3539         int klass_reg = alloc_preg (cfg);
3540
3541         NEW_BBLOCK (cfg, end_bb);
3542         NEW_BBLOCK (cfg, ok_result_bb);
3543
3544         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, obj_reg, 0);
3545         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, ok_result_bb);
3546
3547         save_cast_details (cfg, klass, obj_reg);
3548
3549         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
3550                 NEW_BBLOCK (cfg, interface_fail_bb);
3551
3552                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3553                 mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, ok_result_bb);
3554                 MONO_START_BB (cfg, interface_fail_bb);
3555                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3556
3557                 mini_emit_class_check (cfg, klass_reg, mono_defaults.transparent_proxy_class);
3558
3559                 tmp_reg = alloc_preg (cfg);
3560                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3561                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
3562                 MONO_EMIT_NEW_COND_EXC (cfg, EQ, "InvalidCastException");
3563
3564                 MONO_EMIT_NEW_ICONST (cfg, dreg, 1);
3565                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3566
3567         } else {
3568                 NEW_BBLOCK (cfg, no_proxy_bb);
3569
3570                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
3571                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
3572                 mini_emit_class_check_branch (cfg, klass_reg, mono_defaults.transparent_proxy_class, OP_PBNE_UN, no_proxy_bb);
3573
3574                 tmp_reg = alloc_preg (cfg);
3575                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
3576                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
3577
3578                 tmp_reg = alloc_preg (cfg);
3579                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
3580                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, tmp_reg, 0);
3581                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, no_proxy_bb);
3582
3583                 NEW_BBLOCK (cfg, fail_1_bb);
3584
3585                 mini_emit_isninst_cast (cfg, klass_reg, klass, fail_1_bb, ok_result_bb);
3586
3587                 MONO_START_BB (cfg, fail_1_bb);
3588
3589                 MONO_EMIT_NEW_ICONST (cfg, dreg, 1);
3590                 MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
3591
3592                 MONO_START_BB (cfg, no_proxy_bb);
3593
3594                 mini_emit_castclass (cfg, obj_reg, klass_reg, klass, ok_result_bb);
3595         }
3596
3597         MONO_START_BB (cfg, ok_result_bb);
3598
3599         MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
3600
3601         MONO_START_BB (cfg, end_bb);
3602
3603         /* FIXME: */
3604         MONO_INST_NEW (cfg, ins, OP_ICONST);
3605         ins->dreg = dreg;
3606         ins->type = STACK_I4;
3607
3608         return ins;
3609 }
3610
3611 /*
3612  * Returns NULL and set the cfg exception on error.
3613  */
3614 static G_GNUC_UNUSED MonoInst*
3615 handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, MonoMethod *method, int context_used)
3616 {
3617         gpointer *trampoline;
3618         MonoInst *obj, *method_ins, *tramp_ins;
3619         MonoDomain *domain;
3620         guint8 **code_slot;
3621
3622         obj = handle_alloc (cfg, klass, FALSE, 0);
3623         if (!obj)
3624                 return NULL;
3625
3626         /* Inline the contents of mono_delegate_ctor */
3627
3628         /* Set target field */
3629         /* Optimize away setting of NULL target */
3630         if (!(target->opcode == OP_PCONST && target->inst_p0 == 0))
3631                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, target), target->dreg);
3632
3633         /* Set method field */
3634         method_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD);
3635         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method), method_ins->dreg);
3636
3637         /*
3638          * To avoid looking up the compiled code belonging to the target method
3639          * in mono_delegate_trampoline (), we allocate a per-domain memory slot to
3640          * store it, and we fill it after the method has been compiled.
3641          */
3642         if (!cfg->compile_aot && !method->dynamic) {
3643                 MonoInst *code_slot_ins;
3644
3645                 if (context_used) {
3646                         code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
3647                 } else {
3648                         domain = mono_domain_get ();
3649                         mono_domain_lock (domain);
3650                         if (!domain_jit_info (domain)->method_code_hash)
3651                                 domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL);
3652                         code_slot = g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
3653                         if (!code_slot) {
3654                                 code_slot = mono_domain_alloc0 (domain, sizeof (gpointer));
3655                                 g_hash_table_insert (domain_jit_info (domain)->method_code_hash, method, code_slot);
3656                         }
3657                         mono_domain_unlock (domain);
3658
3659                         EMIT_NEW_PCONST (cfg, code_slot_ins, code_slot);
3660                 }
3661                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
3662         }
3663
3664         /* Set invoke_impl field */
3665         if (cfg->compile_aot) {
3666                 EMIT_NEW_AOTCONST (cfg, tramp_ins, MONO_PATCH_INFO_DELEGATE_TRAMPOLINE, klass);
3667         } else {
3668                 trampoline = mono_create_delegate_trampoline (klass);
3669                 EMIT_NEW_PCONST (cfg, tramp_ins, trampoline);
3670         }
3671         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, invoke_impl), tramp_ins->dreg);
3672
3673         /* All the checks which are in mono_delegate_ctor () are done by the delegate trampoline */
3674
3675         return obj;
3676 }
3677
3678 static MonoInst*
3679 handle_array_new (MonoCompile *cfg, int rank, MonoInst **sp, unsigned char *ip)
3680 {
3681         MonoJitICallInfo *info;
3682
3683         /* Need to register the icall so it gets an icall wrapper */
3684         info = mono_get_array_new_va_icall (rank);
3685
3686         cfg->flags |= MONO_CFG_HAS_VARARGS;
3687
3688         /* mono_array_new_va () needs a vararg calling convention */
3689         cfg->disable_llvm = TRUE;
3690
3691         /* FIXME: This uses info->sig, but it should use the signature of the wrapper */
3692         return mono_emit_native_call (cfg, mono_icall_get_wrapper (info), info->sig, sp);
3693 }
3694
3695 static void
3696 mono_emit_load_got_addr (MonoCompile *cfg)
3697 {
3698         MonoInst *getaddr, *dummy_use;
3699
3700         if (!cfg->got_var || cfg->got_var_allocated)
3701                 return;
3702
3703         MONO_INST_NEW (cfg, getaddr, OP_LOAD_GOTADDR);
3704         getaddr->dreg = cfg->got_var->dreg;
3705
3706         /* Add it to the start of the first bblock */
3707         if (cfg->bb_entry->code) {
3708                 getaddr->next = cfg->bb_entry->code;
3709                 cfg->bb_entry->code = getaddr;
3710         }
3711         else
3712                 MONO_ADD_INS (cfg->bb_entry, getaddr);
3713
3714         cfg->got_var_allocated = TRUE;
3715
3716         /*
3717          * Add a dummy use to keep the got_var alive, since real uses might
3718          * only be generated by the back ends.
3719          * Add it to end_bblock, so the variable's lifetime covers the whole
3720          * method.
3721          * It would be better to make the usage of the got var explicit in all
3722          * cases when the backend needs it (i.e. calls, throw etc.), so this
3723          * wouldn't be needed.
3724          */
3725         NEW_DUMMY_USE (cfg, dummy_use, cfg->got_var);
3726         MONO_ADD_INS (cfg->bb_exit, dummy_use);
3727 }
3728
3729 static int inline_limit;
3730 static gboolean inline_limit_inited;
3731
3732 static gboolean
3733 mono_method_check_inlining (MonoCompile *cfg, MonoMethod *method)
3734 {
3735         MonoMethodHeaderSummary header;
3736         MonoVTable *vtable;
3737 #ifdef MONO_ARCH_SOFT_FLOAT
3738         MonoMethodSignature *sig = mono_method_signature (method);
3739         int i;
3740 #endif
3741
3742         if (cfg->generic_sharing_context)
3743                 return FALSE;
3744
3745         if (cfg->inline_depth > 10)
3746                 return FALSE;
3747
3748 #ifdef MONO_ARCH_HAVE_LMF_OPS
3749         if (((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
3750                  (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) &&
3751             !MONO_TYPE_ISSTRUCT (signature->ret) && !mini_class_is_system_array (method->klass))
3752                 return TRUE;
3753 #endif
3754
3755
3756         if (!mono_method_get_header_summary (method, &header))
3757                 return FALSE;
3758
3759         /*runtime, icall and pinvoke are checked by summary call*/
3760         if ((method->iflags & METHOD_IMPL_ATTRIBUTE_NOINLINING) ||
3761             (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) ||
3762             (method->klass->marshalbyref) ||
3763             header.has_clauses)
3764                 return FALSE;
3765
3766         /* also consider num_locals? */
3767         /* Do the size check early to avoid creating vtables */
3768         if (!inline_limit_inited) {
3769                 if (getenv ("MONO_INLINELIMIT"))
3770                         inline_limit = atoi (getenv ("MONO_INLINELIMIT"));
3771                 else
3772                         inline_limit = INLINE_LENGTH_LIMIT;
3773                 inline_limit_inited = TRUE;
3774         }
3775         if (header.code_size >= inline_limit)
3776                 return FALSE;
3777
3778         /*
3779          * if we can initialize the class of the method right away, we do,
3780          * otherwise we don't allow inlining if the class needs initialization,
3781          * since it would mean inserting a call to mono_runtime_class_init()
3782          * inside the inlined code
3783          */
3784         if (!(cfg->opt & MONO_OPT_SHARED)) {
3785                 if (method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT) {
3786                         if (cfg->run_cctors && method->klass->has_cctor) {
3787                                 /*FIXME it would easier and lazier to just use mono_class_try_get_vtable */
3788                                 if (!method->klass->runtime_info)
3789                                         /* No vtable created yet */
3790                                         return FALSE;
3791                                 vtable = mono_class_vtable (cfg->domain, method->klass);
3792                                 if (!vtable)
3793                                         return FALSE;
3794                                 /* This makes so that inline cannot trigger */
3795                                 /* .cctors: too many apps depend on them */
3796                                 /* running with a specific order... */
3797                                 if (! vtable->initialized)
3798                                         return FALSE;
3799                                 mono_runtime_class_init (vtable);
3800                         }
3801                 } else if (mono_class_needs_cctor_run (method->klass, NULL)) {
3802                         if (!method->klass->runtime_info)
3803                                 /* No vtable created yet */
3804                                 return FALSE;
3805                         vtable = mono_class_vtable (cfg->domain, method->klass);
3806                         if (!vtable)
3807                                 return FALSE;
3808                         if (!vtable->initialized)
3809                                 return FALSE;
3810                 }
3811         } else {
3812                 /*
3813                  * If we're compiling for shared code
3814                  * the cctor will need to be run at aot method load time, for example,
3815                  * or at the end of the compilation of the inlining method.
3816                  */
3817                 if (mono_class_needs_cctor_run (method->klass, NULL) && !((method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
3818                         return FALSE;
3819         }
3820
3821         /*
3822          * CAS - do not inline methods with declarative security
3823          * Note: this has to be before any possible return TRUE;
3824          */
3825         if (mono_method_has_declsec (method))
3826                 return FALSE;
3827
3828 #ifdef MONO_ARCH_SOFT_FLOAT
3829         /* FIXME: */
3830         if (sig->ret && sig->ret->type == MONO_TYPE_R4)
3831                 return FALSE;
3832         for (i = 0; i < sig->param_count; ++i)
3833                 if (!sig->params [i]->byref && sig->params [i]->type == MONO_TYPE_R4)
3834                         return FALSE;
3835 #endif
3836
3837         return TRUE;
3838 }
3839
3840 static gboolean
3841 mini_field_access_needs_cctor_run (MonoCompile *cfg, MonoMethod *method, MonoVTable *vtable)
3842 {
3843         if (vtable->initialized && !cfg->compile_aot)
3844                 return FALSE;
3845
3846         if (vtable->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)
3847                 return FALSE;
3848
3849         if (!mono_class_needs_cctor_run (vtable->klass, method))
3850                 return FALSE;
3851
3852         if (! (method->flags & METHOD_ATTRIBUTE_STATIC) && (vtable->klass == method->klass))
3853                 /* The initialization is already done before the method is called */
3854                 return FALSE;
3855
3856         return TRUE;
3857 }
3858
3859 static MonoInst*
3860 mini_emit_ldelema_1_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index, gboolean bcheck)
3861 {
3862         MonoInst *ins;
3863         guint32 size;
3864         int mult_reg, add_reg, array_reg, index_reg, index2_reg;
3865
3866         mono_class_init (klass);
3867         size = mono_class_array_element_size (klass);
3868
3869         mult_reg = alloc_preg (cfg);
3870         array_reg = arr->dreg;
3871         index_reg = index->dreg;
3872
3873 #if SIZEOF_REGISTER == 8
3874         /* The array reg is 64 bits but the index reg is only 32 */
3875         if (COMPILE_LLVM (cfg)) {
3876                 /* Not needed */
3877                 index2_reg = index_reg;
3878         } else {
3879                 index2_reg = alloc_preg (cfg);
3880                 MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, index2_reg, index_reg);
3881         }
3882 #else
3883         if (index->type == STACK_I8) {
3884                 index2_reg = alloc_preg (cfg);
3885                 MONO_EMIT_NEW_UNALU (cfg, OP_LCONV_TO_I4, index2_reg, index_reg);
3886         } else {
3887                 index2_reg = index_reg;
3888         }
3889 #endif
3890
3891         if (bcheck)
3892                 MONO_EMIT_BOUNDS_CHECK (cfg, array_reg, MonoArray, max_length, index2_reg);
3893
3894 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3895         if (size == 1 || size == 2 || size == 4 || size == 8) {
3896                 static const int fast_log2 [] = { 1, 0, 1, -1, 2, -1, -1, -1, 3 };
3897
3898                 EMIT_NEW_X86_LEA (cfg, ins, array_reg, index2_reg, fast_log2 [size], G_STRUCT_OFFSET (MonoArray, vector));
3899                 ins->type = STACK_PTR;
3900
3901                 return ins;
3902         }
3903 #endif
3904
3905         add_reg = alloc_preg (cfg);
3906
3907         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_MUL_IMM, mult_reg, index2_reg, size);
3908         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, array_reg, mult_reg);
3909         NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, G_STRUCT_OFFSET (MonoArray, vector));
3910         ins->type = STACK_PTR;
3911         MONO_ADD_INS (cfg->cbb, ins);
3912
3913         return ins;
3914 }
3915
3916 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3917 static MonoInst*
3918 mini_emit_ldelema_2_ins (MonoCompile *cfg, MonoClass *klass, MonoInst *arr, MonoInst *index_ins1, MonoInst *index_ins2)
3919 {
3920         int bounds_reg = alloc_preg (cfg);
3921         int add_reg = alloc_preg (cfg);
3922         int mult_reg = alloc_preg (cfg);
3923         int mult2_reg = alloc_preg (cfg);
3924         int low1_reg = alloc_preg (cfg);
3925         int low2_reg = alloc_preg (cfg);
3926         int high1_reg = alloc_preg (cfg);
3927         int high2_reg = alloc_preg (cfg);
3928         int realidx1_reg = alloc_preg (cfg);
3929         int realidx2_reg = alloc_preg (cfg);
3930         int sum_reg = alloc_preg (cfg);
3931         int index1, index2;
3932         MonoInst *ins;
3933         guint32 size;
3934
3935         mono_class_init (klass);
3936         size = mono_class_array_element_size (klass);
3937
3938         index1 = index_ins1->dreg;
3939         index2 = index_ins2->dreg;
3940
3941         /* range checking */
3942         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg,
3943                                        arr->dreg, G_STRUCT_OFFSET (MonoArray, bounds));
3944
3945         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, low1_reg,
3946                                        bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
3947         MONO_EMIT_NEW_BIALU (cfg, OP_PSUB, realidx1_reg, index1, low1_reg);
3948         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, high1_reg,
3949                                        bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, length));
3950         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, high1_reg, realidx1_reg);
3951         MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException");
3952
3953         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, low2_reg,
3954                                        bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
3955         MONO_EMIT_NEW_BIALU (cfg, OP_PSUB, realidx2_reg, index2, low2_reg);
3956         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, high2_reg,
3957                                        bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, length));
3958         MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, high2_reg, realidx2_reg);
3959         MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException");
3960
3961         MONO_EMIT_NEW_BIALU (cfg, OP_PMUL, mult_reg, high2_reg, realidx1_reg);
3962         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, sum_reg, mult_reg, realidx2_reg);
3963         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_PMUL_IMM, mult2_reg, sum_reg, size);
3964         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, mult2_reg, arr->dreg);
3965         NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, add_reg, add_reg, G_STRUCT_OFFSET (MonoArray, vector));
3966
3967         ins->type = STACK_MP;
3968         ins->klass = klass;
3969         MONO_ADD_INS (cfg->cbb, ins);
3970
3971         return ins;
3972 }
3973 #endif
3974
3975 static MonoInst*
3976 mini_emit_ldelema_ins (MonoCompile *cfg, MonoMethod *cmethod, MonoInst **sp, unsigned char *ip, gboolean is_set)
3977 {
3978         int rank;
3979         MonoInst *addr;
3980         MonoMethod *addr_method;
3981         int element_size;
3982
3983         rank = mono_method_signature (cmethod)->param_count - (is_set? 1: 0);
3984
3985         if (rank == 1)
3986                 return mini_emit_ldelema_1_ins (cfg, cmethod->klass->element_class, sp [0], sp [1], TRUE);
3987
3988 #ifndef MONO_ARCH_EMULATE_MUL_DIV
3989         /* emit_ldelema_2 depends on OP_LMUL */
3990         if (rank == 2 && (cfg->opt & MONO_OPT_INTRINS)) {
3991                 return mini_emit_ldelema_2_ins (cfg, cmethod->klass->element_class, sp [0], sp [1], sp [2]);
3992         }
3993 #endif
3994
3995         element_size = mono_class_array_element_size (cmethod->klass->element_class);
3996         addr_method = mono_marshal_get_array_address (rank, element_size);
3997         addr = mono_emit_method_call (cfg, addr_method, sp, NULL);
3998
3999         return addr;
4000 }
4001
4002 static MonoBreakPolicy
4003 always_insert_breakpoint (MonoMethod *method)
4004 {
4005         return MONO_BREAK_POLICY_ALWAYS;
4006 }
4007
4008 static MonoBreakPolicyFunc break_policy_func = always_insert_breakpoint;
4009
4010 /**
4011  * mono_set_break_policy:
4012  * policy_callback: the new callback function
4013  *
4014  * Allow embedders to decide wherther to actually obey breakpoint instructions
4015  * (both break IL instructions and Debugger.Break () method calls), for example
4016  * to not allow an app to be aborted by a perfectly valid IL opcode when executing
4017  * untrusted or semi-trusted code.
4018  *
4019  * @policy_callback will be called every time a break point instruction needs to
4020  * be inserted with the method argument being the method that calls Debugger.Break()
4021  * or has the IL break instruction. The callback should return #MONO_BREAK_POLICY_NEVER
4022  * if it wants the breakpoint to not be effective in the given method.
4023  * #MONO_BREAK_POLICY_ALWAYS is the default.
4024  */
4025 void
4026 mono_set_break_policy (MonoBreakPolicyFunc policy_callback)
4027 {
4028         if (policy_callback)
4029                 break_policy_func = policy_callback;
4030         else
4031                 break_policy_func = always_insert_breakpoint;
4032 }
4033
4034 static gboolean
4035 should_insert_brekpoint (MonoMethod *method) {
4036         switch (break_policy_func (method)) {
4037         case MONO_BREAK_POLICY_ALWAYS:
4038                 return TRUE;
4039         case MONO_BREAK_POLICY_NEVER:
4040                 return FALSE;
4041         case MONO_BREAK_POLICY_ON_DBG:
4042                 return mono_debug_using_mono_debugger ();
4043         default:
4044                 g_warning ("Incorrect value returned from break policy callback");
4045                 return FALSE;
4046         }
4047 }
4048
4049 /* optimize the simple GetGenericValueImpl/SetGenericValueImpl generic icalls */
4050 static MonoInst*
4051 emit_array_generic_access (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **args, int is_set)
4052 {
4053         MonoInst *addr, *store, *load;
4054         MonoClass *eklass = mono_class_from_mono_type (fsig->params [2]);
4055
4056         /* the bounds check is already done by the callers */
4057         addr = mini_emit_ldelema_1_ins (cfg, eklass, args [0], args [1], FALSE);
4058         if (is_set) {
4059                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, &eklass->byval_arg, args [2]->dreg, 0);
4060                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, &eklass->byval_arg, addr->dreg, 0, load->dreg);
4061         } else {
4062                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, &eklass->byval_arg, addr->dreg, 0);
4063                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, &eklass->byval_arg, args [2]->dreg, 0, load->dreg);
4064         }
4065         return store;
4066 }
4067
4068 static MonoInst*
4069 mini_emit_inst_for_ctor (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4070 {
4071         MonoInst *ins = NULL;
4072 #ifdef MONO_ARCH_SIMD_INTRINSICS
4073         if (cfg->opt & MONO_OPT_SIMD) {
4074                 ins = mono_emit_simd_intrinsics (cfg, cmethod, fsig, args);
4075                 if (ins)
4076                         return ins;
4077         }
4078 #endif
4079
4080         return ins;
4081 }
4082
4083 static MonoInst*
4084 mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
4085 {
4086         MonoInst *ins = NULL;
4087
4088         static MonoClass *runtime_helpers_class = NULL;
4089         if (! runtime_helpers_class)
4090                 runtime_helpers_class = mono_class_from_name (mono_defaults.corlib,
4091                         "System.Runtime.CompilerServices", "RuntimeHelpers");
4092
4093         if (cmethod->klass == mono_defaults.string_class) {
4094                 if (strcmp (cmethod->name, "get_Chars") == 0) {
4095                         int dreg = alloc_ireg (cfg);
4096                         int index_reg = alloc_preg (cfg);
4097                         int mult_reg = alloc_preg (cfg);
4098                         int add_reg = alloc_preg (cfg);
4099
4100 #if SIZEOF_REGISTER == 8
4101                         /* The array reg is 64 bits but the index reg is only 32 */
4102                         MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, index_reg, args [1]->dreg);
4103 #else
4104                         index_reg = args [1]->dreg;
4105 #endif
4106                         MONO_EMIT_BOUNDS_CHECK (cfg, args [0]->dreg, MonoString, length, index_reg);
4107
4108 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4109                         EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, G_STRUCT_OFFSET (MonoString, chars));
4110                         add_reg = ins->dreg;
4111                         /* Avoid a warning */
4112                         mult_reg = 0;
4113                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU2_MEMBASE, dreg,
4114                                                                    add_reg, 0);
4115 #else
4116                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, mult_reg, index_reg, 1);
4117                         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, mult_reg, args [0]->dreg);
4118                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU2_MEMBASE, dreg,
4119                                                                    add_reg, G_STRUCT_OFFSET (MonoString, chars));
4120 #endif
4121                         type_from_op (ins, NULL, NULL);
4122                         return ins;
4123                 } else if (strcmp (cmethod->name, "get_Length") == 0) {
4124                         int dreg = alloc_ireg (cfg);
4125                         /* Decompose later to allow more optimizations */
4126                         EMIT_NEW_UNALU (cfg, ins, OP_STRLEN, dreg, args [0]->dreg);
4127                         ins->type = STACK_I4;
4128                         ins->flags |= MONO_INST_FAULT;
4129                         cfg->cbb->has_array_access = TRUE;
4130                         cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
4131
4132                         return ins;
4133                 } else if (strcmp (cmethod->name, "InternalSetChar") == 0) {
4134                         int mult_reg = alloc_preg (cfg);
4135                         int add_reg = alloc_preg (cfg);
4136
4137                         /* The corlib functions check for oob already. */
4138                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, mult_reg, args [1]->dreg, 1);
4139                         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, mult_reg, args [0]->dreg);
4140                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI2_MEMBASE_REG, add_reg, G_STRUCT_OFFSET (MonoString, chars), args [2]->dreg);
4141                         return cfg->cbb->last_ins;
4142                 } else
4143                         return NULL;
4144         } else if (cmethod->klass == mono_defaults.object_class) {
4145
4146                 if (strcmp (cmethod->name, "GetType") == 0) {
4147                         int dreg = alloc_preg (cfg);
4148                         int vt_reg = alloc_preg (cfg);
4149                         MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4150                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
4151                         type_from_op (ins, NULL, NULL);
4152
4153                         return ins;
4154 #if !defined(MONO_ARCH_EMULATE_MUL_DIV) && !defined(HAVE_MOVING_COLLECTOR)
4155                 } else if (strcmp (cmethod->name, "InternalGetHashCode") == 0) {
4156                         int dreg = alloc_ireg (cfg);
4157                         int t1 = alloc_ireg (cfg);
4158
4159                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, t1, args [0]->dreg, 3);
4160                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_MUL_IMM, dreg, t1, 2654435761u);
4161                         ins->type = STACK_I4;
4162
4163                         return ins;
4164 #endif
4165                 } else if (strcmp (cmethod->name, ".ctor") == 0) {
4166                         MONO_INST_NEW (cfg, ins, OP_NOP);
4167                         MONO_ADD_INS (cfg->cbb, ins);
4168                         return ins;
4169                 } else
4170                         return NULL;
4171         } else if (cmethod->klass == mono_defaults.array_class) {
4172                 if (strcmp (cmethod->name + 1, "etGenericValueImpl") == 0)
4173                         return emit_array_generic_access (cfg, fsig, args, *cmethod->name == 'S');
4174
4175 #ifndef MONO_BIG_ARRAYS
4176                 /*
4177                  * This is an inline version of GetLength/GetLowerBound(0) used frequently in
4178                  * Array methods.
4179                  */
4180                 if ((strcmp (cmethod->name, "GetLength") == 0 || strcmp (cmethod->name, "GetLowerBound") == 0) && args [1]->opcode == OP_ICONST && args [1]->inst_c0 == 0) {
4181                         int dreg = alloc_ireg (cfg);
4182                         int bounds_reg = alloc_ireg (cfg);
4183                         MonoBasicBlock *end_bb, *szarray_bb;
4184                         gboolean get_length = strcmp (cmethod->name, "GetLength") == 0;
4185
4186                         NEW_BBLOCK (cfg, end_bb);
4187                         NEW_BBLOCK (cfg, szarray_bb);
4188
4189                         EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, ins, OP_LOAD_MEMBASE, bounds_reg,
4190                                                                                  args [0]->dreg, G_STRUCT_OFFSET (MonoArray, bounds));
4191                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, bounds_reg, 0);
4192                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBEQ, szarray_bb);
4193                         /* Non-szarray case */
4194                         if (get_length)
4195                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, dreg,
4196                                                                            bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, length));
4197                         else
4198                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, dreg,
4199                                                                            bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
4200                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, end_bb);
4201                         MONO_START_BB (cfg, szarray_bb);
4202                         /* Szarray case */
4203                         if (get_length)
4204                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, dreg,
4205                                                                            args [0]->dreg, G_STRUCT_OFFSET (MonoArray, max_length));
4206                         else
4207                                 MONO_EMIT_NEW_ICONST (cfg, dreg, 0);
4208                         MONO_START_BB (cfg, end_bb);
4209
4210                         EMIT_NEW_UNALU (cfg, ins, OP_MOVE, dreg, dreg);
4211                         ins->type = STACK_I4;
4212
4213                         return ins;
4214                 }
4215 #endif
4216
4217                 if (cmethod->name [0] != 'g')
4218                         return NULL;
4219
4220                 if (strcmp (cmethod->name, "get_Rank") == 0) {
4221                         int dreg = alloc_ireg (cfg);
4222                         int vtable_reg = alloc_preg (cfg);
4223                         MONO_EMIT_NEW_LOAD_MEMBASE_OP_FAULT (cfg, OP_LOAD_MEMBASE, vtable_reg,
4224                                                                                                  args [0]->dreg, G_STRUCT_OFFSET (MonoObject, vtable));
4225                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU1_MEMBASE, dreg,
4226                                                                    vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
4227                         type_from_op (ins, NULL, NULL);
4228
4229                         return ins;
4230                 } else if (strcmp (cmethod->name, "get_Length") == 0) {
4231                         int dreg = alloc_ireg (cfg);
4232
4233                         EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, ins, OP_LOADI4_MEMBASE, dreg,
4234                                                                                  args [0]->dreg, G_STRUCT_OFFSET (MonoArray, max_length));
4235                         type_from_op (ins, NULL, NULL);
4236
4237                         return ins;
4238                 } else
4239                         return NULL;
4240         } else if (cmethod->klass == runtime_helpers_class) {
4241
4242                 if (strcmp (cmethod->name, "get_OffsetToStringData") == 0) {
4243                         EMIT_NEW_ICONST (cfg, ins, G_STRUCT_OFFSET (MonoString, chars));
4244                         return ins;
4245                 } else
4246                         return NULL;
4247         } else if (cmethod->klass == mono_defaults.thread_class) {
4248                 if (strcmp (cmethod->name, "SpinWait_nop") == 0) {
4249                         MONO_INST_NEW (cfg, ins, OP_RELAXED_NOP);
4250                         MONO_ADD_INS (cfg->cbb, ins);
4251                         return ins;
4252                 } else if (strcmp (cmethod->name, "MemoryBarrier") == 0) {
4253                         MONO_INST_NEW (cfg, ins, OP_MEMORY_BARRIER);
4254                         MONO_ADD_INS (cfg->cbb, ins);
4255                         return ins;
4256                 }
4257         } else if (cmethod->klass == mono_defaults.monitor_class) {
4258 #if defined(MONO_ARCH_MONITOR_OBJECT_REG)
4259                 if (strcmp (cmethod->name, "Enter") == 0 && fsig->param_count == 1) {
4260                         MonoCallInst *call;
4261
4262                         if (COMPILE_LLVM (cfg)) {
4263                                 /*
4264                                  * Pass the argument normally, the LLVM backend will handle the
4265                                  * calling convention problems.
4266                                  */
4267                                 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4268                         } else {
4269                                 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_ENTER,
4270                                             NULL, helper_sig_monitor_enter_exit_trampoline, NULL);
4271                                 mono_call_inst_add_outarg_reg (cfg, call, args [0]->dreg,
4272                                                                                            MONO_ARCH_MONITOR_OBJECT_REG, FALSE);
4273                         }
4274
4275                         return (MonoInst*)call;
4276                 } else if (strcmp (cmethod->name, "Exit") == 0) {
4277                         MonoCallInst *call;
4278
4279                         if (COMPILE_LLVM (cfg)) {
4280                                 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT, NULL, helper_sig_monitor_enter_exit_trampoline_llvm, args);
4281                         } else {
4282                                 call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_MONITOR_EXIT,
4283                                             NULL, helper_sig_monitor_enter_exit_trampoline, NULL);
4284                                 mono_call_inst_add_outarg_reg (cfg, call, args [0]->dreg,
4285                                                                                            MONO_ARCH_MONITOR_OBJECT_REG, FALSE);
4286                         }
4287
4288                         return (MonoInst*)call;
4289                 }
4290 #elif defined(MONO_ARCH_ENABLE_MONITOR_IL_FASTPATH)
4291                 MonoMethod *fast_method = NULL;
4292
4293                 /* Avoid infinite recursion */
4294                 if (cfg->method->wrapper_type == MONO_WRAPPER_UNKNOWN &&
4295                                 (strcmp (cfg->method->name, "FastMonitorEnter") == 0 ||
4296                                  strcmp (cfg->method->name, "FastMonitorExit") == 0))
4297                         return NULL;
4298
4299                 if ((strcmp (cmethod->name, "Enter") == 0 && fsig->param_count == 1) ||
4300                                 strcmp (cmethod->name, "Exit") == 0)
4301                         fast_method = mono_monitor_get_fast_path (cmethod);
4302                 if (!fast_method)
4303                         return NULL;
4304
4305                 return (MonoInst*)mono_emit_method_call (cfg, fast_method, args, NULL);
4306 #endif
4307         } else if (cmethod->klass->image == mono_defaults.corlib &&
4308                            (strcmp (cmethod->klass->name_space, "System.Threading") == 0) &&
4309                            (strcmp (cmethod->klass->name, "Interlocked") == 0)) {
4310                 ins = NULL;
4311
4312 #if SIZEOF_REGISTER == 8
4313                 if (strcmp (cmethod->name, "Read") == 0 && (fsig->params [0]->type == MONO_TYPE_I8)) {
4314                         /* 64 bit reads are already atomic */
4315                         MONO_INST_NEW (cfg, ins, OP_LOADI8_MEMBASE);
4316                         ins->dreg = mono_alloc_preg (cfg);
4317                         ins->inst_basereg = args [0]->dreg;
4318                         ins->inst_offset = 0;
4319                         MONO_ADD_INS (cfg->cbb, ins);
4320                 }
4321 #endif
4322
4323 #ifdef MONO_ARCH_HAVE_ATOMIC_ADD
4324                 if (strcmp (cmethod->name, "Increment") == 0) {
4325                         MonoInst *ins_iconst;
4326                         guint32 opcode = 0;
4327
4328                         if (fsig->params [0]->type == MONO_TYPE_I4)
4329                                 opcode = OP_ATOMIC_ADD_NEW_I4;
4330 #if SIZEOF_REGISTER == 8
4331                         else if (fsig->params [0]->type == MONO_TYPE_I8)
4332                                 opcode = OP_ATOMIC_ADD_NEW_I8;
4333 #endif
4334                         if (opcode) {
4335                                 MONO_INST_NEW (cfg, ins_iconst, OP_ICONST);
4336                                 ins_iconst->inst_c0 = 1;
4337                                 ins_iconst->dreg = mono_alloc_ireg (cfg);
4338                                 MONO_ADD_INS (cfg->cbb, ins_iconst);
4339
4340                                 MONO_INST_NEW (cfg, ins, opcode);
4341                                 ins->dreg = mono_alloc_ireg (cfg);
4342                                 ins->inst_basereg = args [0]->dreg;
4343                                 ins->inst_offset = 0;
4344                                 ins->sreg2 = ins_iconst->dreg;
4345                                 ins->type = (opcode == OP_ATOMIC_ADD_NEW_I4) ? STACK_I4 : STACK_I8;
4346                                 MONO_ADD_INS (cfg->cbb, ins);
4347                         }
4348                 } else if (strcmp (cmethod->name, "Decrement") == 0) {
4349                         MonoInst *ins_iconst;
4350                         guint32 opcode = 0;
4351
4352                         if (fsig->params [0]->type == MONO_TYPE_I4)
4353                                 opcode = OP_ATOMIC_ADD_NEW_I4;
4354 #if SIZEOF_REGISTER == 8
4355                         else if (fsig->params [0]->type == MONO_TYPE_I8)
4356                                 opcode = OP_ATOMIC_ADD_NEW_I8;
4357 #endif
4358                         if (opcode) {
4359                                 MONO_INST_NEW (cfg, ins_iconst, OP_ICONST);
4360                                 ins_iconst->inst_c0 = -1;
4361                                 ins_iconst->dreg = mono_alloc_ireg (cfg);
4362                                 MONO_ADD_INS (cfg->cbb, ins_iconst);
4363
4364                                 MONO_INST_NEW (cfg, ins, opcode);
4365                                 ins->dreg = mono_alloc_ireg (cfg);
4366                                 ins->inst_basereg = args [0]->dreg;
4367                                 ins->inst_offset = 0;
4368                                 ins->sreg2 = ins_iconst->dreg;
4369                                 ins->type = (opcode == OP_ATOMIC_ADD_NEW_I4) ? STACK_I4 : STACK_I8;
4370                                 MONO_ADD_INS (cfg->cbb, ins);
4371                         }
4372                 } else if (strcmp (cmethod->name, "Add") == 0) {
4373                         guint32 opcode = 0;
4374
4375                         if (fsig->params [0]->type == MONO_TYPE_I4)
4376                                 opcode = OP_ATOMIC_ADD_NEW_I4;
4377 #if SIZEOF_REGISTER == 8
4378                         else if (fsig->params [0]->type == MONO_TYPE_I8)
4379                                 opcode = OP_ATOMIC_ADD_NEW_I8;
4380 #endif
4381
4382                         if (opcode) {
4383                                 MONO_INST_NEW (cfg, ins, opcode);
4384                                 ins->dreg = mono_alloc_ireg (cfg);
4385                                 ins->inst_basereg = args [0]->dreg;
4386                                 ins->inst_offset = 0;
4387                                 ins->sreg2 = args [1]->dreg;
4388                                 ins->type = (opcode == OP_ATOMIC_ADD_NEW_I4) ? STACK_I4 : STACK_I8;
4389                                 MONO_ADD_INS (cfg->cbb, ins);
4390                         }
4391                 }
4392 #endif /* MONO_ARCH_HAVE_ATOMIC_ADD */
4393
4394 #ifdef MONO_ARCH_HAVE_ATOMIC_EXCHANGE
4395                 if (strcmp (cmethod->name, "Exchange") == 0) {
4396                         guint32 opcode;
4397                         gboolean is_ref = fsig->params [0]->type == MONO_TYPE_OBJECT;
4398
4399                         if (fsig->params [0]->type == MONO_TYPE_I4)
4400                                 opcode = OP_ATOMIC_EXCHANGE_I4;
4401 #if SIZEOF_REGISTER == 8
4402                         else if (is_ref || (fsig->params [0]->type == MONO_TYPE_I8) ||
4403                                         (fsig->params [0]->type == MONO_TYPE_I))
4404                                 opcode = OP_ATOMIC_EXCHANGE_I8;
4405 #else
4406                         else if (is_ref || (fsig->params [0]->type == MONO_TYPE_I))
4407                                 opcode = OP_ATOMIC_EXCHANGE_I4;
4408 #endif
4409                         else
4410                                 return NULL;
4411
4412                         MONO_INST_NEW (cfg, ins, opcode);
4413                         ins->dreg = mono_alloc_ireg (cfg);
4414                         ins->inst_basereg = args [0]->dreg;
4415                         ins->inst_offset = 0;
4416                         ins->sreg2 = args [1]->dreg;
4417                         MONO_ADD_INS (cfg->cbb, ins);
4418
4419                         switch (fsig->params [0]->type) {
4420                         case MONO_TYPE_I4:
4421                                 ins->type = STACK_I4;
4422                                 break;
4423                         case MONO_TYPE_I8:
4424                         case MONO_TYPE_I:
4425                                 ins->type = STACK_I8;
4426                                 break;
4427                         case MONO_TYPE_OBJECT:
4428                                 ins->type = STACK_OBJ;
4429                                 break;
4430                         default:
4431                                 g_assert_not_reached ();
4432                         }
4433
4434                         if (cfg->gen_write_barriers && is_ref) {
4435                                 MonoInst *dummy_use;
4436                                 MonoMethod *write_barrier = mono_gc_get_write_barrier ();
4437                                 mono_emit_method_call (cfg, write_barrier, &args [0], NULL);
4438                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, args [1]);
4439                         }
4440                 }
4441 #endif /* MONO_ARCH_HAVE_ATOMIC_EXCHANGE */
4442
4443 #ifdef MONO_ARCH_HAVE_ATOMIC_CAS
4444                 if ((strcmp (cmethod->name, "CompareExchange") == 0)) {
4445                         int size = 0;
4446                         gboolean is_ref = MONO_TYPE_IS_REFERENCE (fsig->params [1]);
4447                         if (fsig->params [1]->type == MONO_TYPE_I4)
4448                                 size = 4;
4449                         else if (is_ref || fsig->params [1]->type == MONO_TYPE_I)
4450                                 size = sizeof (gpointer);
4451                         else if (sizeof (gpointer) == 8 && fsig->params [1]->type == MONO_TYPE_I8)
4452                                 size = 8;
4453                         if (size == 4) {
4454                                 MONO_INST_NEW (cfg, ins, OP_ATOMIC_CAS_I4);
4455                                 ins->dreg = alloc_ireg (cfg);
4456                                 ins->sreg1 = args [0]->dreg;
4457                                 ins->sreg2 = args [1]->dreg;
4458                                 ins->sreg3 = args [2]->dreg;
4459                                 ins->type = STACK_I4;
4460                                 MONO_ADD_INS (cfg->cbb, ins);
4461                         } else if (size == 8) {
4462                                 MONO_INST_NEW (cfg, ins, OP_ATOMIC_CAS_I8);
4463                                 ins->dreg = alloc_ireg (cfg);
4464                                 ins->sreg1 = args [0]->dreg;
4465                                 ins->sreg2 = args [1]->dreg;
4466                                 ins->sreg3 = args [2]->dreg;
4467                                 ins->type = STACK_I8;
4468                                 MONO_ADD_INS (cfg->cbb, ins);
4469                         } else {
4470                                 /* g_assert_not_reached (); */
4471                         }
4472                         if (cfg->gen_write_barriers && is_ref) {
4473                                 MonoInst *dummy_use;
4474                                 MonoMethod *write_barrier = mono_gc_get_write_barrier ();
4475                                 mono_emit_method_call (cfg, write_barrier, &args [0], NULL);
4476                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, args [1]);
4477                         }
4478                 }
4479 #endif /* MONO_ARCH_HAVE_ATOMIC_CAS */
4480
4481                 if (ins)
4482                         return ins;
4483         } else if (cmethod->klass->image == mono_defaults.corlib) {
4484                 if (cmethod->name [0] == 'B' && strcmp (cmethod->name, "Break") == 0
4485                                 && strcmp (cmethod->klass->name, "Debugger") == 0) {
4486                         if (should_insert_brekpoint (cfg->method))
4487                                 MONO_INST_NEW (cfg, ins, OP_BREAK);
4488                         else
4489                                 MONO_INST_NEW (cfg, ins, OP_NOP);
4490                         MONO_ADD_INS (cfg->cbb, ins);
4491                         return ins;
4492                 }
4493                 if (cmethod->name [0] == 'g' && strcmp (cmethod->name, "get_IsRunningOnWindows") == 0
4494                                 && strcmp (cmethod->klass->name, "Environment") == 0) {
4495 #ifdef TARGET_WIN32
4496                         EMIT_NEW_ICONST (cfg, ins, 1);
4497 #else
4498                         EMIT_NEW_ICONST (cfg, ins, 0);
4499 #endif
4500                         return ins;
4501                 }
4502         } else if (cmethod->klass == mono_defaults.math_class) {
4503                 /*
4504                  * There is general branches code for Min/Max, but it does not work for
4505                  * all inputs:
4506                  * http://everything2.com/?node_id=1051618
4507                  */
4508         }
4509
4510 #ifdef MONO_ARCH_SIMD_INTRINSICS
4511         if (cfg->opt & MONO_OPT_SIMD) {
4512                 ins = mono_emit_simd_intrinsics (cfg, cmethod, fsig, args);
4513                 if (ins)
4514                         return ins;
4515         }
4516 #endif
4517
4518         return mono_arch_emit_inst_for_method (cfg, cmethod, fsig, args);
4519 }
4520
4521 /*
4522  * This entry point could be used later for arbitrary method
4523  * redirection.
4524  */
4525 inline static MonoInst*
4526 mini_redirect_call (MonoCompile *cfg, MonoMethod *method,
4527                                         MonoMethodSignature *signature, MonoInst **args, MonoInst *this)
4528 {
4529         if (method->klass == mono_defaults.string_class) {
4530                 /* managed string allocation support */
4531                 if (strcmp (method->name, "InternalAllocateStr") == 0 && !(mono_profiler_events & MONO_PROFILE_ALLOCATIONS)) {
4532                         MonoInst *iargs [2];
4533                         MonoVTable *vtable = mono_class_vtable (cfg->domain, method->klass);
4534                         MonoMethod *managed_alloc = NULL;
4535
4536                         g_assert (vtable); /*Should not fail since it System.String*/
4537 #ifndef MONO_CROSS_COMPILE
4538                         managed_alloc = mono_gc_get_managed_allocator (vtable, FALSE);
4539 #endif
4540                         if (!managed_alloc)
4541                                 return NULL;
4542                         EMIT_NEW_VTABLECONST (cfg, iargs [0], vtable);
4543                         iargs [1] = args [0];
4544                         return mono_emit_method_call (cfg, managed_alloc, iargs, this);
4545                 }
4546         }
4547         return NULL;
4548 }
4549
4550 static void
4551 mono_save_args (MonoCompile *cfg, MonoMethodSignature *sig, MonoInst **sp)
4552 {
4553         MonoInst *store, *temp;
4554         int i;
4555
4556         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
4557                 MonoType *argtype = (sig->hasthis && (i == 0)) ? type_from_stack_type (*sp) : sig->params [i - sig->hasthis];
4558
4559                 /*
4560                  * FIXME: We should use *args++ = sp [0], but that would mean the arg
4561                  * would be different than the MonoInst's used to represent arguments, and
4562                  * the ldelema implementation can't deal with that.
4563                  * Solution: When ldelema is used on an inline argument, create a var for
4564                  * it, emit ldelema on that var, and emit the saving code below in
4565                  * inline_method () if needed.
4566                  */
4567                 temp = mono_compile_create_var (cfg, argtype, OP_LOCAL);
4568                 cfg->args [i] = temp;
4569                 /* This uses cfg->args [i] which is set by the preceeding line */
4570                 EMIT_NEW_ARGSTORE (cfg, store, i, *sp);
4571                 store->cil_code = sp [0]->cil_code;
4572                 sp++;
4573         }
4574 }
4575
4576 #define MONO_INLINE_CALLED_LIMITED_METHODS 1
4577 #define MONO_INLINE_CALLER_LIMITED_METHODS 1
4578
4579 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4580 static gboolean
4581 check_inline_called_method_name_limit (MonoMethod *called_method)
4582 {
4583         int strncmp_result;
4584         static char *limit = NULL;
4585
4586         if (limit == NULL) {
4587                 char *limit_string = getenv ("MONO_INLINE_CALLED_METHOD_NAME_LIMIT");
4588
4589                 if (limit_string != NULL)
4590                         limit = limit_string;
4591                 else
4592                         limit = (char *) "";
4593         }
4594
4595         if (limit [0] != '\0') {
4596                 char *called_method_name = mono_method_full_name (called_method, TRUE);
4597
4598                 strncmp_result = strncmp (called_method_name, limit, strlen (limit));
4599                 g_free (called_method_name);
4600
4601                 //return (strncmp_result <= 0);
4602                 return (strncmp_result == 0);
4603         } else {
4604                 return TRUE;
4605         }
4606 }
4607 #endif
4608
4609 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4610 static gboolean
4611 check_inline_caller_method_name_limit (MonoMethod *caller_method)
4612 {
4613         int strncmp_result;
4614         static char *limit = NULL;
4615
4616         if (limit == NULL) {
4617                 char *limit_string = getenv ("MONO_INLINE_CALLER_METHOD_NAME_LIMIT");
4618                 if (limit_string != NULL) {
4619                         limit = limit_string;
4620                 } else {
4621                         limit = (char *) "";
4622                 }
4623         }
4624
4625         if (limit [0] != '\0') {
4626                 char *caller_method_name = mono_method_full_name (caller_method, TRUE);
4627
4628                 strncmp_result = strncmp (caller_method_name, limit, strlen (limit));
4629                 g_free (caller_method_name);
4630
4631                 //return (strncmp_result <= 0);
4632                 return (strncmp_result == 0);
4633         } else {
4634                 return TRUE;
4635         }
4636 }
4637 #endif
4638
4639 static int
4640 inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **sp,
4641                 guchar *ip, guint real_offset, GList *dont_inline, gboolean inline_allways)
4642 {
4643         MonoInst *ins, *rvar = NULL;
4644         MonoMethodHeader *cheader;
4645         MonoBasicBlock *ebblock, *sbblock;
4646         int i, costs;
4647         MonoMethod *prev_inlined_method;
4648         MonoInst **prev_locals, **prev_args;
4649         MonoType **prev_arg_types;
4650         guint prev_real_offset;
4651         GHashTable *prev_cbb_hash;
4652         MonoBasicBlock **prev_cil_offset_to_bb;
4653         MonoBasicBlock *prev_cbb;
4654         unsigned char* prev_cil_start;
4655         guint32 prev_cil_offset_to_bb_len;
4656         MonoMethod *prev_current_method;
4657         MonoGenericContext *prev_generic_context;
4658         gboolean ret_var_set, prev_ret_var_set;
4659
4660         g_assert (cfg->exception_type == MONO_EXCEPTION_NONE);
4661
4662 #if (MONO_INLINE_CALLED_LIMITED_METHODS)
4663         if ((! inline_allways) && ! check_inline_called_method_name_limit (cmethod))
4664                 return 0;
4665 #endif
4666 #if (MONO_INLINE_CALLER_LIMITED_METHODS)
4667         if ((! inline_allways) && ! check_inline_caller_method_name_limit (cfg->method))
4668                 return 0;
4669 #endif
4670
4671         if (cfg->verbose_level > 2)
4672                 printf ("INLINE START %p %s -> %s\n", cmethod,  mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4673
4674         if (!cmethod->inline_info) {
4675                 mono_jit_stats.inlineable_methods++;
4676                 cmethod->inline_info = 1;
4677         }
4678
4679         /* allocate local variables */
4680         cheader = mono_method_get_header (cmethod);
4681
4682         if (cheader == NULL || mono_loader_get_last_error ()) {
4683                 if (cheader)
4684                         mono_metadata_free_mh (cheader);
4685                 mono_loader_clear_error ();
4686                 return 0;
4687         }
4688
4689         /* allocate space to store the return value */
4690         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
4691                 rvar = mono_compile_create_var (cfg, fsig->ret, OP_LOCAL);
4692         }
4693
4694
4695         prev_locals = cfg->locals;
4696         cfg->locals = mono_mempool_alloc0 (cfg->mempool, cheader->num_locals * sizeof (MonoInst*));
4697         for (i = 0; i < cheader->num_locals; ++i)
4698                 cfg->locals [i] = mono_compile_create_var (cfg, cheader->locals [i], OP_LOCAL);
4699
4700         /* allocate start and end blocks */
4701         /* This is needed so if the inline is aborted, we can clean up */
4702         NEW_BBLOCK (cfg, sbblock);
4703         sbblock->real_offset = real_offset;
4704
4705         NEW_BBLOCK (cfg, ebblock);
4706         ebblock->block_num = cfg->num_bblocks++;
4707         ebblock->real_offset = real_offset;
4708
4709         prev_args = cfg->args;
4710         prev_arg_types = cfg->arg_types;
4711         prev_inlined_method = cfg->inlined_method;
4712         cfg->inlined_method = cmethod;
4713         cfg->ret_var_set = FALSE;
4714         cfg->inline_depth ++;
4715         prev_real_offset = cfg->real_offset;
4716         prev_cbb_hash = cfg->cbb_hash;
4717         prev_cil_offset_to_bb = cfg->cil_offset_to_bb;
4718         prev_cil_offset_to_bb_len = cfg->cil_offset_to_bb_len;
4719         prev_cil_start = cfg->cil_start;
4720         prev_cbb = cfg->cbb;
4721         prev_current_method = cfg->current_method;
4722         prev_generic_context = cfg->generic_context;
4723         prev_ret_var_set = cfg->ret_var_set;
4724
4725         costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
4726
4727         ret_var_set = cfg->ret_var_set;
4728
4729         cfg->inlined_method = prev_inlined_method;
4730         cfg->real_offset = prev_real_offset;
4731         cfg->cbb_hash = prev_cbb_hash;
4732         cfg->cil_offset_to_bb = prev_cil_offset_to_bb;
4733         cfg->cil_offset_to_bb_len = prev_cil_offset_to_bb_len;
4734         cfg->cil_start = prev_cil_start;
4735         cfg->locals = prev_locals;
4736         cfg->args = prev_args;
4737         cfg->arg_types = prev_arg_types;
4738         cfg->current_method = prev_current_method;
4739         cfg->generic_context = prev_generic_context;
4740         cfg->ret_var_set = prev_ret_var_set;
4741         cfg->inline_depth --;
4742
4743         if ((costs >= 0 && costs < 60) || inline_allways) {
4744                 if (cfg->verbose_level > 2)
4745                         printf ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
4746
4747                 mono_jit_stats.inlined_methods++;
4748
4749                 /* always add some code to avoid block split failures */
4750                 MONO_INST_NEW (cfg, ins, OP_NOP);
4751                 MONO_ADD_INS (prev_cbb, ins);
4752
4753                 prev_cbb->next_bb = sbblock;
4754                 link_bblock (cfg, prev_cbb, sbblock);
4755
4756                 /*
4757                  * Get rid of the begin and end bblocks if possible to aid local
4758                  * optimizations.
4759                  */
4760                 mono_merge_basic_blocks (cfg, prev_cbb, sbblock);
4761
4762                 if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] != ebblock))
4763                         mono_merge_basic_blocks (cfg, prev_cbb, prev_cbb->out_bb [0]);
4764
4765                 if ((ebblock->in_count == 1) && ebblock->in_bb [0]->out_count == 1) {
4766                         MonoBasicBlock *prev = ebblock->in_bb [0];
4767                         mono_merge_basic_blocks (cfg, prev, ebblock);
4768                         cfg->cbb = prev;
4769                         if ((prev_cbb->out_count == 1) && (prev_cbb->out_bb [0]->in_count == 1) && (prev_cbb->out_bb [0] == prev)) {
4770                                 mono_merge_basic_blocks (cfg, prev_cbb, prev);
4771                                 cfg->cbb = prev_cbb;
4772                         }
4773                 } else {
4774                         cfg->cbb = ebblock;
4775                 }
4776
4777                 if (rvar) {
4778                         /*
4779                          * If the inlined method contains only a throw, then the ret var is not
4780                          * set, so set it to a dummy value.
4781                          */
4782                         if (!ret_var_set) {
4783                                 static double r8_0 = 0.0;
4784
4785                                 switch (rvar->type) {
4786                                 case STACK_I4:
4787                                         MONO_EMIT_NEW_ICONST (cfg, rvar->dreg, 0);
4788                                         break;
4789                                 case STACK_I8:
4790                                         MONO_EMIT_NEW_I8CONST (cfg, rvar->dreg, 0);
4791                                         break;
4792                                 case STACK_PTR:
4793                                 case STACK_MP:
4794                                 case STACK_OBJ:
4795                                         MONO_EMIT_NEW_PCONST (cfg, rvar->dreg, 0);
4796                                         break;
4797                                 case STACK_R8:
4798                                         MONO_INST_NEW (cfg, ins, OP_R8CONST);
4799                                         ins->type = STACK_R8;
4800                                         ins->inst_p0 = (void*)&r8_0;
4801                                         ins->dreg = rvar->dreg;
4802                                         MONO_ADD_INS (cfg->cbb, ins);
4803                                         break;
4804                                 case STACK_VTYPE:
4805                                         MONO_EMIT_NEW_VZERO (cfg, rvar->dreg, mono_class_from_mono_type (fsig->ret));
4806                                         break;
4807                                 default:
4808                                         g_assert_not_reached ();
4809                                 }
4810                         }
4811
4812                         EMIT_NEW_TEMPLOAD (cfg, ins, rvar->inst_c0);
4813                         *sp++ = ins;
4814                 }
4815                 cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, cheader);
4816                 return costs + 1;
4817         } else {
4818                 if (cfg->verbose_level > 2)
4819                         printf ("INLINE ABORTED %s\n", mono_method_full_name (cmethod, TRUE));
4820                 cfg->exception_type = MONO_EXCEPTION_NONE;
4821                 mono_loader_clear_error ();
4822
4823                 /* This gets rid of the newly added bblocks */
4824                 cfg->cbb = prev_cbb;
4825         }
4826         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, cheader);
4827         return 0;
4828 }
4829
4830 /*
4831  * Some of these comments may well be out-of-date.
4832  * Design decisions: we do a single pass over the IL code (and we do bblock
4833  * splitting/merging in the few cases when it's required: a back jump to an IL
4834  * address that was not already seen as bblock starting point).
4835  * Code is validated as we go (full verification is still better left to metadata/verify.c).
4836  * Complex operations are decomposed in simpler ones right away. We need to let the
4837  * arch-specific code peek and poke inside this process somehow (except when the
4838  * optimizations can take advantage of the full semantic info of coarse opcodes).
4839  * All the opcodes of the form opcode.s are 'normalized' to opcode.
4840  * MonoInst->opcode initially is the IL opcode or some simplification of that
4841  * (OP_LOAD, OP_STORE). The arch-specific code may rearrange it to an arch-specific
4842  * opcode with value bigger than OP_LAST.
4843  * At this point the IR can be handed over to an interpreter, a dumb code generator
4844  * or to the optimizing code generator that will translate it to SSA form.
4845  *
4846  * Profiling directed optimizations.
4847  * We may compile by default with few or no optimizations and instrument the code
4848  * or the user may indicate what methods to optimize the most either in a config file
4849  * or through repeated runs where the compiler applies offline the optimizations to
4850  * each method and then decides if it was worth it.
4851  */
4852
4853 #define CHECK_TYPE(ins) if (!(ins)->type) UNVERIFIED
4854 #define CHECK_STACK(num) if ((sp - stack_start) < (num)) UNVERIFIED
4855 #define CHECK_STACK_OVF(num) if (((sp - stack_start) + (num)) > header->max_stack) UNVERIFIED
4856 #define CHECK_ARG(num) if ((unsigned)(num) >= (unsigned)num_args) UNVERIFIED
4857 #define CHECK_LOCAL(num) if ((unsigned)(num) >= (unsigned)header->num_locals) UNVERIFIED
4858 #define CHECK_OPSIZE(size) if (ip + size > end) UNVERIFIED
4859 #define CHECK_UNVERIFIABLE(cfg) if (cfg->unverifiable) UNVERIFIED
4860 #define CHECK_TYPELOAD(klass) if (!(klass) || (klass)->exception_type) {cfg->exception_ptr = klass; goto load_error;}
4861
4862 /* offset from br.s -> br like opcodes */
4863 #define BIG_BRANCH_OFFSET 13
4864
4865 static gboolean
4866 ip_in_bb (MonoCompile *cfg, MonoBasicBlock *bb, const guint8* ip)
4867 {
4868         MonoBasicBlock *b = cfg->cil_offset_to_bb [ip - cfg->cil_start];
4869
4870         return b == NULL || b == bb;
4871 }
4872
4873 static int
4874 get_basic_blocks (MonoCompile *cfg, MonoMethodHeader* header, guint real_offset, unsigned char *start, unsigned char *end, unsigned char **pos)
4875 {
4876         unsigned char *ip = start;
4877         unsigned char *target;
4878         int i;
4879         guint cli_addr;
4880         MonoBasicBlock *bblock;
4881         const MonoOpcode *opcode;
4882
4883         while (ip < end) {
4884                 cli_addr = ip - start;
4885                 i = mono_opcode_value ((const guint8 **)&ip, end);
4886                 if (i < 0)
4887                         UNVERIFIED;
4888                 opcode = &mono_opcodes [i];
4889                 switch (opcode->argument) {
4890                 case MonoInlineNone:
4891                         ip++;
4892                         break;
4893                 case MonoInlineString:
4894                 case MonoInlineType:
4895                 case MonoInlineField:
4896                 case MonoInlineMethod:
4897                 case MonoInlineTok:
4898                 case MonoInlineSig:
4899                 case MonoShortInlineR:
4900                 case MonoInlineI:
4901                         ip += 5;
4902                         break;
4903                 case MonoInlineVar:
4904                         ip += 3;
4905                         break;
4906                 case MonoShortInlineVar:
4907                 case MonoShortInlineI:
4908                         ip += 2;
4909                         break;
4910                 case MonoShortInlineBrTarget:
4911                         target = start + cli_addr + 2 + (signed char)ip [1];
4912                         GET_BBLOCK (cfg, bblock, target);
4913                         ip += 2;
4914                         if (ip < end)
4915                                 GET_BBLOCK (cfg, bblock, ip);
4916                         break;
4917                 case MonoInlineBrTarget:
4918                         target = start + cli_addr + 5 + (gint32)read32 (ip + 1);
4919                         GET_BBLOCK (cfg, bblock, target);
4920                         ip += 5;
4921                         if (ip < end)
4922                                 GET_BBLOCK (cfg, bblock, ip);
4923                         break;
4924                 case MonoInlineSwitch: {
4925                         guint32 n = read32 (ip + 1);
4926                         guint32 j;
4927                         ip += 5;
4928                         cli_addr += 5 + 4 * n;
4929                         target = start + cli_addr;
4930                         GET_BBLOCK (cfg, bblock, target);
4931
4932                         for (j = 0; j < n; ++j) {
4933                                 target = start + cli_addr + (gint32)read32 (ip);
4934                                 GET_BBLOCK (cfg, bblock, target);
4935                                 ip += 4;
4936                         }
4937                         break;
4938                 }
4939                 case MonoInlineR:
4940                 case MonoInlineI8:
4941                         ip += 9;
4942                         break;
4943                 default:
4944                         g_assert_not_reached ();
4945                 }
4946
4947                 if (i == CEE_THROW) {
4948                         unsigned char *bb_start = ip - 1;
4949
4950                         /* Find the start of the bblock containing the throw */
4951                         bblock = NULL;
4952                         while ((bb_start >= start) && !bblock) {
4953                                 bblock = cfg->cil_offset_to_bb [(bb_start) - start];
4954                                 bb_start --;
4955                         }
4956                         if (bblock)
4957                                 bblock->out_of_line = 1;
4958                 }
4959         }
4960         return 0;
4961 unverified:
4962         *pos = ip;
4963         return 1;
4964 }
4965
4966 static inline MonoMethod *
4967 mini_get_method_allow_open (MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4968 {
4969         MonoMethod *method;
4970
4971         if (m->wrapper_type != MONO_WRAPPER_NONE)
4972                 return mono_method_get_wrapper_data (m, token);
4973
4974         method = mono_get_method_full (m->klass->image, token, klass, context);
4975
4976         return method;
4977 }
4978
4979 static inline MonoMethod *
4980 mini_get_method (MonoCompile *cfg, MonoMethod *m, guint32 token, MonoClass *klass, MonoGenericContext *context)
4981 {
4982         MonoMethod *method = mini_get_method_allow_open (m, token, klass, context);
4983
4984         if (method && cfg && !cfg->generic_sharing_context && mono_class_is_open_constructed_type (&method->klass->byval_arg))
4985                 return NULL;
4986
4987         return method;
4988 }
4989
4990 static inline MonoClass*
4991 mini_get_class (MonoMethod *method, guint32 token, MonoGenericContext *context)
4992 {
4993         MonoClass *klass;
4994
4995         if (method->wrapper_type != MONO_WRAPPER_NONE)
4996                 klass = mono_method_get_wrapper_data (method, token);
4997         else
4998                 klass = mono_class_get_full (method->klass->image, token, context);
4999         if (klass)
5000                 mono_class_init (klass);
5001         return klass;
5002 }
5003
5004 /*
5005  * Returns TRUE if the JIT should abort inlining because "callee"
5006  * is influenced by security attributes.
5007  */
5008 static
5009 gboolean check_linkdemand (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee)
5010 {
5011         guint32 result;
5012
5013         if ((cfg->method != caller) && mono_method_has_declsec (callee)) {
5014                 return TRUE;
5015         }
5016
5017         result = mono_declsec_linkdemand (cfg->domain, caller, callee);
5018         if (result == MONO_JIT_SECURITY_OK)
5019                 return FALSE;
5020
5021         if (result == MONO_JIT_LINKDEMAND_ECMA) {
5022                 /* Generate code to throw a SecurityException before the actual call/link */
5023                 MonoSecurityManager *secman = mono_security_manager_get_methods ();
5024                 MonoInst *args [2];
5025
5026                 NEW_ICONST (cfg, args [0], 4);
5027                 NEW_METHODCONST (cfg, args [1], caller);
5028                 mono_emit_method_call (cfg, secman->linkdemandsecurityexception, args, NULL);
5029         } else if (cfg->exception_type == MONO_EXCEPTION_NONE) {
5030                  /* don't hide previous results */
5031                 cfg->exception_type = MONO_EXCEPTION_SECURITY_LINKDEMAND;
5032                 cfg->exception_data = result;
5033                 return TRUE;
5034         }
5035
5036         return FALSE;
5037 }
5038
5039 static MonoMethod*
5040 throw_exception (void)
5041 {
5042         static MonoMethod *method = NULL;
5043
5044         if (!method) {
5045                 MonoSecurityManager *secman = mono_security_manager_get_methods ();
5046                 method = mono_class_get_method_from_name (secman->securitymanager, "ThrowException", 1);
5047         }
5048         g_assert (method);
5049         return method;
5050 }
5051
5052 static void
5053 emit_throw_exception (MonoCompile *cfg, MonoException *ex)
5054 {
5055         MonoMethod *thrower = throw_exception ();
5056         MonoInst *args [1];
5057
5058         EMIT_NEW_PCONST (cfg, args [0], ex);
5059         mono_emit_method_call (cfg, thrower, args, NULL);
5060 }
5061
5062 /*
5063  * Return the original method is a wrapper is specified. We can only access
5064  * the custom attributes from the original method.
5065  */
5066 static MonoMethod*
5067 get_original_method (MonoMethod *method)
5068 {
5069         if (method->wrapper_type == MONO_WRAPPER_NONE)
5070                 return method;
5071
5072         /* native code (which is like Critical) can call any managed method XXX FIXME XXX to validate all usages */
5073         if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)
5074                 return NULL;
5075
5076         /* in other cases we need to find the original method */
5077         return mono_marshal_method_from_wrapper (method);
5078 }
5079
5080 static void
5081 ensure_method_is_allowed_to_access_field (MonoCompile *cfg, MonoMethod *caller, MonoClassField *field,
5082                                           MonoBasicBlock *bblock, unsigned char *ip)
5083 {
5084         /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5085         MonoException *ex = mono_security_core_clr_is_field_access_allowed (get_original_method (caller), field);
5086         if (ex)
5087                 emit_throw_exception (cfg, ex);
5088 }
5089
5090 static void
5091 ensure_method_is_allowed_to_call_method (MonoCompile *cfg, MonoMethod *caller, MonoMethod *callee,
5092                                          MonoBasicBlock *bblock, unsigned char *ip)
5093 {
5094         /* we can't get the coreclr security level on wrappers since they don't have the attributes */
5095         MonoException *ex = mono_security_core_clr_is_call_allowed (get_original_method (caller), callee);
5096         if (ex)
5097                 emit_throw_exception (cfg, ex);
5098 }
5099
5100 /*
5101  * Check that the IL instructions at ip are the array initialization
5102  * sequence and return the pointer to the data and the size.
5103  */
5104 static const char*
5105 initialize_array_data (MonoMethod *method, gboolean aot, unsigned char *ip, MonoClass *klass, guint32 len, int *out_size, guint32 *out_field_token)
5106 {
5107         /*
5108          * newarr[System.Int32]
5109          * dup
5110          * ldtoken field valuetype ...
5111          * call void class [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
5112          */
5113         if (ip [0] == CEE_DUP && ip [1] == CEE_LDTOKEN && ip [5] == 0x4 && ip [6] == CEE_CALL) {
5114                 guint32 token = read32 (ip + 7);
5115                 guint32 field_token = read32 (ip + 2);
5116                 guint32 field_index = field_token & 0xffffff;
5117                 guint32 rva;
5118                 const char *data_ptr;
5119                 int size = 0;
5120                 MonoMethod *cmethod;
5121                 MonoClass *dummy_class;
5122                 MonoClassField *field = mono_field_from_token (method->klass->image, field_token, &dummy_class, NULL);
5123                 int dummy_align;
5124
5125                 if (!field)
5126                         return NULL;
5127
5128                 *out_field_token = field_token;
5129
5130                 cmethod = mini_get_method (NULL, method, token, NULL, NULL);
5131                 if (!cmethod)
5132                         return NULL;
5133                 if (strcmp (cmethod->name, "InitializeArray") || strcmp (cmethod->klass->name, "RuntimeHelpers") || cmethod->klass->image != mono_defaults.corlib)
5134                         return NULL;
5135                 switch (mono_type_get_underlying_type (&klass->byval_arg)->type) {
5136                 case MONO_TYPE_BOOLEAN:
5137                 case MONO_TYPE_I1:
5138                 case MONO_TYPE_U1:
5139                         size = 1; break;
5140                 /* we need to swap on big endian, so punt. Should we handle R4 and R8 as well? */
5141 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
5142                 case MONO_TYPE_CHAR:
5143                 case MONO_TYPE_I2:
5144                 case MONO_TYPE_U2:
5145                         size = 2; break;
5146                 case MONO_TYPE_I4:
5147                 case MONO_TYPE_U4:
5148                 case MONO_TYPE_R4:
5149                         size = 4; break;
5150                 case MONO_TYPE_R8:
5151 #ifdef ARM_FPU_FPA
5152                         return NULL; /* stupid ARM FP swapped format */
5153 #endif
5154                 case MONO_TYPE_I8:
5155                 case MONO_TYPE_U8:
5156                         size = 8; break;
5157 #endif
5158                 default:
5159                         return NULL;
5160                 }
5161                 size *= len;
5162                 if (size > mono_type_size (field->type, &dummy_align))
5163                     return NULL;
5164                 *out_size = size;
5165                 /*g_print ("optimized in %s: size: %d, numelems: %d\n", method->name, size, newarr->inst_newa_len->inst_c0);*/
5166                 if (!method->klass->image->dynamic) {
5167                         field_index = read32 (ip + 2) & 0xffffff;
5168                         mono_metadata_field_info (method->klass->image, field_index - 1, NULL, &rva, NULL);
5169                         data_ptr = mono_image_rva_map (method->klass->image, rva);
5170                         /*g_print ("field: 0x%08x, rva: %d, rva_ptr: %p\n", read32 (ip + 2), rva, data_ptr);*/
5171                         /* for aot code we do the lookup on load */
5172                         if (aot && data_ptr)
5173                                 return GUINT_TO_POINTER (rva);
5174                 } else {
5175                         /*FIXME is it possible to AOT a SRE assembly not meant to be saved? */
5176                         g_assert (!aot);
5177                         data_ptr = mono_field_get_data (field);
5178                 }
5179                 return data_ptr;
5180         }
5181         return NULL;
5182 }
5183
5184 static void
5185 set_exception_type_from_invalid_il (MonoCompile *cfg, MonoMethod *method, unsigned char *ip)
5186 {
5187         char *method_fname = mono_method_full_name (method, TRUE);
5188         char *method_code;
5189         MonoMethodHeader *header = mono_method_get_header (method);
5190
5191         if (header->code_size == 0)
5192                 method_code = g_strdup ("method body is empty.");
5193         else
5194                 method_code = mono_disasm_code_one (NULL, method, ip, NULL);
5195         cfg->exception_type = MONO_EXCEPTION_INVALID_PROGRAM;
5196         cfg->exception_message = g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
5197         g_free (method_fname);
5198         g_free (method_code);
5199         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
5200 }
5201
5202 static void
5203 set_exception_object (MonoCompile *cfg, MonoException *exception)
5204 {
5205         cfg->exception_type = MONO_EXCEPTION_OBJECT_SUPPLIED;
5206         MONO_GC_REGISTER_ROOT (cfg->exception_ptr);
5207         cfg->exception_ptr = exception;
5208 }
5209
5210 static gboolean
5211 generic_class_is_reference_type (MonoCompile *cfg, MonoClass *klass)
5212 {
5213         MonoType *type;
5214
5215         if (cfg->generic_sharing_context)
5216                 type = mini_get_basic_type_from_generic (cfg->generic_sharing_context, &klass->byval_arg);
5217         else
5218                 type = &klass->byval_arg;
5219         return MONO_TYPE_IS_REFERENCE (type);
5220 }
5221
5222 static void
5223 emit_stloc_ir (MonoCompile *cfg, MonoInst **sp, MonoMethodHeader *header, int n)
5224 {
5225         MonoInst *ins;
5226         guint32 opcode = mono_type_to_regmove (cfg, header->locals [n]);
5227         if ((opcode == OP_MOVE) && cfg->cbb->last_ins == sp [0]  &&
5228                         ((sp [0]->opcode == OP_ICONST) || (sp [0]->opcode == OP_I8CONST))) {
5229                 /* Optimize reg-reg moves away */
5230                 /*
5231                  * Can't optimize other opcodes, since sp[0] might point to
5232                  * the last ins of a decomposed opcode.
5233                  */
5234                 sp [0]->dreg = (cfg)->locals [n]->dreg;
5235         } else {
5236                 EMIT_NEW_LOCSTORE (cfg, ins, n, *sp);
5237         }
5238 }
5239
5240 /*
5241  * ldloca inhibits many optimizations so try to get rid of it in common
5242  * cases.
5243  */
5244 static inline unsigned char *
5245 emit_optimized_ldloca_ir (MonoCompile *cfg, unsigned char *ip, unsigned char *end, int size)
5246 {
5247         int local, token;
5248         MonoClass *klass;
5249
5250         if (size == 1) {
5251                 local = ip [1];
5252                 ip += 2;
5253         } else {
5254                 local = read16 (ip + 2);
5255                 ip += 4;
5256         }
5257
5258         if (ip + 6 < end && (ip [0] == CEE_PREFIX1) && (ip [1] == CEE_INITOBJ) && ip_in_bb (cfg, cfg->cbb, ip + 1)) {
5259                 gboolean skip = FALSE;
5260
5261                 /* From the INITOBJ case */
5262                 token = read32 (ip + 2);
5263                 klass = mini_get_class (cfg->current_method, token, cfg->generic_context);
5264                 CHECK_TYPELOAD (klass);
5265                 if (generic_class_is_reference_type (cfg, klass)) {
5266                         MONO_EMIT_NEW_PCONST (cfg, cfg->locals [local]->dreg, NULL);
5267                 } else if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) {
5268                         MONO_EMIT_NEW_PCONST (cfg, cfg->locals [local]->dreg, NULL);
5269                 } else if (MONO_TYPE_ISSTRUCT (&klass->byval_arg)) {
5270                         MONO_EMIT_NEW_VZERO (cfg, cfg->locals [local]->dreg, klass);
5271                 } else {
5272                         skip = TRUE;
5273                 }
5274
5275                 if (!skip)
5276                         return ip + 6;
5277         }
5278 load_error:
5279         return NULL;
5280 }
5281
5282 static gboolean
5283 is_exception_class (MonoClass *class)
5284 {
5285         while (class) {
5286                 if (class == mono_defaults.exception_class)
5287                         return TRUE;
5288                 class = class->parent;
5289         }
5290         return FALSE;
5291 }
5292
5293 /*
5294  * mono_method_to_ir:
5295  *
5296  *   Translate the .net IL into linear IR.
5297  */
5298 int
5299 mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_bblock, MonoBasicBlock *end_bblock,
5300                    MonoInst *return_var, GList *dont_inline, MonoInst **inline_args,
5301                    guint inline_offset, gboolean is_virtual_call)
5302 {
5303         MonoError error;
5304         MonoInst *ins, **sp, **stack_start;
5305         MonoBasicBlock *bblock, *tblock = NULL, *init_localsbb = NULL;
5306         MonoSimpleBasicBlock *bb = NULL, *original_bb = NULL;
5307         MonoMethod *cmethod, *method_definition;
5308         MonoInst **arg_array;
5309         MonoMethodHeader *header;
5310         MonoImage *image;
5311         guint32 token, ins_flag;
5312         MonoClass *klass;
5313         MonoClass *constrained_call = NULL;
5314         unsigned char *ip, *end, *target, *err_pos;
5315         static double r8_0 = 0.0;
5316         MonoMethodSignature *sig;
5317         MonoGenericContext *generic_context = NULL;
5318         MonoGenericContainer *generic_container = NULL;
5319         MonoType **param_types;
5320         int i, n, start_new_bblock, dreg;
5321         int num_calls = 0, inline_costs = 0;
5322         int breakpoint_id = 0;
5323         guint num_args;
5324         MonoBoolean security, pinvoke;
5325         MonoSecurityManager* secman = NULL;
5326         MonoDeclSecurityActions actions;
5327         GSList *class_inits = NULL;
5328         gboolean dont_verify, dont_verify_stloc, readonly = FALSE;
5329         int context_used;
5330         gboolean init_locals, seq_points, skip_dead_blocks;
5331
5332         /* serialization and xdomain stuff may need access to private fields and methods */
5333         dont_verify = method->klass->image->assembly->corlib_internal? TRUE: FALSE;
5334         dont_verify |= method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE;
5335         dont_verify |= method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH;
5336         dont_verify |= method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE; /* bug #77896 */
5337         dont_verify |= method->wrapper_type == MONO_WRAPPER_COMINTEROP;
5338         dont_verify |= method->wrapper_type == MONO_WRAPPER_COMINTEROP_INVOKE;
5339
5340         dont_verify |= mono_security_get_mode () == MONO_SECURITY_MODE_SMCS_HACK;
5341
5342         /* still some type unsafety issues in marshal wrappers... (unknown is PtrToStructure) */
5343         dont_verify_stloc = method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE;
5344         dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_UNKNOWN;
5345         dont_verify_stloc |= method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED;
5346
5347         image = method->klass->image;
5348         header = mono_method_get_header (method);
5349         if (!header) {
5350                 MonoLoaderError *error;
5351
5352                 if ((error = mono_loader_get_last_error ())) {
5353                         cfg->exception_type = error->exception_type;
5354                 } else {
5355                         cfg->exception_type = MONO_EXCEPTION_INVALID_PROGRAM;
5356                         cfg->exception_message = g_strdup_printf ("Missing or incorrect header for method %s", cfg->method->name);
5357                 }
5358                 goto exception_exit;
5359         }
5360         generic_container = mono_method_get_generic_container (method);
5361         sig = mono_method_signature (method);
5362         num_args = sig->hasthis + sig->param_count;
5363         ip = (unsigned char*)header->code;
5364         cfg->cil_start = ip;
5365         end = ip + header->code_size;
5366         mono_jit_stats.cil_code_size += header->code_size;
5367         init_locals = header->init_locals;
5368
5369         seq_points = cfg->gen_seq_points && cfg->method == method;
5370
5371         /*
5372          * Methods without init_locals set could cause asserts in various passes
5373          * (#497220).
5374          */
5375         init_locals = TRUE;
5376
5377         method_definition = method;
5378         while (method_definition->is_inflated) {
5379                 MonoMethodInflated *imethod = (MonoMethodInflated *) method_definition;
5380                 method_definition = imethod->declaring;
5381         }
5382
5383         /* SkipVerification is not allowed if core-clr is enabled */
5384         if (!dont_verify && mini_assembly_can_skip_verification (cfg->domain, method)) {
5385                 dont_verify = TRUE;
5386                 dont_verify_stloc = TRUE;
5387         }
5388
5389         if (!dont_verify && mini_method_verify (cfg, method_definition))
5390                 goto exception_exit;
5391
5392         if (mono_debug_using_mono_debugger ())
5393                 cfg->keep_cil_nops = TRUE;
5394
5395         if (sig->is_inflated)
5396                 generic_context = mono_method_get_context (method);
5397         else if (generic_container)
5398                 generic_context = &generic_container->context;
5399         cfg->generic_context = generic_context;
5400
5401         if (!cfg->generic_sharing_context)
5402                 g_assert (!sig->has_type_parameters);
5403
5404         if (sig->generic_param_count && method->wrapper_type == MONO_WRAPPER_NONE) {
5405                 g_assert (method->is_inflated);
5406                 g_assert (mono_method_get_context (method)->method_inst);
5407         }
5408         if (method->is_inflated && mono_method_get_context (method)->method_inst)
5409                 g_assert (sig->generic_param_count);
5410
5411         if (cfg->method == method) {
5412                 cfg->real_offset = 0;
5413         } else {
5414                 cfg->real_offset = inline_offset;
5415         }
5416
5417         cfg->cil_offset_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoBasicBlock*) * header->code_size);
5418         cfg->cil_offset_to_bb_len = header->code_size;
5419
5420         cfg->current_method = method;
5421
5422         if (cfg->verbose_level > 2)
5423                 printf ("method to IR %s\n", mono_method_full_name (method, TRUE));
5424
5425         param_types = mono_mempool_alloc (cfg->mempool, sizeof (MonoType*) * num_args);
5426         if (sig->hasthis)
5427                 param_types [0] = method->klass->valuetype?&method->klass->this_arg:&method->klass->byval_arg;
5428         for (n = 0; n < sig->param_count; ++n)
5429                 param_types [n + sig->hasthis] = sig->params [n];
5430         cfg->arg_types = param_types;
5431
5432         dont_inline = g_list_prepend (dont_inline, method);
5433         if (cfg->method == method) {
5434
5435                 if (cfg->prof_options & MONO_PROFILE_INS_COVERAGE)
5436                         cfg->coverage_info = mono_profiler_coverage_alloc (cfg->method, header->code_size);
5437
5438                 /* ENTRY BLOCK */
5439                 NEW_BBLOCK (cfg, start_bblock);
5440                 cfg->bb_entry = start_bblock;
5441                 start_bblock->cil_code = NULL;
5442                 start_bblock->cil_length = 0;
5443
5444                 /* EXIT BLOCK */
5445                 NEW_BBLOCK (cfg, end_bblock);
5446                 cfg->bb_exit = end_bblock;
5447                 end_bblock->cil_code = NULL;
5448                 end_bblock->cil_length = 0;
5449                 g_assert (cfg->num_bblocks == 2);
5450
5451                 arg_array = cfg->args;
5452
5453                 if (header->num_clauses) {
5454                         cfg->spvars = g_hash_table_new (NULL, NULL);
5455                         cfg->exvars = g_hash_table_new (NULL, NULL);
5456                 }
5457                 /* handle exception clauses */
5458                 for (i = 0; i < header->num_clauses; ++i) {
5459                         MonoBasicBlock *try_bb;
5460                         MonoExceptionClause *clause = &header->clauses [i];
5461                         GET_BBLOCK (cfg, try_bb, ip + clause->try_offset);
5462                         try_bb->real_offset = clause->try_offset;
5463                         GET_BBLOCK (cfg, tblock, ip + clause->handler_offset);
5464                         tblock->real_offset = clause->handler_offset;
5465                         tblock->flags |= BB_EXCEPTION_HANDLER;
5466
5467                         link_bblock (cfg, try_bb, tblock);
5468
5469                         if (*(ip + clause->handler_offset) == CEE_POP)
5470                                 tblock->flags |= BB_EXCEPTION_DEAD_OBJ;
5471
5472                         if (clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY ||
5473                             clause->flags == MONO_EXCEPTION_CLAUSE_FILTER ||
5474                             clause->flags == MONO_EXCEPTION_CLAUSE_FAULT) {
5475                                 MONO_INST_NEW (cfg, ins, OP_START_HANDLER);
5476                                 MONO_ADD_INS (tblock, ins);
5477
5478                                 /* todo: is a fault block unsafe to optimize? */
5479                                 if (clause->flags == MONO_EXCEPTION_CLAUSE_FAULT)
5480                                         tblock->flags |= BB_EXCEPTION_UNSAFE;
5481                         }
5482
5483
5484                         /*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);
5485                           while (p < end) {
5486                           printf ("%s", mono_disasm_code_one (NULL, method, p, &p));
5487                           }*/
5488                         /* catch and filter blocks get the exception object on the stack */
5489                         if (clause->flags == MONO_EXCEPTION_CLAUSE_NONE ||
5490                             clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
5491                                 MonoInst *dummy_use;
5492
5493                                 /* mostly like handle_stack_args (), but just sets the input args */
5494                                 /* printf ("handling clause at IL_%04x\n", clause->handler_offset); */
5495                                 tblock->in_scount = 1;
5496                                 tblock->in_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
5497                                 tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
5498
5499                                 /*
5500                                  * Add a dummy use for the exvar so its liveness info will be
5501                                  * correct.
5502                                  */
5503                                 cfg->cbb = tblock;
5504                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, tblock->in_stack [0]);
5505
5506                                 if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
5507                                         GET_BBLOCK (cfg, tblock, ip + clause->data.filter_offset);
5508                                         tblock->flags |= BB_EXCEPTION_HANDLER;
5509                                         tblock->real_offset = clause->data.filter_offset;
5510                                         tblock->in_scount = 1;
5511                                         tblock->in_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*));
5512                                         /* The filter block shares the exvar with the handler block */
5513                                         tblock->in_stack [0] = mono_create_exvar_for_offset (cfg, clause->handler_offset);
5514                                         MONO_INST_NEW (cfg, ins, OP_START_HANDLER);
5515                                         MONO_ADD_INS (tblock, ins);
5516                                 }
5517                         }
5518
5519                         if (clause->flags != MONO_EXCEPTION_CLAUSE_FILTER &&
5520                                         clause->data.catch_class &&
5521                                         cfg->generic_sharing_context &&
5522                                         mono_class_check_context_used (clause->data.catch_class)) {
5523                                 /*
5524                                  * In shared generic code with catch
5525                                  * clauses containing type variables
5526                                  * the exception handling code has to
5527                                  * be able to get to the rgctx.
5528                                  * Therefore we have to make sure that
5529                                  * the vtable/mrgctx argument (for
5530                                  * static or generic methods) or the
5531                                  * "this" argument (for non-static
5532                                  * methods) are live.
5533                                  */
5534                                 if ((method->flags & METHOD_ATTRIBUTE_STATIC) ||
5535                                                 mini_method_get_context (method)->method_inst ||
5536                                                 method->klass->valuetype) {
5537                                         mono_get_vtable_var (cfg);
5538                                 } else {
5539                                         MonoInst *dummy_use;
5540
5541                                         EMIT_NEW_DUMMY_USE (cfg, dummy_use, arg_array [0]);
5542                                 }
5543                         }
5544                 }
5545         } else {
5546                 arg_array = (MonoInst **) alloca (sizeof (MonoInst *) * num_args);
5547                 cfg->cbb = start_bblock;
5548                 cfg->args = arg_array;
5549                 mono_save_args (cfg, sig, inline_args);
5550         }
5551
5552         /* FIRST CODE BLOCK */
5553         NEW_BBLOCK (cfg, bblock);
5554         bblock->cil_code = ip;
5555         cfg->cbb = bblock;
5556         cfg->ip = ip;
5557
5558         ADD_BBLOCK (cfg, bblock);
5559
5560         if (cfg->method == method) {
5561                 breakpoint_id = mono_debugger_method_has_breakpoint (method);
5562                 if (breakpoint_id && (mono_debug_format != MONO_DEBUG_FORMAT_DEBUGGER)) {
5563                         MONO_INST_NEW (cfg, ins, OP_BREAK);
5564                         MONO_ADD_INS (bblock, ins);
5565                 }
5566         }
5567
5568         if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS)
5569                 secman = mono_security_manager_get_methods ();
5570
5571         security = (secman && mono_method_has_declsec (method));
5572         /* at this point having security doesn't mean we have any code to generate */
5573         if (security && (cfg->method == method)) {
5574                 /* Only Demand, NonCasDemand and DemandChoice requires code generation.
5575                  * And we do not want to enter the next section (with allocation) if we
5576                  * have nothing to generate */
5577                 security = mono_declsec_get_demands (method, &actions);
5578         }
5579
5580         /* we must Demand SecurityPermission.Unmanaged before P/Invoking */
5581         pinvoke = (secman && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE));
5582         if (pinvoke) {
5583                 MonoMethod *wrapped = mono_marshal_method_from_wrapper (method);
5584                 if (wrapped && (wrapped->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
5585                         MonoCustomAttrInfo* custom = mono_custom_attrs_from_method (wrapped);
5586
5587                         /* unless the method or it's class has the [SuppressUnmanagedCodeSecurity] attribute */
5588                         if (custom && mono_custom_attrs_has_attr (custom, secman->suppressunmanagedcodesecurity)) {
5589                                 pinvoke = FALSE;
5590                         }
5591                         if (custom)
5592                                 mono_custom_attrs_free (custom);
5593
5594                         if (pinvoke) {
5595                                 custom = mono_custom_attrs_from_class (wrapped->klass);
5596                                 if (custom && mono_custom_attrs_has_attr (custom, secman->suppressunmanagedcodesecurity)) {
5597                                         pinvoke = FALSE;
5598                                 }
5599                                 if (custom)
5600                                         mono_custom_attrs_free (custom);
5601                         }
5602                 } else {
5603                         /* not a P/Invoke after all */
5604                         pinvoke = FALSE;
5605                 }
5606         }
5607
5608         if ((init_locals || (cfg->method == method && (cfg->opt & MONO_OPT_SHARED))) || cfg->compile_aot || security || pinvoke) {
5609                 /* we use a separate basic block for the initialization code */
5610                 NEW_BBLOCK (cfg, init_localsbb);
5611                 cfg->bb_init = init_localsbb;
5612                 init_localsbb->real_offset = cfg->real_offset;
5613                 start_bblock->next_bb = init_localsbb;
5614                 init_localsbb->next_bb = bblock;
5615                 link_bblock (cfg, start_bblock, init_localsbb);
5616                 link_bblock (cfg, init_localsbb, bblock);
5617
5618                 cfg->cbb = init_localsbb;
5619         } else {
5620                 start_bblock->next_bb = bblock;
5621                 link_bblock (cfg, start_bblock, bblock);
5622         }
5623
5624         /* at this point we know, if security is TRUE, that some code needs to be generated */
5625         if (security && (cfg->method == method)) {
5626                 MonoInst *args [2];
5627
5628                 mono_jit_stats.cas_demand_generation++;
5629
5630                 if (actions.demand.blob) {
5631                         /* Add code for SecurityAction.Demand */
5632                         EMIT_NEW_DECLSECCONST (cfg, args[0], image, actions.demand);
5633                         EMIT_NEW_ICONST (cfg, args [1], actions.demand.size);
5634                         /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5635                         mono_emit_method_call (cfg, secman->demand, args, NULL);
5636                 }
5637                 if (actions.noncasdemand.blob) {
5638                         /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */
5639                         /* For Mono we re-route non-CAS Demand to Demand (as the managed code must deal with it anyway) */
5640                         EMIT_NEW_DECLSECCONST (cfg, args[0], image, actions.noncasdemand);
5641                         EMIT_NEW_ICONST (cfg, args [1], actions.noncasdemand.size);
5642                         /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */
5643                         mono_emit_method_call (cfg, secman->demand, args, NULL);
5644                 }
5645                 if (actions.demandchoice.blob) {
5646                         /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */
5647                         EMIT_NEW_DECLSECCONST (cfg, args[0], image, actions.demandchoice);
5648                         EMIT_NEW_ICONST (cfg, args [1], actions.demandchoice.size);
5649                         /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */
5650                         mono_emit_method_call (cfg, secman->demandchoice, args, NULL);
5651                 }
5652         }
5653
5654         /* we must Demand SecurityPermission.Unmanaged before p/invoking */
5655         if (pinvoke) {
5656                 mono_emit_method_call (cfg, secman->demandunmanaged, NULL, NULL);
5657         }
5658
5659         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
5660                 /* check if this is native code, e.g. an icall or a p/invoke */
5661                 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
5662                         MonoMethod *wrapped = mono_marshal_method_from_wrapper (method);
5663                         if (wrapped) {
5664                                 gboolean pinvk = (wrapped->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL);
5665                                 gboolean icall = (wrapped->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL);
5666
5667                                 /* if this ia a native call then it can only be JITted from platform code */
5668                                 if ((icall || pinvk) && method->klass && method->klass->image) {
5669                                         if (!mono_security_core_clr_is_platform_image (method->klass->image)) {
5670                                                 MonoException *ex = icall ? mono_get_exception_security () :
5671                                                         mono_get_exception_method_access ();
5672                                                 emit_throw_exception (cfg, ex);
5673                                         }
5674                                 }
5675                         }
5676                 }
5677         }
5678
5679         if (header->code_size == 0)
5680                 UNVERIFIED;
5681
5682         if (get_basic_blocks (cfg, header, cfg->real_offset, ip, end, &err_pos)) {
5683                 ip = err_pos;
5684                 UNVERIFIED;
5685         }
5686
5687         if (cfg->method == method)
5688                 mono_debug_init_method (cfg, bblock, breakpoint_id);
5689
5690         for (n = 0; n < header->num_locals; ++n) {
5691                 if (header->locals [n]->type == MONO_TYPE_VOID && !header->locals [n]->byref)
5692                         UNVERIFIED;
5693         }
5694         class_inits = NULL;
5695
5696         /* We force the vtable variable here for all shared methods
5697            for the possibility that they might show up in a stack
5698            trace where their exact instantiation is needed. */
5699         if (cfg->generic_sharing_context && method == cfg->method) {
5700                 if ((method->flags & METHOD_ATTRIBUTE_STATIC) ||
5701                                 mini_method_get_context (method)->method_inst ||
5702                                 method->klass->valuetype) {
5703                         mono_get_vtable_var (cfg);
5704                 } else {
5705                         /* FIXME: Is there a better way to do this?
5706                            We need the variable live for the duration
5707                            of the whole method. */
5708                         cfg->args [0]->flags |= MONO_INST_INDIRECT;
5709                 }
5710         }
5711
5712         /* add a check for this != NULL to inlined methods */
5713         if (is_virtual_call) {
5714                 MonoInst *arg_ins;
5715
5716                 NEW_ARGLOAD (cfg, arg_ins, 0);
5717                 MONO_ADD_INS (cfg->cbb, arg_ins);
5718                 MONO_EMIT_NEW_CHECK_THIS (cfg, arg_ins->dreg);
5719         }
5720
5721         skip_dead_blocks = !dont_verify;
5722         if (skip_dead_blocks) {
5723                 original_bb = bb = mono_basic_block_split (method, &error);
5724                 if (!mono_error_ok (&error)) {
5725                         mono_error_cleanup (&error);
5726                         UNVERIFIED;
5727                 }
5728                 g_assert (bb);
5729         }
5730
5731         /* we use a spare stack slot in SWITCH and NEWOBJ and others */
5732         stack_start = sp = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * (header->max_stack + 1));
5733
5734         ins_flag = 0;
5735         start_new_bblock = 0;
5736         cfg->cbb = bblock;
5737         while (ip < end) {
5738                 if (cfg->method == method)
5739                         cfg->real_offset = ip - header->code;
5740                 else
5741                         cfg->real_offset = inline_offset;
5742                 cfg->ip = ip;
5743
5744                 context_used = 0;
5745
5746                 if (start_new_bblock) {
5747                         bblock->cil_length = ip - bblock->cil_code;
5748                         if (start_new_bblock == 2) {
5749                                 g_assert (ip == tblock->cil_code);
5750                         } else {
5751                                 GET_BBLOCK (cfg, tblock, ip);
5752                         }
5753                         bblock->next_bb = tblock;
5754                         bblock = tblock;
5755                         cfg->cbb = bblock;
5756                         start_new_bblock = 0;
5757                         for (i = 0; i < bblock->in_scount; ++i) {
5758                                 if (cfg->verbose_level > 3)
5759                                         printf ("loading %d from temp %d\n", i, (int)bblock->in_stack [i]->inst_c0);
5760                                 EMIT_NEW_TEMPLOAD (cfg, ins, bblock->in_stack [i]->inst_c0);
5761                                 *sp++ = ins;
5762                         }
5763                         if (class_inits)
5764                                 g_slist_free (class_inits);
5765                         class_inits = NULL;
5766                 } else {
5767                         if ((tblock = cfg->cil_offset_to_bb [ip - cfg->cil_start]) && (tblock != bblock)) {
5768                                 link_bblock (cfg, bblock, tblock);
5769                                 if (sp != stack_start) {
5770                                         handle_stack_args (cfg, stack_start, sp - stack_start);
5771                                         sp = stack_start;
5772                                         CHECK_UNVERIFIABLE (cfg);
5773                                 }
5774                                 bblock->next_bb = tblock;
5775                                 bblock = tblock;
5776                                 cfg->cbb = bblock;
5777                                 for (i = 0; i < bblock->in_scount; ++i) {
5778                                         if (cfg->verbose_level > 3)
5779                                                 printf ("loading %d from temp %d\n", i, (int)bblock->in_stack [i]->inst_c0);
5780                                         EMIT_NEW_TEMPLOAD (cfg, ins, bblock->in_stack [i]->inst_c0);
5781                                         *sp++ = ins;
5782                                 }
5783                                 g_slist_free (class_inits);
5784                                 class_inits = NULL;
5785                         }
5786                 }
5787
5788                 if (skip_dead_blocks) {
5789                         int ip_offset = ip - header->code;
5790
5791                         if (ip_offset == bb->end)
5792                                 bb = bb->next;
5793
5794                         if (bb->dead) {
5795                                 int op_size = mono_opcode_size (ip, end);
5796                                 g_assert (op_size > 0); /*The BB formation pass must catch all bad ops*/
5797
5798                                 if (cfg->verbose_level > 3) printf ("SKIPPING DEAD OP at %x\n", ip_offset);
5799
5800                                 if (ip_offset + op_size == bb->end) {
5801                                         MONO_INST_NEW (cfg, ins, OP_NOP);
5802                                         MONO_ADD_INS (bblock, ins);
5803                                         start_new_bblock = 1;
5804                                 }
5805
5806                                 ip += op_size;
5807                                 continue;
5808                         }
5809                 }
5810                 /*
5811                  * Sequence points are points where the debugger can place a breakpoint.
5812                  * Currently, we generate these automatically at points where the IL
5813                  * stack is empty.
5814                  */
5815                 if (seq_points && sp == stack_start) {
5816                         NEW_SEQ_POINT (cfg, ins, ip - header->code, TRUE);
5817                         MONO_ADD_INS (cfg->cbb, ins);
5818                 }
5819
5820                 bblock->real_offset = cfg->real_offset;
5821
5822                 if ((cfg->method == method) && cfg->coverage_info) {
5823                         guint32 cil_offset = ip - header->code;
5824                         cfg->coverage_info->data [cil_offset].cil_code = ip;
5825
5826                         /* TODO: Use an increment here */
5827 #if defined(TARGET_X86)
5828                         MONO_INST_NEW (cfg, ins, OP_STORE_MEM_IMM);
5829                         ins->inst_p0 = &(cfg->coverage_info->data [cil_offset].count);
5830                         ins->inst_imm = 1;
5831                         MONO_ADD_INS (cfg->cbb, ins);
5832 #else
5833                         EMIT_NEW_PCONST (cfg, ins, &(cfg->coverage_info->data [cil_offset].count));
5834                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, ins->dreg, 0, 1);
5835 #endif
5836                 }
5837
5838                 if (cfg->verbose_level > 3)
5839                         printf ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
5840
5841                 switch (*ip) {
5842                 case CEE_NOP:
5843                         if (cfg->keep_cil_nops)
5844                                 MONO_INST_NEW (cfg, ins, OP_HARD_NOP);
5845                         else
5846                                 MONO_INST_NEW (cfg, ins, OP_NOP);
5847                         ip++;
5848                         MONO_ADD_INS (bblock, ins);
5849                         break;
5850                 case CEE_BREAK:
5851                         if (should_insert_brekpoint (cfg->method))
5852                                 MONO_INST_NEW (cfg, ins, OP_BREAK);
5853                         else
5854                                 MONO_INST_NEW (cfg, ins, OP_NOP);
5855                         ip++;
5856                         MONO_ADD_INS (bblock, ins);
5857                         break;
5858                 case CEE_LDARG_0:
5859                 case CEE_LDARG_1:
5860                 case CEE_LDARG_2:
5861                 case CEE_LDARG_3:
5862                         CHECK_STACK_OVF (1);
5863                         n = (*ip)-CEE_LDARG_0;
5864                         CHECK_ARG (n);
5865                         EMIT_NEW_ARGLOAD (cfg, ins, n);
5866                         ip++;
5867                         *sp++ = ins;
5868                         break;
5869                 case CEE_LDLOC_0:
5870                 case CEE_LDLOC_1:
5871                 case CEE_LDLOC_2:
5872                 case CEE_LDLOC_3:
5873                         CHECK_STACK_OVF (1);
5874                         n = (*ip)-CEE_LDLOC_0;
5875                         CHECK_LOCAL (n);
5876                         EMIT_NEW_LOCLOAD (cfg, ins, n);
5877                         ip++;
5878                         *sp++ = ins;
5879                         break;
5880                 case CEE_STLOC_0:
5881                 case CEE_STLOC_1:
5882                 case CEE_STLOC_2:
5883                 case CEE_STLOC_3: {
5884                         CHECK_STACK (1);
5885                         n = (*ip)-CEE_STLOC_0;
5886                         CHECK_LOCAL (n);
5887                         --sp;
5888                         if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [n], *sp))
5889                                 UNVERIFIED;
5890                         emit_stloc_ir (cfg, sp, header, n);
5891                         ++ip;
5892                         inline_costs += 1;
5893                         break;
5894                         }
5895                 case CEE_LDARG_S:
5896                         CHECK_OPSIZE (2);
5897                         CHECK_STACK_OVF (1);
5898                         n = ip [1];
5899                         CHECK_ARG (n);
5900                         EMIT_NEW_ARGLOAD (cfg, ins, n);
5901                         *sp++ = ins;
5902                         ip += 2;
5903                         break;
5904                 case CEE_LDARGA_S:
5905                         CHECK_OPSIZE (2);
5906                         CHECK_STACK_OVF (1);
5907                         n = ip [1];
5908                         CHECK_ARG (n);
5909                         NEW_ARGLOADA (cfg, ins, n);
5910                         MONO_ADD_INS (cfg->cbb, ins);
5911                         *sp++ = ins;
5912                         ip += 2;
5913                         break;
5914                 case CEE_STARG_S:
5915                         CHECK_OPSIZE (2);
5916                         CHECK_STACK (1);
5917                         --sp;
5918                         n = ip [1];
5919                         CHECK_ARG (n);
5920                         if (!dont_verify_stloc && target_type_is_incompatible (cfg, param_types [ip [1]], *sp))
5921                                 UNVERIFIED;
5922                         EMIT_NEW_ARGSTORE (cfg, ins, n, *sp);
5923                         ip += 2;
5924                         break;
5925                 case CEE_LDLOC_S:
5926                         CHECK_OPSIZE (2);
5927                         CHECK_STACK_OVF (1);
5928                         n = ip [1];
5929                         CHECK_LOCAL (n);
5930                         EMIT_NEW_LOCLOAD (cfg, ins, n);
5931                         *sp++ = ins;
5932                         ip += 2;
5933                         break;
5934                 case CEE_LDLOCA_S: {
5935                         unsigned char *tmp_ip;
5936                         CHECK_OPSIZE (2);
5937                         CHECK_STACK_OVF (1);
5938                         CHECK_LOCAL (ip [1]);
5939
5940                         if ((tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 1))) {
5941                                 ip = tmp_ip;
5942                                 inline_costs += 1;
5943                                 break;
5944                         }
5945
5946                         EMIT_NEW_LOCLOADA (cfg, ins, ip [1]);
5947                         *sp++ = ins;
5948                         ip += 2;
5949                         break;
5950                 }
5951                 case CEE_STLOC_S:
5952                         CHECK_OPSIZE (2);
5953                         CHECK_STACK (1);
5954                         --sp;
5955                         CHECK_LOCAL (ip [1]);
5956                         if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [ip [1]], *sp))
5957                                 UNVERIFIED;
5958                         emit_stloc_ir (cfg, sp, header, ip [1]);
5959                         ip += 2;
5960                         inline_costs += 1;
5961                         break;
5962                 case CEE_LDNULL:
5963                         CHECK_STACK_OVF (1);
5964                         EMIT_NEW_PCONST (cfg, ins, NULL);
5965                         ins->type = STACK_OBJ;
5966                         ++ip;
5967                         *sp++ = ins;
5968                         break;
5969                 case CEE_LDC_I4_M1:
5970                         CHECK_STACK_OVF (1);
5971                         EMIT_NEW_ICONST (cfg, ins, -1);
5972                         ++ip;
5973                         *sp++ = ins;
5974                         break;
5975                 case CEE_LDC_I4_0:
5976                 case CEE_LDC_I4_1:
5977                 case CEE_LDC_I4_2:
5978                 case CEE_LDC_I4_3:
5979                 case CEE_LDC_I4_4:
5980                 case CEE_LDC_I4_5:
5981                 case CEE_LDC_I4_6:
5982                 case CEE_LDC_I4_7:
5983                 case CEE_LDC_I4_8:
5984                         CHECK_STACK_OVF (1);
5985                         EMIT_NEW_ICONST (cfg, ins, (*ip) - CEE_LDC_I4_0);
5986                         ++ip;
5987                         *sp++ = ins;
5988                         break;
5989                 case CEE_LDC_I4_S:
5990                         CHECK_OPSIZE (2);
5991                         CHECK_STACK_OVF (1);
5992                         ++ip;
5993                         EMIT_NEW_ICONST (cfg, ins, *((signed char*)ip));
5994                         ++ip;
5995                         *sp++ = ins;
5996                         break;
5997                 case CEE_LDC_I4:
5998                         CHECK_OPSIZE (5);
5999                         CHECK_STACK_OVF (1);
6000                         EMIT_NEW_ICONST (cfg, ins, (gint32)read32 (ip + 1));
6001                         ip += 5;
6002                         *sp++ = ins;
6003                         break;
6004                 case CEE_LDC_I8:
6005                         CHECK_OPSIZE (9);
6006                         CHECK_STACK_OVF (1);
6007                         MONO_INST_NEW (cfg, ins, OP_I8CONST);
6008                         ins->type = STACK_I8;
6009                         ins->dreg = alloc_dreg (cfg, STACK_I8);
6010                         ++ip;
6011                         ins->inst_l = (gint64)read64 (ip);
6012                         MONO_ADD_INS (bblock, ins);
6013                         ip += 8;
6014                         *sp++ = ins;
6015                         break;
6016                 case CEE_LDC_R4: {
6017                         float *f;
6018                         gboolean use_aotconst = FALSE;
6019
6020 #ifdef TARGET_POWERPC
6021                         /* FIXME: Clean this up */
6022                         if (cfg->compile_aot)
6023                                 use_aotconst = TRUE;
6024 #endif
6025
6026                         /* FIXME: we should really allocate this only late in the compilation process */
6027                         f = mono_domain_alloc (cfg->domain, sizeof (float));
6028                         CHECK_OPSIZE (5);
6029                         CHECK_STACK_OVF (1);
6030
6031                         if (use_aotconst) {
6032                                 MonoInst *cons;
6033                                 int dreg;
6034
6035                                 EMIT_NEW_AOTCONST (cfg, cons, MONO_PATCH_INFO_R4, f);
6036
6037                                 dreg = alloc_freg (cfg);
6038                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADR4_MEMBASE, dreg, cons->dreg, 0);
6039                                 ins->type = STACK_R8;
6040                         } else {
6041                                 MONO_INST_NEW (cfg, ins, OP_R4CONST);
6042                                 ins->type = STACK_R8;
6043                                 ins->dreg = alloc_dreg (cfg, STACK_R8);
6044                                 ins->inst_p0 = f;
6045                                 MONO_ADD_INS (bblock, ins);
6046                         }
6047                         ++ip;
6048                         readr4 (ip, f);
6049                         ip += 4;
6050                         *sp++ = ins;
6051                         break;
6052                 }
6053                 case CEE_LDC_R8: {
6054                         double *d;
6055                         gboolean use_aotconst = FALSE;
6056
6057 #ifdef TARGET_POWERPC
6058                         /* FIXME: Clean this up */
6059                         if (cfg->compile_aot)
6060                                 use_aotconst = TRUE;
6061 #endif
6062
6063                         /* FIXME: we should really allocate this only late in the compilation process */
6064                         d = mono_domain_alloc (cfg->domain, sizeof (double));
6065                         CHECK_OPSIZE (9);
6066                         CHECK_STACK_OVF (1);
6067
6068                         if (use_aotconst) {
6069                                 MonoInst *cons;
6070                                 int dreg;
6071
6072                                 EMIT_NEW_AOTCONST (cfg, cons, MONO_PATCH_INFO_R8, d);
6073
6074                                 dreg = alloc_freg (cfg);
6075                                 EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADR8_MEMBASE, dreg, cons->dreg, 0);
6076                                 ins->type = STACK_R8;
6077                         } else {
6078                                 MONO_INST_NEW (cfg, ins, OP_R8CONST);
6079                                 ins->type = STACK_R8;
6080                                 ins->dreg = alloc_dreg (cfg, STACK_R8);
6081                                 ins->inst_p0 = d;
6082                                 MONO_ADD_INS (bblock, ins);
6083                         }
6084                         ++ip;
6085                         readr8 (ip, d);
6086                         ip += 8;
6087                         *sp++ = ins;
6088                         break;
6089                 }
6090                 case CEE_DUP: {
6091                         MonoInst *temp, *store;
6092                         CHECK_STACK (1);
6093                         CHECK_STACK_OVF (1);
6094                         sp--;
6095                         ins = *sp;
6096
6097                         temp = mono_compile_create_var (cfg, type_from_stack_type (ins), OP_LOCAL);
6098                         EMIT_NEW_TEMPSTORE (cfg, store, temp->inst_c0, ins);
6099
6100                         EMIT_NEW_TEMPLOAD (cfg, ins, temp->inst_c0);
6101                         *sp++ = ins;
6102
6103                         EMIT_NEW_TEMPLOAD (cfg, ins, temp->inst_c0);
6104                         *sp++ = ins;
6105
6106                         ++ip;
6107                         inline_costs += 2;
6108                         break;
6109                 }
6110                 case CEE_POP:
6111                         CHECK_STACK (1);
6112                         ip++;
6113                         --sp;
6114
6115 #ifdef TARGET_X86
6116                         if (sp [0]->type == STACK_R8)
6117                                 /* we need to pop the value from the x86 FP stack */
6118                                 MONO_EMIT_NEW_UNALU (cfg, OP_X86_FPOP, -1, sp [0]->dreg);
6119 #endif
6120                         break;
6121                 case CEE_JMP: {
6122                         MonoCallInst *call;
6123
6124                         INLINE_FAILURE;
6125
6126                         CHECK_OPSIZE (5);
6127                         if (stack_start != sp)
6128                                 UNVERIFIED;
6129                         token = read32 (ip + 1);
6130                         /* FIXME: check the signature matches */
6131                         cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
6132
6133                         if (!cmethod)
6134                                 goto load_error;
6135
6136                         if (cfg->generic_sharing_context && mono_method_check_context_used (cmethod))
6137                                 GENERIC_SHARING_FAILURE (CEE_JMP);
6138
6139                         if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS)
6140                                 CHECK_CFG_EXCEPTION;
6141
6142 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6143                         {
6144                                 MonoMethodSignature *fsig = mono_method_signature (cmethod);
6145                                 int i, n;
6146
6147                                 /* Handle tail calls similarly to calls */
6148                                 n = fsig->param_count + fsig->hasthis;
6149
6150                                 MONO_INST_NEW_CALL (cfg, call, OP_TAILCALL);
6151                                 call->method = cmethod;
6152                                 call->tail_call = TRUE;
6153                                 call->signature = mono_method_signature (cmethod);
6154                                 call->args = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * n);
6155                                 call->inst.inst_p0 = cmethod;
6156                                 for (i = 0; i < n; ++i)
6157                                         EMIT_NEW_ARGLOAD (cfg, call->args [i], i);
6158
6159                                 mono_arch_emit_call (cfg, call);
6160                                 MONO_ADD_INS (bblock, (MonoInst*)call);
6161                         }
6162 #else
6163                         for (i = 0; i < num_args; ++i)
6164                                 /* Prevent arguments from being optimized away */
6165                                 arg_array [i]->flags |= MONO_INST_VOLATILE;
6166
6167                         MONO_INST_NEW_CALL (cfg, call, OP_JMP);
6168                         ins = (MonoInst*)call;
6169                         ins->inst_p0 = cmethod;
6170                         MONO_ADD_INS (bblock, ins);
6171 #endif
6172
6173                         ip += 5;
6174                         start_new_bblock = 1;
6175                         break;
6176                 }
6177                 case CEE_CALLI:
6178                 case CEE_CALL:
6179                 case CEE_CALLVIRT: {
6180                         MonoInst *addr = NULL;
6181                         MonoMethodSignature *fsig = NULL;
6182                         int array_rank = 0;
6183                         int virtual = *ip == CEE_CALLVIRT;
6184                         int calli = *ip == CEE_CALLI;
6185                         gboolean pass_imt_from_rgctx = FALSE;
6186                         MonoInst *imt_arg = NULL;
6187                         gboolean pass_vtable = FALSE;
6188                         gboolean pass_mrgctx = FALSE;
6189                         MonoInst *vtable_arg = NULL;
6190                         gboolean check_this = FALSE;
6191                         gboolean supported_tail_call = FALSE;
6192
6193                         CHECK_OPSIZE (5);
6194                         token = read32 (ip + 1);
6195
6196                         if (calli) {
6197                                 cmethod = NULL;
6198                                 CHECK_STACK (1);
6199                                 --sp;
6200                                 addr = *sp;
6201                                 if (method->wrapper_type != MONO_WRAPPER_NONE)
6202                                         fsig = (MonoMethodSignature *)mono_method_get_wrapper_data (method, token);
6203                                 else
6204                                         fsig = mono_metadata_parse_signature (image, token);
6205
6206                                 n = fsig->param_count + fsig->hasthis;
6207
6208                                 if (method->dynamic && fsig->pinvoke) {
6209                                         MonoInst *args [3];
6210
6211                                         /*
6212                                          * This is a call through a function pointer using a pinvoke
6213                                          * signature. Have to create a wrapper and call that instead.
6214                                          * FIXME: This is very slow, need to create a wrapper at JIT time
6215                                          * instead based on the signature.
6216                                          */
6217                                         EMIT_NEW_IMAGECONST (cfg, args [0], method->klass->image);
6218                                         EMIT_NEW_PCONST (cfg, args [1], fsig);
6219                                         args [2] = addr;
6220                                         addr = mono_emit_jit_icall (cfg, mono_get_native_calli_wrapper, args);
6221                                 }
6222                         } else {
6223                                 MonoMethod *cil_method;
6224
6225                                 if (method->wrapper_type != MONO_WRAPPER_NONE) {
6226                                         cmethod =  (MonoMethod *)mono_method_get_wrapper_data (method, token);
6227                                         cil_method = cmethod;
6228                                 } else if (constrained_call) {
6229                                         if ((constrained_call->byval_arg.type == MONO_TYPE_VAR || constrained_call->byval_arg.type == MONO_TYPE_MVAR) && cfg->generic_sharing_context) {
6230                                                 /*
6231                                                  * This is needed since get_method_constrained can't find
6232                                                  * the method in klass representing a type var.
6233                                                  * The type var is guaranteed to be a reference type in this
6234                                                  * case.
6235                                                  */
6236                                                 cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
6237                                                 cil_method = cmethod;
6238                                                 g_assert (!cmethod->klass->valuetype);
6239                                         } else {
6240                                                 cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
6241                                         }
6242                                 } else {
6243                                         cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
6244                                         cil_method = cmethod;
6245                                 }
6246
6247                                 if (!cmethod)
6248                                         goto load_error;
6249                                 if (!dont_verify && !cfg->skip_visibility) {
6250                                         MonoMethod *target_method = cil_method;
6251                                         if (method->is_inflated) {
6252                                                 target_method = mini_get_method_allow_open (method, token, NULL, &(mono_method_get_generic_container (method_definition)->context));
6253                                         }
6254                                         if (!mono_method_can_access_method (method_definition, target_method) &&
6255                                                 !mono_method_can_access_method (method, cil_method))
6256                                                 METHOD_ACCESS_FAILURE;
6257                                 }
6258
6259                                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
6260                                         ensure_method_is_allowed_to_call_method (cfg, method, cil_method, bblock, ip);
6261
6262                                 if (!virtual && (cmethod->flags & METHOD_ATTRIBUTE_ABSTRACT))
6263                                         /* MS.NET seems to silently convert this to a callvirt */
6264                                         virtual = 1;
6265
6266                                 {
6267                                         /*
6268                                          * MS.NET accepts non virtual calls to virtual final methods of transparent proxy classes and
6269                                          * converts to a callvirt.
6270                                          *
6271                                          * tests/bug-515884.il is an example of this behavior
6272                                          */
6273                                         const int test_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_STATIC;
6274                                         const int expected_flags = METHOD_ATTRIBUTE_VIRTUAL | METHOD_ATTRIBUTE_FINAL;
6275                                         if (!virtual && cmethod->klass->marshalbyref && (cmethod->flags & test_flags) == expected_flags && cfg->method->wrapper_type == MONO_WRAPPER_NONE)
6276                                                 virtual = 1;
6277                                 }
6278
6279                                 if (!cmethod->klass->inited)
6280                                         if (!mono_class_init (cmethod->klass))
6281                                                 goto load_error;
6282
6283                                 if (cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL &&
6284                                     mini_class_is_system_array (cmethod->klass)) {
6285                                         array_rank = cmethod->klass->rank;
6286                                         fsig = mono_method_signature (cmethod);
6287                                 } else {
6288                                         fsig = mono_method_signature (cmethod);
6289
6290                                         if (!fsig)
6291                                                 goto load_error;
6292
6293                                         if (fsig->pinvoke) {
6294                                                 MonoMethod *wrapper = mono_marshal_get_native_wrapper (cmethod,
6295                                                         check_for_pending_exc, FALSE);
6296                                                 fsig = mono_method_signature (wrapper);
6297                                         } else if (constrained_call) {
6298                                                 fsig = mono_method_signature (cmethod);
6299                                         } else {
6300                                                 fsig = mono_method_get_signature_full (cmethod, image, token, generic_context);
6301                                         }
6302                                 }
6303
6304                                 mono_save_token_info (cfg, image, token, cil_method);
6305
6306                                 n = fsig->param_count + fsig->hasthis;
6307
6308                                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
6309                                         if (check_linkdemand (cfg, method, cmethod))
6310                                                 INLINE_FAILURE;
6311                                         CHECK_CFG_EXCEPTION;
6312                                 }
6313
6314                                 if (cmethod->string_ctor && method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
6315                                         g_assert_not_reached ();
6316                         }
6317
6318                         if (!cfg->generic_sharing_context && cmethod && cmethod->klass->generic_container)
6319                                 UNVERIFIED;
6320
6321                         if (!cfg->generic_sharing_context && cmethod)
6322                                 g_assert (!mono_method_check_context_used (cmethod));
6323
6324                         CHECK_STACK (n);
6325
6326                         //g_assert (!virtual || fsig->hasthis);
6327
6328                         sp -= n;
6329
6330                         if (constrained_call) {
6331                                 /*
6332                                  * We have the `constrained.' prefix opcode.
6333                                  */
6334                                 if (constrained_call->valuetype && !cmethod->klass->valuetype) {
6335                                         /*
6336                                          * The type parameter is instantiated as a valuetype,
6337                                          * but that type doesn't override the method we're
6338                                          * calling, so we need to box `this'.
6339                                          */
6340                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &constrained_call->byval_arg, sp [0]->dreg, 0);
6341                                         ins->klass = constrained_call;
6342                                         sp [0] = handle_box (cfg, ins, constrained_call, mono_class_check_context_used (constrained_call));
6343                                         CHECK_CFG_EXCEPTION;
6344                                 } else if (!constrained_call->valuetype) {
6345                                         int dreg = alloc_preg (cfg);
6346
6347                                         /*
6348                                          * The type parameter is instantiated as a reference
6349                                          * type.  We have a managed pointer on the stack, so
6350                                          * we need to dereference it here.
6351                                          */
6352                                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, sp [0]->dreg, 0);
6353                                         ins->type = STACK_OBJ;
6354                                         sp [0] = ins;
6355                                 } else if (cmethod->klass->valuetype)
6356                                         virtual = 0;
6357                                 constrained_call = NULL;
6358                         }
6359
6360                         if (*ip != CEE_CALLI && check_call_signature (cfg, fsig, sp))
6361                                 UNVERIFIED;
6362
6363                         /*
6364                          * If the callee is a shared method, then its static cctor
6365                          * might not get called after the call was patched.
6366                          */
6367                         if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
6368                                 emit_generic_class_init (cfg, cmethod->klass);
6369                                 CHECK_TYPELOAD (cmethod->klass);
6370                         }
6371
6372                         if (cmethod && ((cmethod->flags & METHOD_ATTRIBUTE_STATIC) || cmethod->klass->valuetype) &&
6373                                         (cmethod->klass->generic_class || cmethod->klass->generic_container)) {
6374                                 gboolean sharing_enabled = mono_class_generic_sharing_enabled (cmethod->klass);
6375                                 MonoGenericContext *context = mini_class_get_context (cmethod->klass);
6376                                 gboolean context_sharable = mono_generic_context_is_sharable (context, TRUE);
6377
6378                                 /*
6379                                  * Pass vtable iff target method might
6380                                  * be shared, which means that sharing
6381                                  * is enabled for its class and its
6382                                  * context is sharable (and it's not a
6383                                  * generic method).
6384                                  */
6385                                 if (sharing_enabled && context_sharable &&
6386                                         !(mini_method_get_context (cmethod) && mini_method_get_context (cmethod)->method_inst))
6387                                         pass_vtable = TRUE;
6388                         }
6389
6390                         if (cmethod && mini_method_get_context (cmethod) &&
6391                                         mini_method_get_context (cmethod)->method_inst) {
6392                                 gboolean sharing_enabled = mono_class_generic_sharing_enabled (cmethod->klass);
6393                                 MonoGenericContext *context = mini_method_get_context (cmethod);
6394                                 gboolean context_sharable = mono_generic_context_is_sharable (context, TRUE);
6395
6396                                 g_assert (!pass_vtable);
6397
6398                                 if (sharing_enabled && context_sharable)
6399                                         pass_mrgctx = TRUE;
6400                         }
6401
6402                         if (cfg->generic_sharing_context && cmethod) {
6403                                 MonoGenericContext *cmethod_context = mono_method_get_context (cmethod);
6404
6405                                 context_used = mono_method_check_context_used (cmethod);
6406
6407                                 if (context_used && (cmethod->klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
6408                                         /* Generic method interface
6409                                            calls are resolved via a
6410                                            helper function and don't
6411                                            need an imt. */
6412                                         if (!cmethod_context || !cmethod_context->method_inst)
6413                                                 pass_imt_from_rgctx = TRUE;
6414                                 }
6415
6416                                 /*
6417                                  * If a shared method calls another
6418                                  * shared method then the caller must
6419                                  * have a generic sharing context
6420                                  * because the magic trampoline
6421                                  * requires it.  FIXME: We shouldn't
6422                                  * have to force the vtable/mrgctx
6423                                  * variable here.  Instead there
6424                                  * should be a flag in the cfg to
6425                                  * request a generic sharing context.
6426                                  */
6427                                 if (context_used &&
6428                                                 ((method->flags & METHOD_ATTRIBUTE_STATIC) || method->klass->valuetype))
6429                                         mono_get_vtable_var (cfg);
6430                         }
6431
6432                         if (pass_vtable) {
6433                                 if (context_used) {
6434                                         vtable_arg = emit_get_rgctx_klass (cfg, context_used, cmethod->klass, MONO_RGCTX_INFO_VTABLE);
6435                                 } else {
6436                                         MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
6437
6438                                         CHECK_TYPELOAD (cmethod->klass);
6439                                         EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
6440                                 }
6441                         }
6442
6443                         if (pass_mrgctx) {
6444                                 g_assert (!vtable_arg);
6445
6446                                 if (!cfg->compile_aot) {
6447                                         /*
6448                                          * emit_get_rgctx_method () calls mono_class_vtable () so check
6449                                          * for type load errors before.
6450                                          */
6451                                         mono_class_setup_vtable (cmethod->klass);
6452                                         CHECK_TYPELOAD (cmethod->klass);
6453                                 }
6454
6455                                 vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_METHOD_RGCTX);
6456
6457                                 if (!(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
6458                                                 MONO_METHOD_IS_FINAL (cmethod)) {
6459                                         if (virtual)
6460                                                 check_this = TRUE;
6461                                         virtual = 0;
6462                                 }
6463                         }
6464
6465                         if (pass_imt_from_rgctx) {
6466                                 g_assert (!pass_vtable);
6467                                 g_assert (cmethod);
6468
6469                                 imt_arg = emit_get_rgctx_method (cfg, context_used,
6470                                         cmethod, MONO_RGCTX_INFO_METHOD);
6471                         }
6472
6473                         if (check_this)
6474                                 MONO_EMIT_NEW_CHECK_THIS (cfg, sp [0]->dreg);
6475
6476                         /* Calling virtual generic methods */
6477                         if (cmethod && virtual &&
6478                             (cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) &&
6479                             !(MONO_METHOD_IS_FINAL (cmethod) &&
6480                               cmethod->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) &&
6481                             mono_method_signature (cmethod)->generic_param_count) {
6482                                 MonoInst *this_temp, *this_arg_temp, *store;
6483                                 MonoInst *iargs [4];
6484
6485                                 g_assert (mono_method_signature (cmethod)->is_inflated);
6486
6487                                 /* Prevent inlining of methods that contain indirect calls */
6488                                 INLINE_FAILURE;
6489
6490 #if MONO_ARCH_HAVE_GENERALIZED_IMT_THUNK && defined(MONO_ARCH_GSHARED_SUPPORTED)
6491                                 if (cmethod->wrapper_type == MONO_WRAPPER_NONE && mono_use_imt) {
6492                                         g_assert (!imt_arg);
6493                                         if (!context_used)
6494                                                 g_assert (cmethod->is_inflated);
6495                                         imt_arg = emit_get_rgctx_method (cfg, context_used,
6496                                                                                                          cmethod, MONO_RGCTX_INFO_METHOD);
6497                                         ins = mono_emit_method_call_full (cfg, cmethod, fsig, sp, sp [0], imt_arg);
6498                                 } else
6499 #endif
6500                                 {
6501                                         this_temp = mono_compile_create_var (cfg, type_from_stack_type (sp [0]), OP_LOCAL);
6502                                         NEW_TEMPSTORE (cfg, store, this_temp->inst_c0, sp [0]);
6503                                         MONO_ADD_INS (bblock, store);
6504
6505                                         /* FIXME: This should be a managed pointer */
6506                                         this_arg_temp = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
6507
6508                                         EMIT_NEW_TEMPLOAD (cfg, iargs [0], this_temp->inst_c0);
6509                                         iargs [1] = emit_get_rgctx_method (cfg, context_used,
6510                                                                                                            cmethod, MONO_RGCTX_INFO_METHOD);
6511                                         EMIT_NEW_TEMPLOADA (cfg, iargs [2], this_arg_temp->inst_c0);
6512                                         addr = mono_emit_jit_icall (cfg,
6513                                                                                                 mono_helper_compile_generic_method, iargs);
6514
6515                                         EMIT_NEW_TEMPLOAD (cfg, sp [0], this_arg_temp->inst_c0);
6516
6517                                         ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr);
6518                                 }
6519
6520                                 if (!MONO_TYPE_IS_VOID (fsig->ret))
6521                                         *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
6522
6523                                 CHECK_CFG_EXCEPTION;
6524
6525                                 ip += 5;
6526                                 ins_flag = 0;
6527                                 break;
6528                         }
6529
6530 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6531                         supported_tail_call = cmethod && MONO_ARCH_USE_OP_TAIL_CALL (mono_method_signature (method), mono_method_signature (cmethod));
6532 #else
6533                         supported_tail_call = cmethod && mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)) && !MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->ret);
6534 #endif
6535
6536                         /* Tail prefix */
6537                         /* FIXME: runtime generic context pointer for jumps? */
6538                         /* FIXME: handle this for generic sharing eventually */
6539                         if ((ins_flag & MONO_INST_TAILCALL) && !cfg->generic_sharing_context && !vtable_arg && cmethod && (*ip == CEE_CALL) && supported_tail_call) {
6540                                 MonoCallInst *call;
6541
6542                                 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6543                                 INLINE_FAILURE;
6544
6545 #ifdef MONO_ARCH_USE_OP_TAIL_CALL
6546                                 /* Handle tail calls similarly to calls */
6547                                 call = mono_emit_call_args (cfg, mono_method_signature (cmethod), sp, FALSE, FALSE, TRUE);
6548 #else
6549                                 MONO_INST_NEW_CALL (cfg, call, OP_JMP);
6550                                 call->tail_call = TRUE;
6551                                 call->method = cmethod;
6552                                 call->signature = mono_method_signature (cmethod);
6553
6554                                 /*
6555                                  * We implement tail calls by storing the actual arguments into the
6556                                  * argument variables, then emitting a CEE_JMP.
6557                                  */
6558                                 for (i = 0; i < n; ++i) {
6559                                         /* Prevent argument from being register allocated */
6560                                         arg_array [i]->flags |= MONO_INST_VOLATILE;
6561                                         EMIT_NEW_ARGSTORE (cfg, ins, i, sp [i]);
6562                                 }
6563 #endif
6564
6565                                 ins = (MonoInst*)call;
6566                                 ins->inst_p0 = cmethod;
6567                                 ins->inst_p1 = arg_array [0];
6568                                 MONO_ADD_INS (bblock, ins);
6569                                 link_bblock (cfg, bblock, end_bblock);
6570                                 start_new_bblock = 1;
6571
6572                                 CHECK_CFG_EXCEPTION;
6573
6574                                 /* skip CEE_RET as well */
6575                                 ip += 6;
6576                                 ins_flag = 0;
6577                                 break;
6578                         }
6579
6580                         /* Conversion to a JIT intrinsic */
6581                         if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp))) {
6582                                 bblock = cfg->cbb;
6583                                 if (!MONO_TYPE_IS_VOID (fsig->ret)) {
6584                                         type_to_eval_stack_type ((cfg), fsig->ret, ins);
6585                                         *sp = ins;
6586                                         sp++;
6587                                 }
6588
6589                                 CHECK_CFG_EXCEPTION;
6590
6591                                 ip += 5;
6592                                 ins_flag = 0;
6593                                 break;
6594                         }
6595
6596                         /* Inlining */
6597                         if ((cfg->opt & MONO_OPT_INLINE) && cmethod &&
6598                                 (!virtual || !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL) || MONO_METHOD_IS_FINAL (cmethod)) &&
6599                             mono_method_check_inlining (cfg, cmethod) &&
6600                                  !g_list_find (dont_inline, cmethod)) {
6601                                 int costs;
6602                                 gboolean allways = FALSE;
6603
6604                                 if ((cmethod->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
6605                                         (cmethod->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
6606                                         /* Prevent inlining of methods that call wrappers */
6607                                         INLINE_FAILURE;
6608                                         cmethod = mono_marshal_get_native_wrapper (cmethod, check_for_pending_exc, FALSE);
6609                                         allways = TRUE;
6610                                 }
6611
6612                                 if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, allways))) {
6613                                         ip += 5;
6614                                         cfg->real_offset += 5;
6615                                         bblock = cfg->cbb;
6616
6617                                         if (!MONO_TYPE_IS_VOID (fsig->ret))
6618                                                 /* *sp is already set by inline_method */
6619                                                 sp++;
6620
6621                                         inline_costs += costs;
6622                                         ins_flag = 0;
6623                                         break;
6624                                 }
6625                         }
6626
6627                         inline_costs += 10 * num_calls++;
6628
6629                         /* Tail recursion elimination */
6630                         if ((cfg->opt & MONO_OPT_TAILC) && *ip == CEE_CALL && cmethod == method && ip [5] == CEE_RET && !vtable_arg) {
6631                                 gboolean has_vtargs = FALSE;
6632                                 int i;
6633
6634                                 /* Prevent inlining of methods with tail calls (the call stack would be altered) */
6635                                 INLINE_FAILURE;
6636
6637                                 /* keep it simple */
6638                                 for (i =  fsig->param_count - 1; i >= 0; i--) {
6639                                         if (MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->params [i]))
6640                                                 has_vtargs = TRUE;
6641                                 }
6642
6643                                 if (!has_vtargs) {
6644                                         for (i = 0; i < n; ++i)
6645                                                 EMIT_NEW_ARGSTORE (cfg, ins, i, sp [i]);
6646                                         MONO_INST_NEW (cfg, ins, OP_BR);
6647                                         MONO_ADD_INS (bblock, ins);
6648                                         tblock = start_bblock->out_bb [0];
6649                                         link_bblock (cfg, bblock, tblock);
6650                                         ins->inst_target_bb = tblock;
6651                                         start_new_bblock = 1;
6652
6653                                         /* skip the CEE_RET, too */
6654                                         if (ip_in_bb (cfg, bblock, ip + 5))
6655                                                 ip += 6;
6656                                         else
6657                                                 ip += 5;
6658
6659                                         ins_flag = 0;
6660                                         break;
6661                                 }
6662                         }
6663
6664                         /* Generic sharing */
6665                         /* FIXME: only do this for generic methods if
6666                            they are not shared! */
6667                         if (context_used && !imt_arg && !array_rank &&
6668                                         (!mono_method_is_generic_sharable_impl (cmethod, TRUE) ||
6669                                                 !mono_class_generic_sharing_enabled (cmethod->klass)) &&
6670                                         (!virtual || MONO_METHOD_IS_FINAL (cmethod) ||
6671                                                 !(cmethod->flags & METHOD_ATTRIBUTE_VIRTUAL))) {
6672                                 INLINE_FAILURE;
6673
6674                                 g_assert (cfg->generic_sharing_context && cmethod);
6675                                 g_assert (!addr);
6676
6677                                 /*
6678                                  * We are compiling a call to a
6679                                  * generic method from shared code,
6680                                  * which means that we have to look up
6681                                  * the method in the rgctx and do an
6682                                  * indirect call.
6683                                  */
6684                                 addr = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
6685                         }
6686
6687                         /* Indirect calls */
6688                         if (addr) {
6689                                 g_assert (!imt_arg);
6690
6691                                 if (*ip == CEE_CALL)
6692                                         g_assert (context_used);
6693                                 else if (*ip == CEE_CALLI)
6694                                         g_assert (!vtable_arg);
6695                                 else
6696                                         /* FIXME: what the hell is this??? */
6697                                         g_assert (cmethod->flags & METHOD_ATTRIBUTE_FINAL ||
6698                                                         !(cmethod->flags & METHOD_ATTRIBUTE_FINAL));
6699
6700                                 /* Prevent inlining of methods with indirect calls */
6701                                 INLINE_FAILURE;
6702
6703                                 if (vtable_arg) {
6704                                         MonoCallInst *call;
6705                                         int rgctx_reg = mono_alloc_preg (cfg);
6706
6707                                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, rgctx_reg, vtable_arg->dreg);
6708                                         ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr);
6709                                         call = (MonoCallInst*)ins;
6710                                         set_rgctx_arg (cfg, call, rgctx_reg, vtable_arg);
6711                                 } else {
6712                                         if (addr->opcode == OP_AOTCONST && addr->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
6713                                                 /*
6714                                                  * Instead of emitting an indirect call, emit a direct call
6715                                                  * with the contents of the aotconst as the patch info.
6716                                                  */
6717                                                 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_p0, fsig, sp);
6718                                                 NULLIFY_INS (addr);
6719                                         } else if (addr->opcode == OP_GOT_ENTRY && addr->inst_right->inst_c1 == MONO_PATCH_INFO_ICALL_ADDR) {
6720                                                 ins = (MonoInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_ICALL_ADDR, addr->inst_right->inst_left, fsig, sp);
6721                                                 NULLIFY_INS (addr);
6722                                         } else {
6723                                                 ins = (MonoInst*)mono_emit_calli (cfg, fsig, sp, addr);
6724                                         }
6725                                 }
6726                                 if (!MONO_TYPE_IS_VOID (fsig->ret))
6727                                         *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
6728
6729                                 CHECK_CFG_EXCEPTION;
6730
6731                                 ip += 5;
6732                                 ins_flag = 0;
6733                                 break;
6734                         }
6735
6736                         /* Array methods */
6737                         if (array_rank) {
6738                                 MonoInst *addr;
6739
6740                                 if (strcmp (cmethod->name, "Set") == 0) { /* array Set */
6741                                         if (sp [fsig->param_count]->type == STACK_OBJ) {
6742                                                 MonoInst *iargs [2];
6743
6744                                                 iargs [0] = sp [0];
6745                                                 iargs [1] = sp [fsig->param_count];
6746
6747                                                 mono_emit_jit_icall (cfg, mono_helper_stelem_ref_check, iargs);
6748                                         }
6749
6750                                         addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, TRUE);
6751                                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, fsig->params [fsig->param_count - 1], addr->dreg, 0, sp [fsig->param_count]->dreg);
6752                                 } else if (strcmp (cmethod->name, "Get") == 0) { /* array Get */
6753                                         addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, FALSE);
6754
6755                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, fsig->ret, addr->dreg, 0);
6756
6757                                         *sp++ = ins;
6758                                 } else if (strcmp (cmethod->name, "Address") == 0) { /* array Address */
6759                                         if (!cmethod->klass->element_class->valuetype && !readonly)
6760                                                 mini_emit_check_array_type (cfg, sp [0], cmethod->klass);
6761                                         CHECK_TYPELOAD (cmethod->klass);
6762
6763                                         readonly = FALSE;
6764                                         addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, FALSE);
6765                                         *sp++ = addr;
6766                                 } else {
6767                                         g_assert_not_reached ();
6768                                 }
6769
6770                                 CHECK_CFG_EXCEPTION;
6771
6772                                 ip += 5;
6773                                 ins_flag = 0;
6774                                 break;
6775                         }
6776
6777                         ins = mini_redirect_call (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL);
6778                         if (ins) {
6779                                 if (!MONO_TYPE_IS_VOID (fsig->ret))
6780                                         *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
6781
6782                                 CHECK_CFG_EXCEPTION;
6783
6784                                 ip += 5;
6785                                 ins_flag = 0;
6786                                 break;
6787                         }
6788
6789                         /* Common call */
6790                         INLINE_FAILURE;
6791                         if (vtable_arg) {
6792                                 ins = mono_emit_rgctx_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL,
6793                                         NULL, vtable_arg);
6794                         } else if (imt_arg) {
6795                                 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, imt_arg);
6796                         } else {
6797                                 ins = (MonoInst*)mono_emit_method_call_full (cfg, cmethod, fsig, sp, virtual ? sp [0] : NULL, NULL);
6798                         }
6799
6800                         if (!MONO_TYPE_IS_VOID (fsig->ret))
6801                                 *sp++ = mono_emit_widen_call_res (cfg, ins, fsig);
6802
6803                         CHECK_CFG_EXCEPTION;
6804
6805                         ip += 5;
6806                         ins_flag = 0;
6807                         break;
6808                 }
6809                 case CEE_RET:
6810                         if (cfg->method != method) {
6811                                 /* return from inlined method */
6812                                 /*
6813                                  * If in_count == 0, that means the ret is unreachable due to
6814                                  * being preceeded by a throw. In that case, inline_method () will
6815                                  * handle setting the return value
6816                                  * (test case: test_0_inline_throw ()).
6817                                  */
6818                                 if (return_var && cfg->cbb->in_count) {
6819                                         MonoInst *store;
6820                                         CHECK_STACK (1);
6821                                         --sp;
6822                                         //g_assert (returnvar != -1);
6823                                         EMIT_NEW_TEMPSTORE (cfg, store, return_var->inst_c0, *sp);
6824                                         cfg->ret_var_set = TRUE;
6825                                 }
6826                         } else {
6827                                 if (cfg->ret) {
6828                                         MonoType *ret_type = mono_method_signature (method)->ret;
6829
6830                                         if (seq_points) {
6831                                                 /*
6832                                                  * Place a seq point here too even through the IL stack is not
6833                                                  * empty, so a step over on
6834                                                  * call <FOO>
6835                                                  * ret
6836                                                  * will work correctly.
6837                                                  */
6838                                                 NEW_SEQ_POINT (cfg, ins, ip - header->code, TRUE);
6839                                                 MONO_ADD_INS (cfg->cbb, ins);
6840                                         }
6841
6842                                         g_assert (!return_var);
6843                                         CHECK_STACK (1);
6844                                         --sp;
6845                                         if (mini_type_to_stind (cfg, ret_type) == CEE_STOBJ) {
6846                                                 MonoInst *ret_addr;
6847
6848                                                 if (!cfg->vret_addr) {
6849                                                         MonoInst *ins;
6850
6851                                                         EMIT_NEW_VARSTORE (cfg, ins, cfg->ret, ret_type, (*sp));
6852                                                 } else {
6853                                                         EMIT_NEW_RETLOADA (cfg, ret_addr);
6854
6855                                                         EMIT_NEW_STORE_MEMBASE (cfg, ins, OP_STOREV_MEMBASE, ret_addr->dreg, 0, (*sp)->dreg);
6856                                                         ins->klass = mono_class_from_mono_type (ret_type);
6857                                                 }
6858                                         } else {
6859 #ifdef MONO_ARCH_SOFT_FLOAT
6860                                                 if (COMPILE_SOFT_FLOAT (cfg) && !ret_type->byref && ret_type->type == MONO_TYPE_R4) {
6861                                                         MonoInst *iargs [1];
6862                                                         MonoInst *conv;
6863
6864                                                         iargs [0] = *sp;
6865                                                         conv = mono_emit_jit_icall (cfg, mono_fload_r4_arg, iargs);
6866                                                         mono_arch_emit_setret (cfg, method, conv);
6867                                                 } else {
6868                                                         mono_arch_emit_setret (cfg, method, *sp);
6869                                                 }
6870 #else
6871                                                 mono_arch_emit_setret (cfg, method, *sp);
6872 #endif
6873                                         }
6874                                 }
6875                         }
6876                         if (sp != stack_start)
6877                                 UNVERIFIED;
6878                         MONO_INST_NEW (cfg, ins, OP_BR);
6879                         ip++;
6880                         ins->inst_target_bb = end_bblock;
6881                         MONO_ADD_INS (bblock, ins);
6882                         link_bblock (cfg, bblock, end_bblock);
6883                         start_new_bblock = 1;
6884                         break;
6885                 case CEE_BR_S:
6886                         CHECK_OPSIZE (2);
6887                         MONO_INST_NEW (cfg, ins, OP_BR);
6888                         ip++;
6889                         target = ip + 1 + (signed char)(*ip);
6890                         ++ip;
6891                         GET_BBLOCK (cfg, tblock, target);
6892                         link_bblock (cfg, bblock, tblock);
6893                         ins->inst_target_bb = tblock;
6894                         if (sp != stack_start) {
6895                                 handle_stack_args (cfg, stack_start, sp - stack_start);
6896                                 sp = stack_start;
6897                                 CHECK_UNVERIFIABLE (cfg);
6898                         }
6899                         MONO_ADD_INS (bblock, ins);
6900                         start_new_bblock = 1;
6901                         inline_costs += BRANCH_COST;
6902                         break;
6903                 case CEE_BEQ_S:
6904                 case CEE_BGE_S:
6905                 case CEE_BGT_S:
6906                 case CEE_BLE_S:
6907                 case CEE_BLT_S:
6908                 case CEE_BNE_UN_S:
6909                 case CEE_BGE_UN_S:
6910                 case CEE_BGT_UN_S:
6911                 case CEE_BLE_UN_S:
6912                 case CEE_BLT_UN_S:
6913                         CHECK_OPSIZE (2);
6914                         CHECK_STACK (2);
6915                         MONO_INST_NEW (cfg, ins, *ip + BIG_BRANCH_OFFSET);
6916                         ip++;
6917                         target = ip + 1 + *(signed char*)ip;
6918                         ip++;
6919
6920                         ADD_BINCOND (NULL);
6921
6922                         sp = stack_start;
6923                         inline_costs += BRANCH_COST;
6924                         break;
6925                 case CEE_BR:
6926                         CHECK_OPSIZE (5);
6927                         MONO_INST_NEW (cfg, ins, OP_BR);
6928                         ip++;
6929
6930                         target = ip + 4 + (gint32)read32(ip);
6931                         ip += 4;
6932                         GET_BBLOCK (cfg, tblock, target);
6933                         link_bblock (cfg, bblock, tblock);
6934                         ins->inst_target_bb = tblock;
6935                         if (sp != stack_start) {
6936                                 handle_stack_args (cfg, stack_start, sp - stack_start);
6937                                 sp = stack_start;
6938                                 CHECK_UNVERIFIABLE (cfg);
6939                         }
6940
6941                         MONO_ADD_INS (bblock, ins);
6942
6943                         start_new_bblock = 1;
6944                         inline_costs += BRANCH_COST;
6945                         break;
6946                 case CEE_BRFALSE_S:
6947                 case CEE_BRTRUE_S:
6948                 case CEE_BRFALSE:
6949                 case CEE_BRTRUE: {
6950                         MonoInst *cmp;
6951                         gboolean is_short = ((*ip) == CEE_BRFALSE_S) || ((*ip) == CEE_BRTRUE_S);
6952                         gboolean is_true = ((*ip) == CEE_BRTRUE_S) || ((*ip) == CEE_BRTRUE);
6953                         guint32 opsize = is_short ? 1 : 4;
6954
6955                         CHECK_OPSIZE (opsize);
6956                         CHECK_STACK (1);
6957                         if (sp [-1]->type == STACK_VTYPE || sp [-1]->type == STACK_R8)
6958                                 UNVERIFIED;
6959                         ip ++;
6960                         target = ip + opsize + (is_short ? *(signed char*)ip : (gint32)read32(ip));
6961                         ip += opsize;
6962
6963                         sp--;
6964
6965                         GET_BBLOCK (cfg, tblock, target);
6966                         link_bblock (cfg, bblock, tblock);
6967                         GET_BBLOCK (cfg, tblock, ip);
6968                         link_bblock (cfg, bblock, tblock);
6969
6970                         if (sp != stack_start) {
6971                                 handle_stack_args (cfg, stack_start, sp - stack_start);
6972                                 CHECK_UNVERIFIABLE (cfg);
6973                         }
6974
6975                         MONO_INST_NEW(cfg, cmp, OP_ICOMPARE_IMM);
6976                         cmp->sreg1 = sp [0]->dreg;
6977                         type_from_op (cmp, sp [0], NULL);
6978                         CHECK_TYPE (cmp);
6979
6980 #if SIZEOF_REGISTER == 4
6981                         if (cmp->opcode == OP_LCOMPARE_IMM) {
6982                                 /* Convert it to OP_LCOMPARE */
6983                                 MONO_INST_NEW (cfg, ins, OP_I8CONST);
6984                                 ins->type = STACK_I8;
6985                                 ins->dreg = alloc_dreg (cfg, STACK_I8);
6986                                 ins->inst_l = 0;
6987                                 MONO_ADD_INS (bblock, ins);
6988                                 cmp->opcode = OP_LCOMPARE;
6989                                 cmp->sreg2 = ins->dreg;
6990                         }
6991 #endif
6992                         MONO_ADD_INS (bblock, cmp);
6993
6994                         MONO_INST_NEW (cfg, ins, is_true ? CEE_BNE_UN : CEE_BEQ);
6995                         type_from_op (ins, sp [0], NULL);
6996                         MONO_ADD_INS (bblock, ins);
6997                         ins->inst_many_bb = mono_mempool_alloc (cfg->mempool, sizeof(gpointer)*2);
6998                         GET_BBLOCK (cfg, tblock, target);
6999                         ins->inst_true_bb = tblock;
7000                         GET_BBLOCK (cfg, tblock, ip);
7001                         ins->inst_false_bb = tblock;
7002                         start_new_bblock = 2;
7003
7004                         sp = stack_start;
7005                         inline_costs += BRANCH_COST;
7006                         break;
7007                 }
7008                 case CEE_BEQ:
7009                 case CEE_BGE:
7010                 case CEE_BGT:
7011                 case CEE_BLE:
7012                 case CEE_BLT:
7013                 case CEE_BNE_UN:
7014                 case CEE_BGE_UN:
7015                 case CEE_BGT_UN:
7016                 case CEE_BLE_UN:
7017                 case CEE_BLT_UN:
7018                         CHECK_OPSIZE (5);
7019                         CHECK_STACK (2);
7020                         MONO_INST_NEW (cfg, ins, *ip);
7021                         ip++;
7022                         target = ip + 4 + (gint32)read32(ip);
7023                         ip += 4;
7024
7025                         ADD_BINCOND (NULL);
7026
7027                         sp = stack_start;
7028                         inline_costs += BRANCH_COST;
7029                         break;
7030                 case CEE_SWITCH: {
7031                         MonoInst *src1;
7032                         MonoBasicBlock **targets;
7033                         MonoBasicBlock *default_bblock;
7034                         MonoJumpInfoBBTable *table;
7035                         int offset_reg = alloc_preg (cfg);
7036                         int target_reg = alloc_preg (cfg);
7037                         int table_reg = alloc_preg (cfg);
7038                         int sum_reg = alloc_preg (cfg);
7039                         gboolean use_op_switch;
7040
7041                         CHECK_OPSIZE (5);
7042                         CHECK_STACK (1);
7043                         n = read32 (ip + 1);
7044                         --sp;
7045                         src1 = sp [0];
7046                         if ((src1->type != STACK_I4) && (src1->type != STACK_PTR))
7047                                 UNVERIFIED;
7048
7049                         ip += 5;
7050                         CHECK_OPSIZE (n * sizeof (guint32));
7051                         target = ip + n * sizeof (guint32);
7052
7053                         GET_BBLOCK (cfg, default_bblock, target);
7054
7055                         targets = mono_mempool_alloc (cfg->mempool, sizeof (MonoBasicBlock*) * n);
7056                         for (i = 0; i < n; ++i) {
7057                                 GET_BBLOCK (cfg, tblock, target + (gint32)read32(ip));
7058                                 targets [i] = tblock;
7059                                 ip += 4;
7060                         }
7061
7062                         if (sp != stack_start) {
7063                                 /*
7064                                  * Link the current bb with the targets as well, so handle_stack_args
7065                                  * will set their in_stack correctly.
7066                                  */
7067                                 link_bblock (cfg, bblock, default_bblock);
7068                                 for (i = 0; i < n; ++i)
7069                                         link_bblock (cfg, bblock, targets [i]);
7070
7071                                 handle_stack_args (cfg, stack_start, sp - stack_start);
7072                                 sp = stack_start;
7073                                 CHECK_UNVERIFIABLE (cfg);
7074                         }
7075
7076                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ICOMPARE_IMM, -1, src1->dreg, n);
7077                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_IBGE_UN, default_bblock);
7078                         bblock = cfg->cbb;
7079
7080                         for (i = 0; i < n; ++i)
7081                                 link_bblock (cfg, bblock, targets [i]);
7082
7083                         table = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfoBBTable));
7084                         table->table = targets;
7085                         table->table_size = n;
7086
7087                         use_op_switch = FALSE;
7088 #ifdef TARGET_ARM
7089                         /* ARM implements SWITCH statements differently */
7090                         /* FIXME: Make it use the generic implementation */
7091                         if (!cfg->compile_aot)
7092                                 use_op_switch = TRUE;
7093 #endif
7094
7095                         if (COMPILE_LLVM (cfg))
7096                                 use_op_switch = TRUE;
7097
7098                         cfg->cbb->has_jump_table = 1;
7099
7100                         if (use_op_switch) {
7101                                 MONO_INST_NEW (cfg, ins, OP_SWITCH);
7102                                 ins->sreg1 = src1->dreg;
7103                                 ins->inst_p0 = table;
7104                                 ins->inst_many_bb = targets;
7105                                 ins->klass = GUINT_TO_POINTER (n);
7106                                 MONO_ADD_INS (cfg->cbb, ins);
7107                         } else {
7108                                 if (sizeof (gpointer) == 8)
7109                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, offset_reg, src1->dreg, 3);
7110                                 else
7111                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, offset_reg, src1->dreg, 2);
7112
7113 #if SIZEOF_REGISTER == 8
7114                                 /* The upper word might not be zero, and we add it to a 64 bit address later */
7115                                 MONO_EMIT_NEW_UNALU (cfg, OP_ZEXT_I4, offset_reg, offset_reg);
7116 #endif
7117
7118                                 if (cfg->compile_aot) {
7119                                         MONO_EMIT_NEW_AOTCONST (cfg, table_reg, table, MONO_PATCH_INFO_SWITCH);
7120                                 } else {
7121                                         MONO_INST_NEW (cfg, ins, OP_JUMP_TABLE);
7122                                         ins->inst_c1 = MONO_PATCH_INFO_SWITCH;
7123                                         ins->inst_p0 = table;
7124                                         ins->dreg = table_reg;
7125                                         MONO_ADD_INS (cfg->cbb, ins);
7126                                 }
7127
7128                                 /* FIXME: Use load_memindex */
7129                                 MONO_EMIT_NEW_BIALU (cfg, OP_PADD, sum_reg, table_reg, offset_reg);
7130                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, target_reg, sum_reg, 0);
7131                                 MONO_EMIT_NEW_UNALU (cfg, OP_BR_REG, -1, target_reg);
7132                         }
7133                         start_new_bblock = 1;
7134                         inline_costs += (BRANCH_COST * 2);
7135                         break;
7136                 }
7137                 case CEE_LDIND_I1:
7138                 case CEE_LDIND_U1:
7139                 case CEE_LDIND_I2:
7140                 case CEE_LDIND_U2:
7141                 case CEE_LDIND_I4:
7142                 case CEE_LDIND_U4:
7143                 case CEE_LDIND_I8:
7144                 case CEE_LDIND_I:
7145                 case CEE_LDIND_R4:
7146                 case CEE_LDIND_R8:
7147                 case CEE_LDIND_REF:
7148                         CHECK_STACK (1);
7149                         --sp;
7150
7151                         switch (*ip) {
7152                         case CEE_LDIND_R4:
7153                         case CEE_LDIND_R8:
7154                                 dreg = alloc_freg (cfg);
7155                                 break;
7156                         case CEE_LDIND_I8:
7157                                 dreg = alloc_lreg (cfg);
7158                                 break;
7159                         default:
7160                                 dreg = alloc_preg (cfg);
7161                         }
7162
7163                         NEW_LOAD_MEMBASE (cfg, ins, ldind_to_load_membase (*ip), dreg, sp [0]->dreg, 0);
7164                         ins->type = ldind_type [*ip - CEE_LDIND_I1];
7165                         ins->flags |= ins_flag;
7166                         ins_flag = 0;
7167                         MONO_ADD_INS (bblock, ins);
7168                         *sp++ = ins;
7169                         ++ip;
7170                         break;
7171                 case CEE_STIND_REF:
7172                 case CEE_STIND_I1:
7173                 case CEE_STIND_I2:
7174                 case CEE_STIND_I4:
7175                 case CEE_STIND_I8:
7176                 case CEE_STIND_R4:
7177                 case CEE_STIND_R8:
7178                 case CEE_STIND_I:
7179                         CHECK_STACK (2);
7180                         sp -= 2;
7181
7182                         NEW_STORE_MEMBASE (cfg, ins, stind_to_store_membase (*ip), sp [0]->dreg, 0, sp [1]->dreg);
7183                         ins->flags |= ins_flag;
7184                         ins_flag = 0;
7185                         MONO_ADD_INS (bblock, ins);
7186
7187                         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))) {
7188                                 MonoInst *dummy_use;
7189                                 /* insert call to write barrier */
7190                                 MonoMethod *write_barrier = mono_gc_get_write_barrier ();
7191                                 mono_emit_method_call (cfg, write_barrier, sp, NULL);
7192                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, sp [1]);
7193                         }
7194
7195                         inline_costs += 1;
7196                         ++ip;
7197                         break;
7198
7199                 case CEE_MUL:
7200                         CHECK_STACK (2);
7201
7202                         MONO_INST_NEW (cfg, ins, (*ip));
7203                         sp -= 2;
7204                         ins->sreg1 = sp [0]->dreg;
7205                         ins->sreg2 = sp [1]->dreg;
7206                         type_from_op (ins, sp [0], sp [1]);
7207                         CHECK_TYPE (ins);
7208                         ins->dreg = alloc_dreg ((cfg), (ins)->type);
7209
7210                         /* Use the immediate opcodes if possible */
7211                         if ((sp [1]->opcode == OP_ICONST) && mono_arch_is_inst_imm (sp [1]->inst_c0)) {
7212                                 int imm_opcode = mono_op_to_op_imm (ins->opcode);
7213                                 if (imm_opcode != -1) {
7214                                         ins->opcode = imm_opcode;
7215                                         ins->inst_p1 = (gpointer)(gssize)(sp [1]->inst_c0);
7216                                         ins->sreg2 = -1;
7217
7218                                         sp [1]->opcode = OP_NOP;
7219                                 }
7220                         }
7221
7222                         MONO_ADD_INS ((cfg)->cbb, (ins));
7223
7224                         *sp++ = mono_decompose_opcode (cfg, ins);
7225                         ip++;
7226                         break;
7227                 case CEE_ADD:
7228                 case CEE_SUB:
7229                 case CEE_DIV:
7230                 case CEE_DIV_UN:
7231                 case CEE_REM:
7232                 case CEE_REM_UN:
7233                 case CEE_AND:
7234                 case CEE_OR:
7235                 case CEE_XOR:
7236                 case CEE_SHL:
7237                 case CEE_SHR:
7238                 case CEE_SHR_UN:
7239                         CHECK_STACK (2);
7240
7241                         MONO_INST_NEW (cfg, ins, (*ip));
7242                         sp -= 2;
7243                         ins->sreg1 = sp [0]->dreg;
7244                         ins->sreg2 = sp [1]->dreg;
7245                         type_from_op (ins, sp [0], sp [1]);
7246                         CHECK_TYPE (ins);
7247                         ADD_WIDEN_OP (ins, sp [0], sp [1]);
7248                         ins->dreg = alloc_dreg ((cfg), (ins)->type);
7249
7250                         /* FIXME: Pass opcode to is_inst_imm */
7251
7252                         /* Use the immediate opcodes if possible */
7253                         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)) {
7254                                 int imm_opcode;
7255
7256                                 imm_opcode = mono_op_to_op_imm_noemul (ins->opcode);
7257                                 if (imm_opcode != -1) {
7258                                         ins->opcode = imm_opcode;
7259                                         if (sp [1]->opcode == OP_I8CONST) {
7260 #if SIZEOF_REGISTER == 8
7261                                                 ins->inst_imm = sp [1]->inst_l;
7262 #else
7263                                                 ins->inst_ls_word = sp [1]->inst_ls_word;
7264                                                 ins->inst_ms_word = sp [1]->inst_ms_word;
7265 #endif
7266                                         }
7267                                         else
7268                                                 ins->inst_imm = (gssize)(sp [1]->inst_c0);
7269                                         ins->sreg2 = -1;
7270
7271                                         /* Might be followed by an instruction added by ADD_WIDEN_OP */
7272                                         if (sp [1]->next == NULL)
7273                                                 sp [1]->opcode = OP_NOP;
7274                                 }
7275                         }
7276                         MONO_ADD_INS ((cfg)->cbb, (ins));
7277
7278                         *sp++ = mono_decompose_opcode (cfg, ins);
7279                         ip++;
7280                         break;
7281                 case CEE_NEG:
7282                 case CEE_NOT:
7283                 case CEE_CONV_I1:
7284                 case CEE_CONV_I2:
7285                 case CEE_CONV_I4:
7286                 case CEE_CONV_R4:
7287                 case CEE_CONV_R8:
7288                 case CEE_CONV_U4:
7289                 case CEE_CONV_I8:
7290                 case CEE_CONV_U8:
7291                 case CEE_CONV_OVF_I8:
7292                 case CEE_CONV_OVF_U8:
7293                 case CEE_CONV_R_UN:
7294                         CHECK_STACK (1);
7295
7296                         /* Special case this earlier so we have long constants in the IR */
7297                         if ((((*ip) == CEE_CONV_I8) || ((*ip) == CEE_CONV_U8)) && (sp [-1]->opcode == OP_ICONST)) {
7298                                 int data = sp [-1]->inst_c0;
7299                                 sp [-1]->opcode = OP_I8CONST;
7300                                 sp [-1]->type = STACK_I8;
7301 #if SIZEOF_REGISTER == 8
7302                                 if ((*ip) == CEE_CONV_U8)
7303                                         sp [-1]->inst_c0 = (guint32)data;
7304                                 else
7305                                         sp [-1]->inst_c0 = data;
7306 #else
7307                                 sp [-1]->inst_ls_word = data;
7308                                 if ((*ip) == CEE_CONV_U8)
7309                                         sp [-1]->inst_ms_word = 0;
7310                                 else
7311                                         sp [-1]->inst_ms_word = (data < 0) ? -1 : 0;
7312 #endif
7313                                 sp [-1]->dreg = alloc_dreg (cfg, STACK_I8);
7314                         }
7315                         else {
7316                                 ADD_UNOP (*ip);
7317                         }
7318                         ip++;
7319                         break;
7320                 case CEE_CONV_OVF_I4:
7321                 case CEE_CONV_OVF_I1:
7322                 case CEE_CONV_OVF_I2:
7323                 case CEE_CONV_OVF_I:
7324                 case CEE_CONV_OVF_U:
7325                         CHECK_STACK (1);
7326
7327                         if (sp [-1]->type == STACK_R8) {
7328                                 ADD_UNOP (CEE_CONV_OVF_I8);
7329                                 ADD_UNOP (*ip);
7330                         } else {
7331                                 ADD_UNOP (*ip);
7332                         }
7333                         ip++;
7334                         break;
7335                 case CEE_CONV_OVF_U1:
7336                 case CEE_CONV_OVF_U2:
7337                 case CEE_CONV_OVF_U4:
7338                         CHECK_STACK (1);
7339
7340                         if (sp [-1]->type == STACK_R8) {
7341                                 ADD_UNOP (CEE_CONV_OVF_U8);
7342                                 ADD_UNOP (*ip);
7343                         } else {
7344                                 ADD_UNOP (*ip);
7345                         }
7346                         ip++;
7347                         break;
7348                 case CEE_CONV_OVF_I1_UN:
7349                 case CEE_CONV_OVF_I2_UN:
7350                 case CEE_CONV_OVF_I4_UN:
7351                 case CEE_CONV_OVF_I8_UN:
7352                 case CEE_CONV_OVF_U1_UN:
7353                 case CEE_CONV_OVF_U2_UN:
7354                 case CEE_CONV_OVF_U4_UN:
7355                 case CEE_CONV_OVF_U8_UN:
7356                 case CEE_CONV_OVF_I_UN:
7357                 case CEE_CONV_OVF_U_UN:
7358                 case CEE_CONV_U2:
7359                 case CEE_CONV_U1:
7360                 case CEE_CONV_I:
7361                 case CEE_CONV_U:
7362                         CHECK_STACK (1);
7363                         ADD_UNOP (*ip);
7364                         CHECK_CFG_EXCEPTION;
7365                         ip++;
7366                         break;
7367                 case CEE_ADD_OVF:
7368                 case CEE_ADD_OVF_UN:
7369                 case CEE_MUL_OVF:
7370                 case CEE_MUL_OVF_UN:
7371                 case CEE_SUB_OVF:
7372                 case CEE_SUB_OVF_UN:
7373                         CHECK_STACK (2);
7374                         ADD_BINOP (*ip);
7375                         ip++;
7376                         break;
7377                 case CEE_CPOBJ:
7378                         CHECK_OPSIZE (5);
7379                         CHECK_STACK (2);
7380                         token = read32 (ip + 1);
7381                         klass = mini_get_class (method, token, generic_context);
7382                         CHECK_TYPELOAD (klass);
7383                         sp -= 2;
7384                         if (generic_class_is_reference_type (cfg, klass)) {
7385                                 MonoInst *store, *load;
7386                                 int dreg = alloc_preg (cfg);
7387
7388                                 NEW_LOAD_MEMBASE (cfg, load, OP_LOAD_MEMBASE, dreg, sp [1]->dreg, 0);
7389                                 load->flags |= ins_flag;
7390                                 MONO_ADD_INS (cfg->cbb, load);
7391
7392                                 NEW_STORE_MEMBASE (cfg, store, OP_STORE_MEMBASE_REG, sp [0]->dreg, 0, dreg);
7393                                 store->flags |= ins_flag;
7394                                 MONO_ADD_INS (cfg->cbb, store);
7395
7396                                 if (cfg->gen_write_barriers && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER) {
7397                                         MonoInst *dummy_use;
7398                                         MonoMethod *write_barrier = mono_gc_get_write_barrier ();
7399                                         mono_emit_method_call (cfg, write_barrier, sp, NULL);
7400                                         EMIT_NEW_DUMMY_USE (cfg, dummy_use, sp [1]);
7401                                 }
7402                         } else {
7403                                 mini_emit_stobj (cfg, sp [0], sp [1], klass, FALSE);
7404                         }
7405                         ins_flag = 0;
7406                         ip += 5;
7407                         break;
7408                 case CEE_LDOBJ: {
7409                         int loc_index = -1;
7410                         int stloc_len = 0;
7411
7412                         CHECK_OPSIZE (5);
7413                         CHECK_STACK (1);
7414                         --sp;
7415                         token = read32 (ip + 1);
7416                         klass = mini_get_class (method, token, generic_context);
7417                         CHECK_TYPELOAD (klass);
7418
7419                         /* Optimize the common ldobj+stloc combination */
7420                         switch (ip [5]) {
7421                         case CEE_STLOC_S:
7422                                 loc_index = ip [6];
7423                                 stloc_len = 2;
7424                                 break;
7425                         case CEE_STLOC_0:
7426                         case CEE_STLOC_1:
7427                         case CEE_STLOC_2:
7428                         case CEE_STLOC_3:
7429                                 loc_index = ip [5] - CEE_STLOC_0;
7430                                 stloc_len = 1;
7431                                 break;
7432                         default:
7433                                 break;
7434                         }
7435
7436                         if ((loc_index != -1) && ip_in_bb (cfg, bblock, ip + 5)) {
7437                                 CHECK_LOCAL (loc_index);
7438
7439                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0);
7440                                 ins->dreg = cfg->locals [loc_index]->dreg;
7441                                 ip += 5;
7442                                 ip += stloc_len;
7443                                 break;
7444                         }
7445
7446                         /* Optimize the ldobj+stobj combination */
7447                         /* The reference case ends up being a load+store anyway */
7448                         if (((ip [5] == CEE_STOBJ) && ip_in_bb (cfg, bblock, ip + 5) && read32 (ip + 6) == token) && !generic_class_is_reference_type (cfg, klass)) {
7449                                 CHECK_STACK (1);
7450
7451                                 sp --;
7452
7453                                 mini_emit_stobj (cfg, sp [0], sp [1], klass, FALSE);
7454
7455                                 ip += 5 + 5;
7456                                 ins_flag = 0;
7457                                 break;
7458                         }
7459
7460                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0);
7461                         *sp++ = ins;
7462
7463                         ip += 5;
7464                         ins_flag = 0;
7465                         inline_costs += 1;
7466                         break;
7467                 }
7468                 case CEE_LDSTR:
7469                         CHECK_STACK_OVF (1);
7470                         CHECK_OPSIZE (5);
7471                         n = read32 (ip + 1);
7472
7473                         if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
7474                                 EMIT_NEW_PCONST (cfg, ins, mono_method_get_wrapper_data (method, n));
7475                                 ins->type = STACK_OBJ;
7476                                 *sp = ins;
7477                         }
7478                         else if (method->wrapper_type != MONO_WRAPPER_NONE) {
7479                                 MonoInst *iargs [1];
7480
7481                                 EMIT_NEW_PCONST (cfg, iargs [0], mono_method_get_wrapper_data (method, n));
7482                                 *sp = mono_emit_jit_icall (cfg, mono_string_new_wrapper, iargs);
7483                         } else {
7484                                 if (cfg->opt & MONO_OPT_SHARED) {
7485                                         MonoInst *iargs [3];
7486
7487                                         if (cfg->compile_aot) {
7488                                                 cfg->ldstr_list = g_list_prepend (cfg->ldstr_list, GINT_TO_POINTER (n));
7489                                         }
7490                                         EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
7491                                         EMIT_NEW_IMAGECONST (cfg, iargs [1], image);
7492                                         EMIT_NEW_ICONST (cfg, iargs [2], mono_metadata_token_index (n));
7493                                         *sp = mono_emit_jit_icall (cfg, mono_ldstr, iargs);
7494                                         mono_ldstr (cfg->domain, image, mono_metadata_token_index (n));
7495                                 } else {
7496                                         if (bblock->out_of_line) {
7497                                                 MonoInst *iargs [2];
7498
7499                                                 if (image == mono_defaults.corlib) {
7500                                                         /*
7501                                                          * Avoid relocations in AOT and save some space by using a
7502                                                          * version of helper_ldstr specialized to mscorlib.
7503                                                          */
7504                                                         EMIT_NEW_ICONST (cfg, iargs [0], mono_metadata_token_index (n));
7505                                                         *sp = mono_emit_jit_icall (cfg, mono_helper_ldstr_mscorlib, iargs);
7506                                                 } else {
7507                                                         /* Avoid creating the string object */
7508                                                         EMIT_NEW_IMAGECONST (cfg, iargs [0], image);
7509                                                         EMIT_NEW_ICONST (cfg, iargs [1], mono_metadata_token_index (n));
7510                                                         *sp = mono_emit_jit_icall (cfg, mono_helper_ldstr, iargs);
7511                                                 }
7512                                         }
7513                                         else
7514                                         if (cfg->compile_aot) {
7515                                                 NEW_LDSTRCONST (cfg, ins, image, n);
7516                                                 *sp = ins;
7517                                                 MONO_ADD_INS (bblock, ins);
7518                                         }
7519                                         else {
7520                                                 NEW_PCONST (cfg, ins, NULL);
7521                                                 ins->type = STACK_OBJ;
7522                                                 ins->inst_p0 = mono_ldstr (cfg->domain, image, mono_metadata_token_index (n));
7523                                                 *sp = ins;
7524                                                 MONO_ADD_INS (bblock, ins);
7525                                         }
7526                                 }
7527                         }
7528
7529                         sp++;
7530                         ip += 5;
7531                         break;
7532                 case CEE_NEWOBJ: {
7533                         MonoInst *iargs [2];
7534                         MonoMethodSignature *fsig;
7535                         MonoInst this_ins;
7536                         MonoInst *alloc;
7537                         MonoInst *vtable_arg = NULL;
7538
7539                         CHECK_OPSIZE (5);
7540                         token = read32 (ip + 1);
7541                         cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
7542                         if (!cmethod)
7543                                 goto load_error;
7544                         fsig = mono_method_get_signature (cmethod, image, token);
7545                         if (!fsig)
7546                                 goto load_error;
7547
7548                         mono_save_token_info (cfg, image, token, cmethod);
7549
7550                         if (!mono_class_init (cmethod->klass))
7551                                 goto load_error;
7552
7553                         if (cfg->generic_sharing_context)
7554                                 context_used = mono_method_check_context_used (cmethod);
7555
7556                         if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
7557                                 if (check_linkdemand (cfg, method, cmethod))
7558                                         INLINE_FAILURE;
7559                                 CHECK_CFG_EXCEPTION;
7560                         } else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
7561                                 ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock, ip);
7562                         }
7563
7564                         if (cmethod->klass->valuetype && mono_class_generic_sharing_enabled (cmethod->klass) &&
7565                                         mono_method_is_generic_sharable_impl (cmethod, TRUE)) {
7566                                 if (cmethod->is_inflated && mono_method_get_context (cmethod)->method_inst) {
7567                                         mono_class_vtable (cfg->domain, cmethod->klass);
7568                                         CHECK_TYPELOAD (cmethod->klass);
7569
7570                                         vtable_arg = emit_get_rgctx_method (cfg, context_used,
7571                                                                                                                 cmethod, MONO_RGCTX_INFO_METHOD_RGCTX);
7572                                 } else {
7573                                         if (context_used) {
7574                                                 vtable_arg = emit_get_rgctx_klass (cfg, context_used,
7575                                                         cmethod->klass, MONO_RGCTX_INFO_VTABLE);
7576                                         } else {
7577                                                 MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
7578
7579                                                 CHECK_TYPELOAD (cmethod->klass);
7580                                                 EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
7581                                         }
7582                                 }
7583                         }
7584
7585                         n = fsig->param_count;
7586                         CHECK_STACK (n);
7587
7588                         /*
7589                          * Generate smaller code for the common newobj <exception> instruction in
7590                          * argument checking code.
7591                          */
7592                         if (bblock->out_of_line && cmethod->klass->image == mono_defaults.corlib &&
7593                                 is_exception_class (cmethod->klass) && n <= 2 &&
7594                                 ((n < 1) || (!fsig->params [0]->byref && fsig->params [0]->type == MONO_TYPE_STRING)) &&
7595                                 ((n < 2) || (!fsig->params [1]->byref && fsig->params [1]->type == MONO_TYPE_STRING))) {
7596                                 MonoInst *iargs [3];
7597
7598                                 g_assert (!vtable_arg);
7599
7600                                 sp -= n;
7601
7602                                 EMIT_NEW_ICONST (cfg, iargs [0], cmethod->klass->type_token);
7603                                 switch (n) {
7604                                 case 0:
7605                                         *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_0, iargs);
7606                                         break;
7607                                 case 1:
7608                                         iargs [1] = sp [0];
7609                                         *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_1, iargs);
7610                                         break;
7611                                 case 2:
7612                                         iargs [1] = sp [0];
7613                                         iargs [2] = sp [1];
7614                                         *sp ++ = mono_emit_jit_icall (cfg, mono_create_corlib_exception_2, iargs);
7615                                         break;
7616                                 default:
7617                                         g_assert_not_reached ();
7618                                 }
7619
7620                                 ip += 5;
7621                                 inline_costs += 5;
7622                                 break;
7623                         }
7624
7625                         /* move the args to allow room for 'this' in the first position */
7626                         while (n--) {
7627                                 --sp;
7628                                 sp [1] = sp [0];
7629                         }
7630
7631                         /* check_call_signature () requires sp[0] to be set */
7632                         this_ins.type = STACK_OBJ;
7633                         sp [0] = &this_ins;
7634                         if (check_call_signature (cfg, fsig, sp))
7635                                 UNVERIFIED;
7636
7637                         iargs [0] = NULL;
7638
7639                         if (mini_class_is_system_array (cmethod->klass)) {
7640                                 g_assert (!vtable_arg);
7641
7642                                 *sp = emit_get_rgctx_method (cfg, context_used,
7643                                                                                          cmethod, MONO_RGCTX_INFO_METHOD);
7644
7645                                 /* Avoid varargs in the common case */
7646                                 if (fsig->param_count == 1)
7647                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_1, sp);
7648                                 else if (fsig->param_count == 2)
7649                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_2, sp);
7650                                 else if (fsig->param_count == 3)
7651                                         alloc = mono_emit_jit_icall (cfg, mono_array_new_3, sp);
7652                                 else
7653                                         alloc = handle_array_new (cfg, fsig->param_count, sp, ip);
7654                         } else if (cmethod->string_ctor) {
7655                                 g_assert (!context_used);
7656                                 g_assert (!vtable_arg);
7657                                 /* we simply pass a null pointer */
7658                                 EMIT_NEW_PCONST (cfg, *sp, NULL);
7659                                 /* now call the string ctor */
7660                                 alloc = mono_emit_method_call_full (cfg, cmethod, fsig, sp, NULL, NULL);
7661                         } else {
7662                                 MonoInst* callvirt_this_arg = NULL;
7663
7664                                 if (cmethod->klass->valuetype) {
7665                                         iargs [0] = mono_compile_create_var (cfg, &cmethod->klass->byval_arg, OP_LOCAL);
7666                                         MONO_EMIT_NEW_VZERO (cfg, iargs [0]->dreg, cmethod->klass);
7667                                         EMIT_NEW_TEMPLOADA (cfg, *sp, iargs [0]->inst_c0);
7668
7669                                         alloc = NULL;
7670
7671                                         /*
7672                                          * The code generated by mini_emit_virtual_call () expects
7673                                          * iargs [0] to be a boxed instance, but luckily the vcall
7674                                          * will be transformed into a normal call there.
7675                                          */
7676                                 } else if (context_used) {
7677                                         alloc = handle_alloc (cfg, cmethod->klass, FALSE, context_used);
7678                                         *sp = alloc;
7679                                 } else {
7680                                         MonoVTable *vtable = mono_class_vtable (cfg->domain, cmethod->klass);
7681
7682                                         CHECK_TYPELOAD (cmethod->klass);
7683
7684                                         /*
7685                                          * TypeInitializationExceptions thrown from the mono_runtime_class_init
7686                                          * call in mono_jit_runtime_invoke () can abort the finalizer thread.
7687                                          * As a workaround, we call class cctors before allocating objects.
7688                                          */
7689                                         if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
7690                                                 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
7691                                                 if (cfg->verbose_level > 2)
7692                                                         printf ("class %s.%s needs init call for ctor\n", cmethod->klass->name_space, cmethod->klass->name);
7693                                                 class_inits = g_slist_prepend (class_inits, vtable);
7694                                         }
7695
7696                                         alloc = handle_alloc (cfg, cmethod->klass, FALSE, 0);
7697                                         *sp = alloc;
7698                                 }
7699                                 CHECK_CFG_EXCEPTION; /*for handle_alloc*/
7700
7701                                 if (alloc)
7702                                         MONO_EMIT_NEW_UNALU (cfg, OP_NOT_NULL, -1, alloc->dreg);
7703
7704                                 /* Now call the actual ctor */
7705                                 /* Avoid virtual calls to ctors if possible */
7706                                 if (cmethod->klass->marshalbyref)
7707                                         callvirt_this_arg = sp [0];
7708
7709
7710                                 if (cmethod && (cfg->opt & MONO_OPT_INTRINS) && (ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp))) {
7711                                         if (!MONO_TYPE_IS_VOID (fsig->ret)) {
7712                                                 type_to_eval_stack_type ((cfg), fsig->ret, ins);
7713                                                 *sp = ins;
7714                                                 sp++;
7715                                         }
7716
7717                                         CHECK_CFG_EXCEPTION;
7718                                 } else
7719
7720
7721
7722                                 if ((cfg->opt & MONO_OPT_INLINE) && cmethod && !context_used && !vtable_arg &&
7723                                     mono_method_check_inlining (cfg, cmethod) &&
7724                                     !mono_class_is_subclass_of (cmethod->klass, mono_defaults.exception_class, FALSE) &&
7725                                     !g_list_find (dont_inline, cmethod)) {
7726                                         int costs;
7727
7728                                         if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, dont_inline, FALSE))) {
7729                                                 cfg->real_offset += 5;
7730                                                 bblock = cfg->cbb;
7731
7732                                                 inline_costs += costs - 5;
7733                                         } else {
7734                                                 INLINE_FAILURE;
7735                                                 mono_emit_method_call_full (cfg, cmethod, fsig, sp, callvirt_this_arg, NULL);
7736                                         }
7737                                 } else if (context_used &&
7738                                                 (!mono_method_is_generic_sharable_impl (cmethod, TRUE) ||
7739                                                         !mono_class_generic_sharing_enabled (cmethod->klass))) {
7740                                         MonoInst *cmethod_addr;
7741
7742                                         cmethod_addr = emit_get_rgctx_method (cfg, context_used,
7743                                                 cmethod, MONO_RGCTX_INFO_GENERIC_METHOD_CODE);
7744
7745                                         mono_emit_rgctx_calli (cfg, fsig, sp, cmethod_addr, vtable_arg);
7746                                 } else {
7747                                         INLINE_FAILURE;
7748                                         ins = mono_emit_rgctx_method_call_full (cfg, cmethod, fsig, sp,
7749                                                                                                                         callvirt_this_arg, NULL, vtable_arg);
7750                                 }
7751                         }
7752
7753                         if (alloc == NULL) {
7754                                 /* Valuetype */
7755                                 EMIT_NEW_TEMPLOAD (cfg, ins, iargs [0]->inst_c0);
7756                                 type_to_eval_stack_type (cfg, &ins->klass->byval_arg, ins);
7757                                 *sp++= ins;
7758                         }
7759                         else
7760                                 *sp++ = alloc;
7761
7762                         ip += 5;
7763                         inline_costs += 5;
7764                         break;
7765                 }
7766                 case CEE_CASTCLASS:
7767                         CHECK_STACK (1);
7768                         --sp;
7769                         CHECK_OPSIZE (5);
7770                         token = read32 (ip + 1);
7771                         klass = mini_get_class (method, token, generic_context);
7772                         CHECK_TYPELOAD (klass);
7773                         if (sp [0]->type != STACK_OBJ)
7774                                 UNVERIFIED;
7775
7776                         if (cfg->generic_sharing_context)
7777                                 context_used = mono_class_check_context_used (klass);
7778
7779                         if (!context_used && mono_class_has_variant_generic_params (klass)) {
7780                                 MonoInst *args [2];
7781
7782                                 /* obj */
7783                                 args [0] = *sp;
7784
7785                                 /* klass */
7786                                 EMIT_NEW_CLASSCONST (cfg, args [1], klass);
7787
7788                                 ins = mono_emit_jit_icall (cfg, mono_object_castclass, args);
7789                                 *sp ++ = ins;
7790                                 ip += 5;
7791                                 inline_costs += 2;
7792                         } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7793                                 MonoMethod *mono_castclass;
7794                                 MonoInst *iargs [1];
7795                                 int costs;
7796
7797                                 mono_castclass = mono_marshal_get_castclass (klass);
7798                                 iargs [0] = sp [0];
7799
7800                                 costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass),
7801                                                            iargs, ip, cfg->real_offset, dont_inline, TRUE);
7802                                 g_assert (costs > 0);
7803
7804                                 ip += 5;
7805                                 cfg->real_offset += 5;
7806                                 bblock = cfg->cbb;
7807
7808                                 *sp++ = iargs [0];
7809
7810                                 inline_costs += costs;
7811                         }
7812                         else {
7813                                 ins = handle_castclass (cfg, klass, *sp, context_used);
7814                                 CHECK_CFG_EXCEPTION;
7815                                 bblock = cfg->cbb;
7816                                 *sp ++ = ins;
7817                                 ip += 5;
7818                         }
7819                         break;
7820                 case CEE_ISINST: {
7821                         CHECK_STACK (1);
7822                         --sp;
7823                         CHECK_OPSIZE (5);
7824                         token = read32 (ip + 1);
7825                         klass = mini_get_class (method, token, generic_context);
7826                         CHECK_TYPELOAD (klass);
7827                         if (sp [0]->type != STACK_OBJ)
7828                                 UNVERIFIED;
7829
7830                         if (cfg->generic_sharing_context)
7831                                 context_used = mono_class_check_context_used (klass);
7832
7833                         if (!context_used && mono_class_has_variant_generic_params (klass)) {
7834                                 MonoInst *args [2];
7835
7836                                 /* obj */
7837                                 args [0] = *sp;
7838
7839                                 /* klass */
7840                                 EMIT_NEW_CLASSCONST (cfg, args [1], klass);
7841
7842                                 *sp = mono_emit_jit_icall (cfg, mono_object_isinst, args);
7843                                 sp++;
7844                                 ip += 5;
7845                                 inline_costs += 2;
7846                         } else if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7847                                 MonoMethod *mono_isinst;
7848                                 MonoInst *iargs [1];
7849                                 int costs;
7850
7851                                 mono_isinst = mono_marshal_get_isinst (klass);
7852                                 iargs [0] = sp [0];
7853
7854                                 costs = inline_method (cfg, mono_isinst, mono_method_signature (mono_isinst),
7855                                                            iargs, ip, cfg->real_offset, dont_inline, TRUE);
7856                                 g_assert (costs > 0);
7857
7858                                 ip += 5;
7859                                 cfg->real_offset += 5;
7860                                 bblock = cfg->cbb;
7861
7862                                 *sp++= iargs [0];
7863
7864                                 inline_costs += costs;
7865                         }
7866                         else {
7867                                 ins = handle_isinst (cfg, klass, *sp, context_used);
7868                                 CHECK_CFG_EXCEPTION;
7869                                 bblock = cfg->cbb;
7870                                 *sp ++ = ins;
7871                                 ip += 5;
7872                         }
7873                         break;
7874                 }
7875                 case CEE_UNBOX_ANY: {
7876                         CHECK_STACK (1);
7877                         --sp;
7878                         CHECK_OPSIZE (5);
7879                         token = read32 (ip + 1);
7880                         klass = mini_get_class (method, token, generic_context);
7881                         CHECK_TYPELOAD (klass);
7882
7883                         mono_save_token_info (cfg, image, token, klass);
7884
7885                         if (cfg->generic_sharing_context)
7886                                 context_used = mono_class_check_context_used (klass);
7887
7888                         if (generic_class_is_reference_type (cfg, klass)) {
7889                                 /* CASTCLASS FIXME kill this huge slice of duplicated code*/
7890                                 if (!context_used && (klass->marshalbyref || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
7891                                         MonoMethod *mono_castclass;
7892                                         MonoInst *iargs [1];
7893                                         int costs;
7894
7895                                         mono_castclass = mono_marshal_get_castclass (klass);
7896                                         iargs [0] = sp [0];
7897
7898                                         costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass),
7899                                                                                    iargs, ip, cfg->real_offset, dont_inline, TRUE);
7900
7901                                         g_assert (costs > 0);
7902
7903                                         ip += 5;
7904                                         cfg->real_offset += 5;
7905                                         bblock = cfg->cbb;
7906
7907                                         *sp++ = iargs [0];
7908                                         inline_costs += costs;
7909                                 } else {
7910                                         ins = handle_castclass (cfg, klass, *sp, context_used);
7911                                         CHECK_CFG_EXCEPTION;
7912                                         bblock = cfg->cbb;
7913                                         *sp ++ = ins;
7914                                         ip += 5;
7915                                 }
7916                                 break;
7917                         }
7918
7919                         if (mono_class_is_nullable (klass)) {
7920                                 ins = handle_unbox_nullable (cfg, *sp, klass, context_used);
7921                                 *sp++= ins;
7922                                 ip += 5;
7923                                 break;
7924                         }
7925
7926                         /* UNBOX */
7927                         ins = handle_unbox (cfg, klass, sp, context_used);
7928                         *sp = ins;
7929
7930                         ip += 5;
7931
7932                         /* LDOBJ */
7933                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0);
7934                         *sp++ = ins;
7935
7936                         inline_costs += 2;
7937                         break;
7938                 }
7939                 case CEE_BOX: {
7940                         MonoInst *val;
7941
7942                         CHECK_STACK (1);
7943                         --sp;
7944                         val = *sp;
7945                         CHECK_OPSIZE (5);
7946                         token = read32 (ip + 1);
7947                         klass = mini_get_class (method, token, generic_context);
7948                         CHECK_TYPELOAD (klass);
7949
7950                         mono_save_token_info (cfg, image, token, klass);
7951
7952                         if (cfg->generic_sharing_context)
7953                                 context_used = mono_class_check_context_used (klass);
7954
7955                         if (generic_class_is_reference_type (cfg, klass)) {
7956                                 *sp++ = val;
7957                                 ip += 5;
7958                                 break;
7959                         }
7960
7961                         if (klass == mono_defaults.void_class)
7962                                 UNVERIFIED;
7963                         if (target_type_is_incompatible (cfg, &klass->byval_arg, *sp))
7964                                 UNVERIFIED;
7965                         /* frequent check in generic code: box (struct), brtrue */
7966                         if (!mono_class_is_nullable (klass) &&
7967                                 ip + 5 < end && ip_in_bb (cfg, bblock, ip + 5) && (ip [5] == CEE_BRTRUE || ip [5] == CEE_BRTRUE_S)) {
7968                                 /*printf ("box-brtrue opt at 0x%04x in %s\n", real_offset, method->name);*/
7969                                 ip += 5;
7970                                 MONO_INST_NEW (cfg, ins, OP_BR);
7971                                 if (*ip == CEE_BRTRUE_S) {
7972                                         CHECK_OPSIZE (2);
7973                                         ip++;
7974                                         target = ip + 1 + (signed char)(*ip);
7975                                         ip++;
7976                                 } else {
7977                                         CHECK_OPSIZE (5);
7978                                         ip++;
7979                                         target = ip + 4 + (gint)(read32 (ip));
7980                                         ip += 4;
7981                                 }
7982                                 GET_BBLOCK (cfg, tblock, target);
7983                                 link_bblock (cfg, bblock, tblock);
7984                                 ins->inst_target_bb = tblock;
7985                                 GET_BBLOCK (cfg, tblock, ip);
7986                                 /*
7987                                  * This leads to some inconsistency, since the two bblocks are
7988                                  * not really connected, but it is needed for handling stack
7989                                  * arguments correctly (See test_0_box_brtrue_opt_regress_81102).
7990                                  * FIXME: This should only be needed if sp != stack_start, but that
7991                                  * doesn't work for some reason (test failure in mcs/tests on x86).
7992                                  */
7993                                 link_bblock (cfg, bblock, tblock);
7994                                 if (sp != stack_start) {
7995                                         handle_stack_args (cfg, stack_start, sp - stack_start);
7996                                         sp = stack_start;
7997                                         CHECK_UNVERIFIABLE (cfg);
7998                                 }
7999                                 MONO_ADD_INS (bblock, ins);
8000                                 start_new_bblock = 1;
8001                                 break;
8002                         }
8003
8004                         *sp++ = handle_box (cfg, val, klass, context_used);
8005
8006                         CHECK_CFG_EXCEPTION;
8007                         ip += 5;
8008                         inline_costs += 1;
8009                         break;
8010                 }
8011                 case CEE_UNBOX: {
8012                         CHECK_STACK (1);
8013                         --sp;
8014                         CHECK_OPSIZE (5);
8015                         token = read32 (ip + 1);
8016                         klass = mini_get_class (method, token, generic_context);
8017                         CHECK_TYPELOAD (klass);
8018
8019                         mono_save_token_info (cfg, image, token, klass);
8020
8021                         if (cfg->generic_sharing_context)
8022                                 context_used = mono_class_check_context_used (klass);
8023
8024                         if (mono_class_is_nullable (klass)) {
8025                                 MonoInst *val;
8026
8027                                 val = handle_unbox_nullable (cfg, *sp, klass, context_used);
8028                                 EMIT_NEW_VARLOADA (cfg, ins, get_vreg_to_inst (cfg, val->dreg), &val->klass->byval_arg);
8029
8030                                 *sp++= ins;
8031                         } else {
8032                                 ins = handle_unbox (cfg, klass, sp, context_used);
8033                                 *sp++ = ins;
8034                         }
8035                         ip += 5;
8036                         inline_costs += 2;
8037                         break;
8038                 }
8039                 case CEE_LDFLD:
8040                 case CEE_LDFLDA:
8041                 case CEE_STFLD: {
8042                         MonoClassField *field;
8043                         int costs;
8044                         guint foffset;
8045
8046                         if (*ip == CEE_STFLD) {
8047                                 CHECK_STACK (2);
8048                                 sp -= 2;
8049                         } else {
8050                                 CHECK_STACK (1);
8051                                 --sp;
8052                         }
8053                         if (sp [0]->type == STACK_I4 || sp [0]->type == STACK_I8 || sp [0]->type == STACK_R8)
8054                                 UNVERIFIED;
8055                         if (*ip != CEE_LDFLD && sp [0]->type == STACK_VTYPE)
8056                                 UNVERIFIED;
8057                         CHECK_OPSIZE (5);
8058                         token = read32 (ip + 1);
8059                         if (method->wrapper_type != MONO_WRAPPER_NONE) {
8060                                 field = mono_method_get_wrapper_data (method, token);
8061                                 klass = field->parent;
8062                         }
8063                         else {
8064                                 field = mono_field_from_token (image, token, &klass, generic_context);
8065                         }
8066                         if (!field)
8067                                 goto load_error;
8068                         if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_field (method, field))
8069                                 FIELD_ACCESS_FAILURE;
8070                         mono_class_init (klass);
8071
8072                         /* XXX this is technically required but, so far (SL2), no [SecurityCritical] types (not many exists) have
8073                            any visible *instance* field  (in fact there's a single case for a static field in Marshal) XXX
8074                         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
8075                                 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
8076                         */
8077
8078                         foffset = klass->valuetype? field->offset - sizeof (MonoObject): field->offset;
8079                         if (*ip == CEE_STFLD) {
8080                                 if (target_type_is_incompatible (cfg, field->type, sp [1]))
8081                                         UNVERIFIED;
8082                                 if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8083                                         MonoMethod *stfld_wrapper = mono_marshal_get_stfld_wrapper (field->type);
8084                                         MonoInst *iargs [5];
8085
8086                                         iargs [0] = sp [0];
8087                                         EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
8088                                         EMIT_NEW_FIELDCONST (cfg, iargs [2], field);
8089                                         EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) :
8090                                                     field->offset);
8091                                         iargs [4] = sp [1];
8092
8093                                         if (cfg->opt & MONO_OPT_INLINE || cfg->compile_aot) {
8094                                                 costs = inline_method (cfg, stfld_wrapper, mono_method_signature (stfld_wrapper),
8095                                                                        iargs, ip, cfg->real_offset, dont_inline, TRUE);
8096                                                 g_assert (costs > 0);
8097
8098                                                 cfg->real_offset += 5;
8099                                                 bblock = cfg->cbb;
8100
8101                                                 inline_costs += costs;
8102                                         } else {
8103                                                 mono_emit_method_call (cfg, stfld_wrapper, iargs, NULL);
8104                                         }
8105                                 } else {
8106                                         MonoInst *store;
8107
8108                                         MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg);
8109
8110                                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, field->type, sp [0]->dreg, foffset, sp [1]->dreg);
8111                                         if (sp [0]->opcode != OP_LDADDR)
8112                                                 store->flags |= MONO_INST_FAULT;
8113
8114                                 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)) {
8115                                         /* insert call to write barrier */
8116                                         MonoMethod *write_barrier = mono_gc_get_write_barrier ();
8117                                         MonoInst *iargs [2], *dummy_use;
8118                                         int dreg;
8119
8120                                         dreg = alloc_preg (cfg);
8121                                         EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, dreg, sp [0]->dreg, foffset);
8122                                         iargs [1] = sp [1];
8123                                         mono_emit_method_call (cfg, write_barrier, iargs, NULL);
8124
8125                                         EMIT_NEW_DUMMY_USE (cfg, dummy_use, sp [1]);
8126                                 }
8127
8128                                         store->flags |= ins_flag;
8129                                 }
8130                                 ins_flag = 0;
8131                                 ip += 5;
8132                                 break;
8133                         }
8134
8135                         if ((klass->marshalbyref && !MONO_CHECK_THIS (sp [0])) || klass->contextbound || klass == mono_defaults.marshalbyrefobject_class) {
8136                                 MonoMethod *wrapper = (*ip == CEE_LDFLDA) ? mono_marshal_get_ldflda_wrapper (field->type) : mono_marshal_get_ldfld_wrapper (field->type);
8137                                 MonoInst *iargs [4];
8138
8139                                 iargs [0] = sp [0];
8140                                 EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
8141                                 EMIT_NEW_FIELDCONST (cfg, iargs [2], field);
8142                                 EMIT_NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset);
8143                                 if (cfg->opt & MONO_OPT_INLINE || cfg->compile_aot) {
8144                                         costs = inline_method (cfg, wrapper, mono_method_signature (wrapper),
8145                                                                                    iargs, ip, cfg->real_offset, dont_inline, TRUE);
8146                                         bblock = cfg->cbb;
8147                                         g_assert (costs > 0);
8148
8149                                         cfg->real_offset += 5;
8150
8151                                         *sp++ = iargs [0];
8152
8153                                         inline_costs += costs;
8154                                 } else {
8155                                         ins = mono_emit_method_call (cfg, wrapper, iargs, NULL);
8156                                         *sp++ = ins;
8157                                 }
8158                         } else {
8159                                 if (sp [0]->type == STACK_VTYPE) {
8160                                         MonoInst *var;
8161
8162                                         /* Have to compute the address of the variable */
8163
8164                                         var = get_vreg_to_inst (cfg, sp [0]->dreg);
8165                                         if (!var)
8166                                                 var = mono_compile_create_var_for_vreg (cfg, &klass->byval_arg, OP_LOCAL, sp [0]->dreg);
8167                                         else
8168                                                 g_assert (var->klass == klass);
8169
8170                                         EMIT_NEW_VARLOADA (cfg, ins, var, &var->klass->byval_arg);
8171                                         sp [0] = ins;
8172                                 }
8173
8174                                 MONO_EMIT_NULL_CHECK (cfg, sp [0]->dreg);
8175
8176                                 if (*ip == CEE_LDFLDA) {
8177                                         dreg = alloc_preg (cfg);
8178
8179                                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, dreg, sp [0]->dreg, foffset);
8180                                         ins->klass = mono_class_from_mono_type (field->type);
8181                                         ins->type = STACK_MP;
8182                                         *sp++ = ins;
8183                                 } else {
8184                                         MonoInst *load;
8185
8186                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, sp [0]->dreg, foffset);
8187                                         load->flags |= ins_flag;
8188                                         if (sp [0]->opcode != OP_LDADDR)
8189                                                 load->flags |= MONO_INST_FAULT;
8190                                         *sp++ = load;
8191                                 }
8192                         }
8193                         ins_flag = 0;
8194                         ip += 5;
8195                         break;
8196                 }
8197                 case CEE_LDSFLD:
8198                 case CEE_LDSFLDA:
8199                 case CEE_STSFLD: {
8200                         MonoClassField *field;
8201                         gpointer addr = NULL;
8202                         gboolean is_special_static;
8203
8204                         CHECK_OPSIZE (5);
8205                         token = read32 (ip + 1);
8206
8207                         if (method->wrapper_type != MONO_WRAPPER_NONE) {
8208                                 field = mono_method_get_wrapper_data (method, token);
8209                                 klass = field->parent;
8210                         }
8211                         else
8212                                 field = mono_field_from_token (image, token, &klass, generic_context);
8213                         if (!field)
8214                                 goto load_error;
8215                         mono_class_init (klass);
8216                         if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_field (method, field))
8217                                 FIELD_ACCESS_FAILURE;
8218
8219                         /* if the class is Critical then transparent code cannot access it's fields */
8220                         if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
8221                                 ensure_method_is_allowed_to_access_field (cfg, method, field, bblock, ip);
8222
8223                         /*
8224                          * We can only support shared generic static
8225                          * field access on architectures where the
8226                          * trampoline code has been extended to handle
8227                          * the generic class init.
8228                          */
8229 #ifndef MONO_ARCH_VTABLE_REG
8230                         GENERIC_SHARING_FAILURE (*ip);
8231 #endif
8232
8233                         if (cfg->generic_sharing_context)
8234                                 context_used = mono_class_check_context_used (klass);
8235
8236                         g_assert (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL));
8237
8238                         /* The special_static_fields field is init'd in mono_class_vtable, so it needs
8239                          * to be called here.
8240                          */
8241                         if (!context_used && !(cfg->opt & MONO_OPT_SHARED)) {
8242                                 mono_class_vtable (cfg->domain, klass);
8243                                 CHECK_TYPELOAD (klass);
8244                         }
8245                         mono_domain_lock (cfg->domain);
8246                         if (cfg->domain->special_static_fields)
8247                                 addr = g_hash_table_lookup (cfg->domain->special_static_fields, field);
8248                         mono_domain_unlock (cfg->domain);
8249
8250                         is_special_static = mono_class_field_is_special_static (field);
8251
8252                         /* Generate IR to compute the field address */
8253                         if (is_special_static && ((gsize)addr & 0x80000000) == 0 && mono_get_thread_intrinsic (cfg) && !(cfg->opt & MONO_OPT_SHARED) && !context_used) {
8254                                 /*
8255                                  * Fast access to TLS data
8256                                  * Inline version of get_thread_static_data () in
8257                                  * threads.c.
8258                                  */
8259                                 guint32 offset;
8260                                 int idx, static_data_reg, array_reg, dreg;
8261                                 MonoInst *thread_ins;
8262
8263                                 // offset &= 0x7fffffff;
8264                                 // idx = (offset >> 24) - 1;
8265                                 //      return ((char*) thread->static_data [idx]) + (offset & 0xffffff);
8266
8267                                 thread_ins = mono_get_thread_intrinsic (cfg);
8268                                 MONO_ADD_INS (cfg->cbb, thread_ins);
8269                                 static_data_reg = alloc_ireg (cfg);
8270                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, static_data_reg, thread_ins->dreg, G_STRUCT_OFFSET (MonoInternalThread, static_data));
8271
8272                                 if (cfg->compile_aot) {
8273                                         int offset_reg, offset2_reg, idx_reg;
8274
8275                                         /* For TLS variables, this will return the TLS offset */
8276                                         EMIT_NEW_SFLDACONST (cfg, ins, field);
8277                                         offset_reg = ins->dreg;
8278                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, offset_reg, offset_reg, 0x7fffffff);
8279                                         idx_reg = alloc_ireg (cfg);
8280                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHR_IMM, idx_reg, offset_reg, 24);
8281                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISUB_IMM, idx_reg, idx_reg, 1);
8282                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHL_IMM, idx_reg, idx_reg, sizeof (gpointer) == 8 ? 3 : 2);
8283                                         MONO_EMIT_NEW_BIALU (cfg, OP_PADD, static_data_reg, static_data_reg, idx_reg);
8284                                         array_reg = alloc_ireg (cfg);
8285                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, static_data_reg, 0);
8286                                         offset2_reg = alloc_ireg (cfg);
8287                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IAND_IMM, offset2_reg, offset_reg, 0xffffff);
8288                                         dreg = alloc_ireg (cfg);
8289                                         EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, array_reg, offset2_reg);
8290                                 } else {
8291                                         offset = (gsize)addr & 0x7fffffff;
8292                                         idx = (offset >> 24) - 1;
8293
8294                                         array_reg = alloc_ireg (cfg);
8295                                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, array_reg, static_data_reg, idx * sizeof (gpointer));
8296                                         dreg = alloc_ireg (cfg);
8297                                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_ADD_IMM, dreg, array_reg, (offset & 0xffffff));
8298                                 }
8299                         } else if ((cfg->opt & MONO_OPT_SHARED) ||
8300                                         (cfg->compile_aot && is_special_static) ||
8301                                         (context_used && is_special_static)) {
8302                                 MonoInst *iargs [2];
8303
8304                                 g_assert (field->parent);
8305                                 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
8306                                 if (context_used) {
8307                                         iargs [1] = emit_get_rgctx_field (cfg, context_used,
8308                                                 field, MONO_RGCTX_INFO_CLASS_FIELD);
8309                                 } else {
8310                                         EMIT_NEW_FIELDCONST (cfg, iargs [1], field);
8311                                 }
8312                                 ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, iargs);
8313                         } else if (context_used) {
8314                                 MonoInst *static_data;
8315
8316                                 /*
8317                                 g_print ("sharing static field access in %s.%s.%s - depth %d offset %d\n",
8318                                         method->klass->name_space, method->klass->name, method->name,
8319                                         depth, field->offset);
8320                                 */
8321
8322                                 if (mono_class_needs_cctor_run (klass, method))
8323                                         emit_generic_class_init (cfg, klass);
8324
8325                                 /*
8326                                  * The pointer we're computing here is
8327                                  *
8328                                  *   super_info.static_data + field->offset
8329                                  */
8330                                 static_data = emit_get_rgctx_klass (cfg, context_used,
8331                                         klass, MONO_RGCTX_INFO_STATIC_DATA);
8332
8333                                 if (field->offset == 0) {
8334                                         ins = static_data;
8335                                 } else {
8336                                         int addr_reg = mono_alloc_preg (cfg);
8337                                         EMIT_NEW_BIALU_IMM (cfg, ins, OP_PADD_IMM, addr_reg, static_data->dreg, field->offset);
8338                                 }
8339                                 } else if ((cfg->opt & MONO_OPT_SHARED) || (cfg->compile_aot && addr)) {
8340                                 MonoInst *iargs [2];
8341
8342                                 g_assert (field->parent);
8343                                 EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
8344                                 EMIT_NEW_FIELDCONST (cfg, iargs [1], field);
8345                                 ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, iargs);
8346                         } else {
8347                                 MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
8348
8349                                 CHECK_TYPELOAD (klass);
8350                                 if (!addr) {
8351                                         if (mini_field_access_needs_cctor_run (cfg, method, vtable) && !(g_slist_find (class_inits, vtable))) {
8352                                                 mono_emit_abs_call (cfg, MONO_PATCH_INFO_CLASS_INIT, vtable->klass, helper_sig_class_init_trampoline, NULL);
8353                                                 if (cfg->verbose_level > 2)
8354                                                         printf ("class %s.%s needs init call for %s\n", klass->name_space, klass->name, mono_field_get_name (field));
8355                                                 class_inits = g_slist_prepend (class_inits, vtable);
8356                                         } else {
8357                                                 if (cfg->run_cctors) {
8358                                                         MonoException *ex;
8359                                                         /* This makes so that inline cannot trigger */
8360                                                         /* .cctors: too many apps depend on them */
8361                                                         /* running with a specific order... */
8362                                                         if (! vtable->initialized)
8363                                                                 INLINE_FAILURE;
8364                                                         ex = mono_runtime_class_init_full (vtable, FALSE);
8365                                                         if (ex) {
8366                                                                 set_exception_object (cfg, ex);
8367                                                                 goto exception_exit;
8368                                                         }
8369                                                 }
8370                                         }
8371                                         addr = (char*)vtable->data + field->offset;
8372
8373                                         if (cfg->compile_aot)
8374                                                 EMIT_NEW_SFLDACONST (cfg, ins, field);
8375                                         else
8376                                                 EMIT_NEW_PCONST (cfg, ins, addr);
8377                                 } else {
8378                                         MonoInst *iargs [1];
8379                                         EMIT_NEW_ICONST (cfg, iargs [0], GPOINTER_TO_UINT (addr));
8380                                         ins = mono_emit_jit_icall (cfg, mono_get_special_static_data, iargs);
8381                                 }
8382                         }
8383
8384                         /* Generate IR to do the actual load/store operation */
8385
8386                         if (*ip == CEE_LDSFLDA) {
8387                                 ins->klass = mono_class_from_mono_type (field->type);
8388                                 ins->type = STACK_PTR;
8389                                 *sp++ = ins;
8390                         } else if (*ip == CEE_STSFLD) {
8391                                 MonoInst *store;
8392                                 CHECK_STACK (1);
8393                                 sp--;
8394
8395                                 EMIT_NEW_STORE_MEMBASE_TYPE (cfg, store, field->type, ins->dreg, 0, sp [0]->dreg);
8396                                 store->flags |= ins_flag;
8397                         } else {
8398                                 gboolean is_const = FALSE;
8399                                 MonoVTable *vtable = NULL;
8400
8401                                 if (!context_used) {
8402                                         vtable = mono_class_vtable (cfg->domain, klass);
8403                                         CHECK_TYPELOAD (klass);
8404                                 }
8405                                 if (!context_used && !((cfg->opt & MONO_OPT_SHARED) || cfg->compile_aot) &&
8406                                     vtable->initialized && (field->type->attrs & FIELD_ATTRIBUTE_INIT_ONLY)) {
8407                                         gpointer addr = (char*)vtable->data + field->offset;
8408                                         int ro_type = field->type->type;
8409                                         if (ro_type == MONO_TYPE_VALUETYPE && field->type->data.klass->enumtype) {
8410                                                 ro_type = mono_class_enum_basetype (field->type->data.klass)->type;
8411                                         }
8412                                         /* printf ("RO-FIELD %s.%s:%s\n", klass->name_space, klass->name, mono_field_get_name (field));*/
8413                                         is_const = TRUE;
8414                                         switch (ro_type) {
8415                                         case MONO_TYPE_BOOLEAN:
8416                                         case MONO_TYPE_U1:
8417                                                 EMIT_NEW_ICONST (cfg, *sp, *((guint8 *)addr));
8418                                                 sp++;
8419                                                 break;
8420                                         case MONO_TYPE_I1:
8421                                                 EMIT_NEW_ICONST (cfg, *sp, *((gint8 *)addr));
8422                                                 sp++;
8423                                                 break;
8424                                         case MONO_TYPE_CHAR:
8425                                         case MONO_TYPE_U2:
8426                                                 EMIT_NEW_ICONST (cfg, *sp, *((guint16 *)addr));
8427                                                 sp++;
8428                                                 break;
8429                                         case MONO_TYPE_I2:
8430                                                 EMIT_NEW_ICONST (cfg, *sp, *((gint16 *)addr));
8431                                                 sp++;
8432                                                 break;
8433                                                 break;
8434                                         case MONO_TYPE_I4:
8435                                                 EMIT_NEW_ICONST (cfg, *sp, *((gint32 *)addr));
8436                                                 sp++;
8437                                                 break;
8438                                         case MONO_TYPE_U4:
8439                                                 EMIT_NEW_ICONST (cfg, *sp, *((guint32 *)addr));
8440                                                 sp++;
8441                                                 break;
8442                                         case MONO_TYPE_I:
8443                                         case MONO_TYPE_U:
8444                                         case MONO_TYPE_PTR:
8445                                         case MONO_TYPE_FNPTR:
8446 #ifndef HAVE_MOVING_COLLECTOR
8447                                         case MONO_TYPE_STRING:
8448                                         case MONO_TYPE_OBJECT:
8449                                         case MONO_TYPE_CLASS:
8450                                         case MONO_TYPE_SZARRAY:
8451                                         case MONO_TYPE_ARRAY:
8452 #endif
8453                                                 EMIT_NEW_PCONST (cfg, *sp, *((gpointer *)addr));
8454                                                 type_to_eval_stack_type ((cfg), field->type, *sp);
8455                                                 sp++;
8456                                                 break;
8457                                         case MONO_TYPE_I8:
8458                                         case MONO_TYPE_U8:
8459                                                 EMIT_NEW_I8CONST (cfg, *sp, *((gint64 *)addr));
8460                                                 sp++;
8461                                                 break;
8462                                         case MONO_TYPE_R4:
8463                                         case MONO_TYPE_R8:
8464                                         case MONO_TYPE_VALUETYPE:
8465                                         default:
8466                                                 is_const = FALSE;
8467                                                 break;
8468                                         }
8469                                 }
8470
8471                                 if (!is_const) {
8472                                         MonoInst *load;
8473
8474                                         CHECK_STACK_OVF (1);
8475
8476                                         EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, ins->dreg, 0);
8477                                         load->flags |= ins_flag;
8478                                         ins_flag = 0;
8479                                         *sp++ = load;
8480                                 }
8481                         }
8482                         ins_flag = 0;
8483                         ip += 5;
8484                         break;
8485                 }
8486                 case CEE_STOBJ:
8487                         CHECK_STACK (2);
8488                         sp -= 2;
8489                         CHECK_OPSIZE (5);
8490                         token = read32 (ip + 1);
8491                         klass = mini_get_class (method, token, generic_context);
8492                         CHECK_TYPELOAD (klass);
8493                         /* FIXME: should check item at sp [1] is compatible with the type of the store. */
8494                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0, sp [1]->dreg);
8495                         if (cfg->gen_write_barriers && cfg->method->wrapper_type != MONO_WRAPPER_WRITE_BARRIER &&
8496                                         generic_class_is_reference_type (cfg, klass)) {
8497                                 MonoInst *dummy_use;
8498                                 /* insert call to write barrier */
8499                                 MonoMethod *write_barrier = mono_gc_get_write_barrier ();
8500                                 mono_emit_method_call (cfg, write_barrier, sp, NULL);
8501                                 EMIT_NEW_DUMMY_USE (cfg, dummy_use, sp [1]);
8502                         }
8503                         ins_flag = 0;
8504                         ip += 5;
8505                         inline_costs += 1;
8506                         break;
8507
8508                         /*
8509                          * Array opcodes
8510                          */
8511                 case CEE_NEWARR: {
8512                         MonoInst *len_ins;
8513                         const char *data_ptr;
8514                         int data_size = 0;
8515                         guint32 field_token;
8516
8517                         CHECK_STACK (1);
8518                         --sp;
8519
8520                         CHECK_OPSIZE (5);
8521                         token = read32 (ip + 1);
8522
8523                         klass = mini_get_class (method, token, generic_context);
8524                         CHECK_TYPELOAD (klass);
8525
8526                         if (cfg->generic_sharing_context)
8527                                 context_used = mono_class_check_context_used (klass);
8528
8529                         if (sp [0]->type == STACK_I8 || (SIZEOF_VOID_P == 8 && sp [0]->type == STACK_PTR)) {
8530                                 MONO_INST_NEW (cfg, ins, OP_LCONV_TO_I4);
8531                                 ins->sreg1 = sp [0]->dreg;
8532                                 ins->type = STACK_I4;
8533                                 ins->dreg = alloc_ireg (cfg);
8534                                 MONO_ADD_INS (cfg->cbb, ins);
8535                                 *sp = mono_decompose_opcode (cfg, ins);
8536                         }
8537
8538                         if (context_used) {
8539                                 MonoInst *args [3];
8540                                 MonoClass *array_class = mono_array_class_get (klass, 1);
8541                                 /* FIXME: we cannot get a managed
8542                                    allocator because we can't get the
8543                                    open generic class's vtable.  We
8544                                    have the same problem in
8545                                    handle_alloc().  This
8546                                    needs to be solved so that we can
8547                                    have managed allocs of shared
8548                                    generic classes. */
8549                                 /*
8550                                 MonoVTable *array_class_vtable = mono_class_vtable (cfg->domain, array_class);
8551                                 MonoMethod *managed_alloc = mono_gc_get_managed_array_allocator (array_class_vtable, 1);
8552                                 */
8553                                 MonoMethod *managed_alloc = NULL;
8554
8555                                 /* FIXME: Decompose later to help abcrem */
8556
8557                                 /* vtable */
8558                                 args [0] = emit_get_rgctx_klass (cfg, context_used,
8559                                         array_class, MONO_RGCTX_INFO_VTABLE);
8560                                 /* array len */
8561                                 args [1] = sp [0];
8562
8563                                 if (managed_alloc)
8564                                         ins = mono_emit_method_call (cfg, managed_alloc, args, NULL);
8565                                 else
8566                                         ins = mono_emit_jit_icall (cfg, mono_array_new_specific, args);
8567                         } else {
8568                                 if (cfg->opt & MONO_OPT_SHARED) {
8569                                         /* Decompose now to avoid problems with references to the domainvar */
8570                                         MonoInst *iargs [3];
8571
8572                                         EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
8573                                         EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
8574                                         iargs [2] = sp [0];
8575
8576                                         ins = mono_emit_jit_icall (cfg, mono_array_new, iargs);
8577                                 } else {
8578                                         /* Decompose later since it is needed by abcrem */
8579                                         MonoClass *array_type = mono_array_class_get (klass, 1);
8580                                         mono_class_vtable (cfg->domain, array_type);
8581                                         CHECK_TYPELOAD (array_type);
8582
8583                                         MONO_INST_NEW (cfg, ins, OP_NEWARR);
8584                                         ins->dreg = alloc_preg (cfg);
8585                                         ins->sreg1 = sp [0]->dreg;
8586                                         ins->inst_newa_class = klass;
8587                                         ins->type = STACK_OBJ;
8588                                         ins->klass = klass;
8589                                         MONO_ADD_INS (cfg->cbb, ins);
8590                                         cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
8591                                         cfg->cbb->has_array_access = TRUE;
8592
8593                                         /* Needed so mono_emit_load_get_addr () gets called */
8594                                         mono_get_got_var (cfg);
8595                                 }
8596                         }
8597
8598                         len_ins = sp [0];
8599                         ip += 5;
8600                         *sp++ = ins;
8601                         inline_costs += 1;
8602
8603                         /*
8604                          * we inline/optimize the initialization sequence if possible.
8605                          * we should also allocate the array as not cleared, since we spend as much time clearing to 0 as initializing
8606                          * for small sizes open code the memcpy
8607                          * ensure the rva field is big enough
8608                          */
8609                         if ((cfg->opt & MONO_OPT_INTRINS) && ip + 6 < end && ip_in_bb (cfg, bblock, 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))) {
8610                                 MonoMethod *memcpy_method = get_memcpy_method ();
8611                                 MonoInst *iargs [3];
8612                                 int add_reg = alloc_preg (cfg);
8613
8614                                 EMIT_NEW_BIALU_IMM (cfg, iargs [0], OP_PADD_IMM, add_reg, ins->dreg, G_STRUCT_OFFSET (MonoArray, vector));
8615                                 if (cfg->compile_aot) {
8616                                         EMIT_NEW_AOTCONST_TOKEN (cfg, iargs [1], MONO_PATCH_INFO_RVA, method->klass->image, GPOINTER_TO_UINT(field_token), STACK_PTR, NULL);
8617                                 } else {
8618                                         EMIT_NEW_PCONST (cfg, iargs [1], (char*)data_ptr);
8619                                 }
8620                                 EMIT_NEW_ICONST (cfg, iargs [2], data_size);
8621                                 mono_emit_method_call (cfg, memcpy_method, iargs, NULL);
8622                                 ip += 11;
8623                         }
8624
8625                         break;
8626                 }
8627                 case CEE_LDLEN:
8628                         CHECK_STACK (1);
8629                         --sp;
8630                         if (sp [0]->type != STACK_OBJ)
8631                                 UNVERIFIED;
8632
8633                         dreg = alloc_preg (cfg);
8634                         MONO_INST_NEW (cfg, ins, OP_LDLEN);
8635                         ins->dreg = alloc_preg (cfg);
8636                         ins->sreg1 = sp [0]->dreg;
8637                         ins->type = STACK_I4;
8638                         /* This flag will be inherited by the decomposition */
8639                         ins->flags |= MONO_INST_FAULT;
8640                         MONO_ADD_INS (cfg->cbb, ins);
8641                         cfg->flags |= MONO_CFG_HAS_ARRAY_ACCESS;
8642                         cfg->cbb->has_array_access = TRUE;
8643                         ip ++;
8644                         *sp++ = ins;
8645                         break;
8646                 case CEE_LDELEMA:
8647                         CHECK_STACK (2);
8648                         sp -= 2;
8649                         CHECK_OPSIZE (5);
8650                         if (sp [0]->type != STACK_OBJ)
8651                                 UNVERIFIED;
8652
8653                         cfg->flags |= MONO_CFG_HAS_LDELEMA;
8654
8655                         klass = mini_get_class (method, read32 (ip + 1), generic_context);
8656                         CHECK_TYPELOAD (klass);
8657                         /* we need to make sure that this array is exactly the type it needs
8658                          * to be for correctness. the wrappers are lax with their usage
8659                          * so we need to ignore them here
8660                          */
8661                         if (!klass->valuetype && method->wrapper_type == MONO_WRAPPER_NONE && !readonly) {
8662                                 MonoClass *array_class = mono_array_class_get (klass, 1);
8663                                 mini_emit_check_array_type (cfg, sp [0], array_class);
8664                                 CHECK_TYPELOAD (array_class);
8665                         }
8666
8667                         readonly = FALSE;
8668                         ins = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
8669                         *sp++ = ins;
8670                         ip += 5;
8671                         break;
8672                 case CEE_LDELEM:
8673                 case CEE_LDELEM_I1:
8674                 case CEE_LDELEM_U1:
8675                 case CEE_LDELEM_I2:
8676                 case CEE_LDELEM_U2:
8677                 case CEE_LDELEM_I4:
8678                 case CEE_LDELEM_U4:
8679                 case CEE_LDELEM_I8:
8680                 case CEE_LDELEM_I:
8681                 case CEE_LDELEM_R4:
8682                 case CEE_LDELEM_R8:
8683                 case CEE_LDELEM_REF: {
8684                         MonoInst *addr;
8685
8686                         CHECK_STACK (2);
8687                         sp -= 2;
8688
8689                         if (*ip == CEE_LDELEM) {
8690                                 CHECK_OPSIZE (5);
8691                                 token = read32 (ip + 1);
8692                                 klass = mini_get_class (method, token, generic_context);
8693                                 CHECK_TYPELOAD (klass);
8694                                 mono_class_init (klass);
8695                         }
8696                         else
8697                                 klass = array_access_to_klass (*ip);
8698
8699                         if (sp [0]->type != STACK_OBJ)
8700                                 UNVERIFIED;
8701
8702                         cfg->flags |= MONO_CFG_HAS_LDELEMA;
8703
8704                         if (sp [1]->opcode == OP_ICONST) {
8705                                 int array_reg = sp [0]->dreg;
8706                                 int index_reg = sp [1]->dreg;
8707                                 int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8708
8709                                 MONO_EMIT_BOUNDS_CHECK (cfg, array_reg, MonoArray, max_length, index_reg);
8710                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, array_reg, offset);
8711                         } else {
8712                                 addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
8713                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0);
8714                         }
8715                         *sp++ = ins;
8716                         if (*ip == CEE_LDELEM)
8717                                 ip += 5;
8718                         else
8719                                 ++ip;
8720                         break;
8721                 }
8722                 case CEE_STELEM_I:
8723                 case CEE_STELEM_I1:
8724                 case CEE_STELEM_I2:
8725                 case CEE_STELEM_I4:
8726                 case CEE_STELEM_I8:
8727                 case CEE_STELEM_R4:
8728                 case CEE_STELEM_R8:
8729                 case CEE_STELEM_REF:
8730                 case CEE_STELEM: {
8731                         MonoInst *addr;
8732
8733                         CHECK_STACK (3);
8734                         sp -= 3;
8735
8736                         cfg->flags |= MONO_CFG_HAS_LDELEMA;
8737
8738                         if (*ip == CEE_STELEM) {
8739                                 CHECK_OPSIZE (5);
8740                                 token = read32 (ip + 1);
8741                                 klass = mini_get_class (method, token, generic_context);
8742                                 CHECK_TYPELOAD (klass);
8743                                 mono_class_init (klass);
8744                         }
8745                         else
8746                                 klass = array_access_to_klass (*ip);
8747
8748                         if (sp [0]->type != STACK_OBJ)
8749                                 UNVERIFIED;
8750
8751                         /* storing a NULL doesn't need any of the complex checks in stelemref */
8752                         if (generic_class_is_reference_type (cfg, klass) &&
8753                                 !(sp [2]->opcode == OP_PCONST && sp [2]->inst_p0 == NULL)) {
8754                                 MonoMethod* helper = mono_marshal_get_stelemref ();
8755                                 MonoInst *iargs [3];
8756
8757                                 if (sp [0]->type != STACK_OBJ)
8758                                         UNVERIFIED;
8759                                 if (sp [2]->type != STACK_OBJ)
8760                                         UNVERIFIED;
8761
8762                                 iargs [2] = sp [2];
8763                                 iargs [1] = sp [1];
8764                                 iargs [0] = sp [0];
8765
8766                                 mono_emit_method_call (cfg, helper, iargs, NULL);
8767                         } else {
8768                                 if (sp [1]->opcode == OP_ICONST) {
8769                                         int array_reg = sp [0]->dreg;
8770                                         int index_reg = sp [1]->dreg;
8771                                         int offset = (mono_class_array_element_size (klass) * sp [1]->inst_c0) + G_STRUCT_OFFSET (MonoArray, vector);
8772
8773                                         MONO_EMIT_BOUNDS_CHECK (cfg, array_reg, MonoArray, max_length, index_reg);
8774                                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, array_reg, offset, sp [2]->dreg);
8775                                 } else {
8776                                         addr = mini_emit_ldelema_1_ins (cfg, klass, sp [0], sp [1], TRUE);
8777                                         EMIT_NEW_STORE_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, addr->dreg, 0, sp [2]->dreg);
8778                                 }
8779                         }
8780
8781                         if (*ip == CEE_STELEM)
8782                                 ip += 5;
8783                         else
8784                                 ++ip;
8785                         inline_costs += 1;
8786                         break;
8787                 }
8788                 case CEE_CKFINITE: {
8789                         CHECK_STACK (1);
8790                         --sp;
8791
8792                         MONO_INST_NEW (cfg, ins, OP_CKFINITE);
8793                         ins->sreg1 = sp [0]->dreg;
8794                         ins->dreg = alloc_freg (cfg);
8795                         ins->type = STACK_R8;
8796                         MONO_ADD_INS (bblock, ins);
8797
8798                         *sp++ = mono_decompose_opcode (cfg, ins);
8799
8800                         ++ip;
8801                         break;
8802                 }
8803                 case CEE_REFANYVAL: {
8804                         MonoInst *src_var, *src;
8805
8806                         int klass_reg = alloc_preg (cfg);
8807                         int dreg = alloc_preg (cfg);
8808
8809                         CHECK_STACK (1);
8810                         MONO_INST_NEW (cfg, ins, *ip);
8811                         --sp;
8812                         CHECK_OPSIZE (5);
8813                         klass = mono_class_get_full (image, read32 (ip + 1), generic_context);
8814                         CHECK_TYPELOAD (klass);
8815                         mono_class_init (klass);
8816
8817                         if (cfg->generic_sharing_context)
8818                                 context_used = mono_class_check_context_used (klass);
8819
8820                         // FIXME:
8821                         src_var = get_vreg_to_inst (cfg, sp [0]->dreg);
8822                         if (!src_var)
8823                                 src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
8824                         EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype);
8825                         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass));
8826
8827                         if (context_used) {
8828                                 MonoInst *klass_ins;
8829
8830                                 klass_ins = emit_get_rgctx_klass (cfg, context_used,
8831                                                 klass, MONO_RGCTX_INFO_KLASS);
8832
8833                                 // FIXME:
8834                                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, klass_reg, klass_ins->dreg);
8835                                 MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException");
8836                         } else {
8837                                 mini_emit_class_check (cfg, klass_reg, klass);
8838                         }
8839                         EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, dreg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, value));
8840                         ins->type = STACK_MP;
8841                         *sp++ = ins;
8842                         ip += 5;
8843                         break;
8844                 }
8845                 case CEE_MKREFANY: {
8846                         MonoInst *loc, *addr;
8847
8848                         CHECK_STACK (1);
8849                         MONO_INST_NEW (cfg, ins, *ip);
8850                         --sp;
8851                         CHECK_OPSIZE (5);
8852                         klass = mono_class_get_full (image, read32 (ip + 1), generic_context);
8853                         CHECK_TYPELOAD (klass);
8854                         mono_class_init (klass);
8855
8856                         if (cfg->generic_sharing_context)
8857                                 context_used = mono_class_check_context_used (klass);
8858
8859                         loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
8860                         EMIT_NEW_TEMPLOADA (cfg, addr, loc->inst_c0);
8861
8862                         if (context_used) {
8863                                 MonoInst *const_ins;
8864                                 int type_reg = alloc_preg (cfg);
8865
8866                                 const_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
8867                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_ins->dreg);
8868                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_ins->dreg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8869                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8870                         } else if (cfg->compile_aot) {
8871                                 int const_reg = alloc_preg (cfg);
8872                                 int type_reg = alloc_preg (cfg);
8873
8874                                 MONO_EMIT_NEW_CLASSCONST (cfg, const_reg, klass);
8875                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
8876                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
8877                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
8878                         } else {
8879                                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
8880                                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STOREP_MEMBASE_IMM, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
8881                         }
8882                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREP_MEMBASE_REG, addr->dreg, G_STRUCT_OFFSET (MonoTypedRef, value), sp [0]->dreg);
8883
8884                         EMIT_NEW_TEMPLOAD (cfg, ins, loc->inst_c0);
8885                         ins->type = STACK_VTYPE;
8886                         ins->klass = mono_defaults.typed_reference_class;
8887                         *sp++ = ins;
8888                         ip += 5;
8889                         break;
8890                 }
8891                 case CEE_LDTOKEN: {
8892                         gpointer handle;
8893                         MonoClass *handle_class;
8894
8895                         CHECK_STACK_OVF (1);
8896
8897                         CHECK_OPSIZE (5);
8898                         n = read32 (ip + 1);
8899
8900                         if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD ||
8901                                         method->wrapper_type == MONO_WRAPPER_SYNCHRONIZED) {
8902                                 handle = mono_method_get_wrapper_data (method, n);
8903                                 handle_class = mono_method_get_wrapper_data (method, n + 1);
8904                                 if (handle_class == mono_defaults.typehandle_class)
8905                                         handle = &((MonoClass*)handle)->byval_arg;
8906                         }
8907                         else {
8908                                 handle = mono_ldtoken (image, n, &handle_class, generic_context);
8909                         }
8910                         if (!handle)
8911                                 goto load_error;
8912                         mono_class_init (handle_class);
8913                         if (cfg->generic_sharing_context) {
8914                                 if (mono_metadata_token_table (n) == MONO_TABLE_TYPEDEF ||
8915                                                 mono_metadata_token_table (n) == MONO_TABLE_TYPEREF) {
8916                                         /* This case handles ldtoken
8917                                            of an open type, like for
8918                                            typeof(Gen<>). */
8919                                         context_used = 0;
8920                                 } else if (handle_class == mono_defaults.typehandle_class) {
8921                                         /* If we get a MONO_TYPE_CLASS
8922                                            then we need to provide the
8923                                            open type, not an
8924                                            instantiation of it. */
8925                                         if (mono_type_get_type (handle) == MONO_TYPE_CLASS)
8926                                                 context_used = 0;
8927                                         else
8928                                                 context_used = mono_class_check_context_used (mono_class_from_mono_type (handle));
8929                                 } else if (handle_class == mono_defaults.fieldhandle_class)
8930                                         context_used = mono_class_check_context_used (((MonoClassField*)handle)->parent);
8931                                 else if (handle_class == mono_defaults.methodhandle_class)
8932                                         context_used = mono_method_check_context_used (handle);
8933                                 else
8934                                         g_assert_not_reached ();
8935                         }
8936
8937                         if ((cfg->opt & MONO_OPT_SHARED) &&
8938                                         method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD &&
8939                                         method->wrapper_type != MONO_WRAPPER_SYNCHRONIZED) {
8940                                 MonoInst *addr, *vtvar, *iargs [3];
8941                                 int method_context_used;
8942
8943                                 if (cfg->generic_sharing_context)
8944                                         method_context_used = mono_method_check_context_used (method);
8945                                 else
8946                                         method_context_used = 0;
8947
8948                                 vtvar = mono_compile_create_var (cfg, &handle_class->byval_arg, OP_LOCAL);
8949
8950                                 EMIT_NEW_IMAGECONST (cfg, iargs [0], image);
8951                                 EMIT_NEW_ICONST (cfg, iargs [1], n);
8952                                 if (method_context_used) {
8953                                         iargs [2] = emit_get_rgctx_method (cfg, method_context_used,
8954                                                 method, MONO_RGCTX_INFO_METHOD);
8955                                         ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper_generic_shared, iargs);
8956                                 } else {
8957                                         EMIT_NEW_PCONST (cfg, iargs [2], generic_context);
8958                                         ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper, iargs);
8959                                 }
8960                                 EMIT_NEW_TEMPLOADA (cfg, addr, vtvar->inst_c0);
8961
8962                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, addr->dreg, 0, ins->dreg);
8963
8964                                 EMIT_NEW_TEMPLOAD (cfg, ins, vtvar->inst_c0);
8965                         } else {
8966                                 if ((ip + 5 < end) && ip_in_bb (cfg, bblock, ip + 5) &&
8967                                         ((ip [5] == CEE_CALL) || (ip [5] == CEE_CALLVIRT)) &&
8968                                         (cmethod = mini_get_method (cfg, method, read32 (ip + 6), NULL, generic_context)) &&
8969                                         (cmethod->klass == mono_defaults.monotype_class->parent) &&
8970                                         (strcmp (cmethod->name, "GetTypeFromHandle") == 0)) {
8971                                         MonoClass *tclass = mono_class_from_mono_type (handle);
8972
8973                                         mono_class_init (tclass);
8974                                         if (context_used) {
8975                                                 ins = emit_get_rgctx_klass (cfg, context_used,
8976                                                         tclass, MONO_RGCTX_INFO_REFLECTION_TYPE);
8977                                         } else if (cfg->compile_aot) {
8978                                                 if (method->wrapper_type) {
8979                                                         if (mono_class_get (tclass->image, tclass->type_token) == tclass && !generic_context) {
8980                                                                 /* Special case for static synchronized wrappers */
8981                                                                 EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, tclass->image, tclass->type_token, generic_context);
8982                                                         } else {
8983                                                                 /* FIXME: n is not a normal token */
8984                                                                 cfg->disable_aot = TRUE;
8985                                                                 EMIT_NEW_PCONST (cfg, ins, NULL);
8986                                                         }
8987                                                 } else {
8988                                                         EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, image, n, generic_context);
8989                                                 }
8990                                         } else {
8991                                                 EMIT_NEW_PCONST (cfg, ins, mono_type_get_object (cfg->domain, handle));
8992                                         }
8993                                         ins->type = STACK_OBJ;
8994                                         ins->klass = cmethod->klass;
8995                                         ip += 5;
8996                                 } else {
8997                                         MonoInst *addr, *vtvar;
8998
8999                                         vtvar = mono_compile_create_var (cfg, &handle_class->byval_arg, OP_LOCAL);
9000
9001                                         if (context_used) {
9002                                                 if (handle_class == mono_defaults.typehandle_class) {
9003                                                         ins = emit_get_rgctx_klass (cfg, context_used,
9004                                                                         mono_class_from_mono_type (handle),
9005                                                                         MONO_RGCTX_INFO_TYPE);
9006                                                 } else if (handle_class == mono_defaults.methodhandle_class) {
9007                                                         ins = emit_get_rgctx_method (cfg, context_used,
9008                                                                         handle, MONO_RGCTX_INFO_METHOD);
9009                                                 } else if (handle_class == mono_defaults.fieldhandle_class) {
9010                                                         ins = emit_get_rgctx_field (cfg, context_used,
9011                                                                         handle, MONO_RGCTX_INFO_CLASS_FIELD);
9012                                                 } else {
9013                                                         g_assert_not_reached ();
9014                                                 }
9015                                         } else if (cfg->compile_aot) {
9016                                                 EMIT_NEW_LDTOKENCONST (cfg, ins, image, n);
9017                                         } else {
9018                                                 EMIT_NEW_PCONST (cfg, ins, handle);
9019                                         }
9020                                         EMIT_NEW_TEMPLOADA (cfg, addr, vtvar->inst_c0);
9021                                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, addr->dreg, 0, ins->dreg);
9022                                         EMIT_NEW_TEMPLOAD (cfg, ins, vtvar->inst_c0);
9023                                 }
9024                         }
9025
9026                         *sp++ = ins;
9027                         ip += 5;
9028                         break;
9029                 }
9030                 case CEE_THROW:
9031                         CHECK_STACK (1);
9032                         MONO_INST_NEW (cfg, ins, OP_THROW);
9033                         --sp;
9034                         ins->sreg1 = sp [0]->dreg;
9035                         ip++;
9036                         bblock->out_of_line = TRUE;
9037                         MONO_ADD_INS (bblock, ins);
9038                         MONO_INST_NEW (cfg, ins, OP_NOT_REACHED);
9039                         MONO_ADD_INS (bblock, ins);
9040                         sp = stack_start;
9041
9042                         link_bblock (cfg, bblock, end_bblock);
9043                         start_new_bblock = 1;
9044                         break;
9045                 case CEE_ENDFINALLY:
9046                         MONO_INST_NEW (cfg, ins, OP_ENDFINALLY);
9047                         MONO_ADD_INS (bblock, ins);
9048                         ip++;
9049                         start_new_bblock = 1;
9050
9051                         /*
9052                          * Control will leave the method so empty the stack, otherwise
9053                          * the next basic block will start with a nonempty stack.
9054                          */
9055                         while (sp != stack_start) {
9056                                 sp--;
9057                         }
9058                         break;
9059                 case CEE_LEAVE:
9060                 case CEE_LEAVE_S: {
9061                         GList *handlers;
9062
9063                         if (*ip == CEE_LEAVE) {
9064                                 CHECK_OPSIZE (5);
9065                                 target = ip + 5 + (gint32)read32(ip + 1);
9066                         } else {
9067                                 CHECK_OPSIZE (2);
9068                                 target = ip + 2 + (signed char)(ip [1]);
9069                         }
9070
9071                         /* empty the stack */
9072                         while (sp != stack_start) {
9073                                 sp--;
9074                         }
9075
9076                         /*
9077                          * If this leave statement is in a catch block, check for a
9078                          * pending exception, and rethrow it if necessary.
9079                          * We avoid doing this in runtime invoke wrappers, since those are called
9080                          * by native code which excepts the wrapper to catch all exceptions.
9081                          */
9082                         for (i = 0; i < header->num_clauses; ++i) {
9083                                 MonoExceptionClause *clause = &header->clauses [i];
9084
9085                                 /*
9086                                  * Use <= in the final comparison to handle clauses with multiple
9087                                  * leave statements, like in bug #78024.
9088                                  * The ordering of the exception clauses guarantees that we find the
9089                                  * innermost clause.
9090                                  */
9091                                 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) {
9092                                         MonoInst *exc_ins;
9093                                         MonoBasicBlock *dont_throw;
9094
9095                                         /*
9096                                           MonoInst *load;
9097
9098                                           NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, clause->handler_offset)->inst_c0);
9099                                         */
9100
9101                                         exc_ins = mono_emit_jit_icall (cfg, mono_thread_get_undeniable_exception, NULL);
9102
9103                                         NEW_BBLOCK (cfg, dont_throw);
9104
9105                                         /*
9106                                          * Currently, we allways rethrow the abort exception, despite the
9107                                          * fact that this is not correct. See thread6.cs for an example.
9108                                          * But propagating the abort exception is more important than
9109                                          * getting the sematics right.
9110                                          */
9111                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, exc_ins->dreg, 0);
9112                                         MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBEQ, dont_throw);
9113                                         MONO_EMIT_NEW_UNALU (cfg, OP_THROW, -1, exc_ins->dreg);
9114
9115                                         MONO_START_BB (cfg, dont_throw);
9116                                         bblock = cfg->cbb;
9117                                 }
9118                         }
9119
9120                         if ((handlers = mono_find_final_block (cfg, ip, target, MONO_EXCEPTION_CLAUSE_FINALLY))) {
9121                                 GList *tmp;
9122                                 MonoExceptionClause *clause;
9123
9124                                 for (tmp = handlers; tmp; tmp = tmp->next) {
9125                                         clause = tmp->data;
9126                                         tblock = cfg->cil_offset_to_bb [clause->handler_offset];
9127                                         g_assert (tblock);
9128                                         link_bblock (cfg, bblock, tblock);
9129                                         MONO_INST_NEW (cfg, ins, OP_CALL_HANDLER);
9130                                         ins->inst_target_bb = tblock;
9131                                         ins->inst_eh_block = clause;
9132                                         MONO_ADD_INS (bblock, ins);
9133                                         bblock->has_call_handler = 1;
9134                                         if (COMPILE_LLVM (cfg)) {
9135                                                 MonoBasicBlock *target_bb;
9136
9137                                                 /*
9138                                                  * Link the finally bblock with the target, since it will
9139                                                  * conceptually branch there.
9140                                                  * FIXME: Have to link the bblock containing the endfinally.
9141                                                  */
9142                                                 GET_BBLOCK (cfg, target_bb, target);
9143                                                 link_bblock (cfg, tblock, target_bb);
9144                                         }
9145                                 }
9146                                 g_list_free (handlers);
9147                         }
9148
9149                         MONO_INST_NEW (cfg, ins, OP_BR);
9150                         MONO_ADD_INS (bblock, ins);
9151                         GET_BBLOCK (cfg, tblock, target);
9152                         link_bblock (cfg, bblock, tblock);
9153                         ins->inst_target_bb = tblock;
9154                         start_new_bblock = 1;
9155
9156                         if (*ip == CEE_LEAVE)
9157                                 ip += 5;
9158                         else
9159                                 ip += 2;
9160
9161                         break;
9162                 }
9163
9164                         /*
9165                          * Mono specific opcodes
9166                          */
9167                 case MONO_CUSTOM_PREFIX: {
9168
9169                         g_assert (method->wrapper_type != MONO_WRAPPER_NONE);
9170
9171                         CHECK_OPSIZE (2);
9172                         switch (ip [1]) {
9173                         case CEE_MONO_ICALL: {
9174                                 gpointer func;
9175                                 MonoJitICallInfo *info;
9176
9177                                 token = read32 (ip + 2);
9178                                 func = mono_method_get_wrapper_data (method, token);
9179                                 info = mono_find_jit_icall_by_addr (func);
9180                                 g_assert (info);
9181
9182                                 CHECK_STACK (info->sig->param_count);
9183                                 sp -= info->sig->param_count;
9184
9185                                 ins = mono_emit_jit_icall (cfg, info->func, sp);
9186                                 if (!MONO_TYPE_IS_VOID (info->sig->ret))
9187                                         *sp++ = ins;
9188
9189                                 ip += 6;
9190                                 inline_costs += 10 * num_calls++;
9191
9192                                 break;
9193                         }
9194                         case CEE_MONO_LDPTR: {
9195                                 gpointer ptr;
9196
9197                                 CHECK_STACK_OVF (1);
9198                                 CHECK_OPSIZE (6);
9199                                 token = read32 (ip + 2);
9200
9201                                 ptr = mono_method_get_wrapper_data (method, token);
9202                                 if (cfg->compile_aot && (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && (strstr (method->name, "__icall_wrapper_") == method->name)) {
9203                                         MonoJitICallInfo *callinfo;
9204                                         const char *icall_name;
9205
9206                                         icall_name = method->name + strlen ("__icall_wrapper_");
9207                                         g_assert (icall_name);
9208                                         callinfo = mono_find_jit_icall_by_name (icall_name);
9209                                         g_assert (callinfo);
9210
9211                                         if (ptr == callinfo->func) {
9212                                                 /* Will be transformed into an AOTCONST later */
9213                                                 EMIT_NEW_PCONST (cfg, ins, ptr);
9214                                                 *sp++ = ins;
9215                                                 ip += 6;
9216                                                 break;
9217                                         }
9218                                 }
9219                                 /* FIXME: Generalize this */
9220                                 if (cfg->compile_aot && ptr == mono_thread_interruption_request_flag ()) {
9221                                         EMIT_NEW_AOTCONST (cfg, ins, MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG, NULL);
9222                                         *sp++ = ins;
9223                                         ip += 6;
9224                                         break;
9225                                 }
9226                                 EMIT_NEW_PCONST (cfg, ins, ptr);
9227                                 *sp++ = ins;
9228                                 ip += 6;
9229                                 inline_costs += 10 * num_calls++;
9230                                 /* Can't embed random pointers into AOT code */
9231                                 cfg->disable_aot = 1;
9232                                 break;
9233                         }
9234                         case CEE_MONO_ICALL_ADDR: {
9235                                 MonoMethod *cmethod;
9236                                 gpointer ptr;
9237
9238                                 CHECK_STACK_OVF (1);
9239                                 CHECK_OPSIZE (6);
9240                                 token = read32 (ip + 2);
9241
9242                                 cmethod = mono_method_get_wrapper_data (method, token);
9243
9244                                 if (cfg->compile_aot) {
9245                                         EMIT_NEW_AOTCONST (cfg, ins, MONO_PATCH_INFO_ICALL_ADDR, cmethod);
9246                                 } else {
9247                                         ptr = mono_lookup_internal_call (cmethod);
9248                                         g_assert (ptr);
9249                                         EMIT_NEW_PCONST (cfg, ins, ptr);
9250                                 }
9251                                 *sp++ = ins;
9252                                 ip += 6;
9253                                 break;
9254                         }
9255                         case CEE_MONO_VTADDR: {
9256                                 MonoInst *src_var, *src;
9257
9258                                 CHECK_STACK (1);
9259                                 --sp;
9260
9261                                 // FIXME:
9262                                 src_var = get_vreg_to_inst (cfg, sp [0]->dreg);
9263                                 EMIT_NEW_VARLOADA ((cfg), (src), src_var, src_var->inst_vtype);
9264                                 *sp++ = src;
9265                                 ip += 2;
9266                                 break;
9267                         }
9268                         case CEE_MONO_NEWOBJ: {
9269                                 MonoInst *iargs [2];
9270
9271                                 CHECK_STACK_OVF (1);
9272                                 CHECK_OPSIZE (6);
9273                                 token = read32 (ip + 2);
9274                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
9275                                 mono_class_init (klass);
9276                                 NEW_DOMAINCONST (cfg, iargs [0]);
9277                                 MONO_ADD_INS (cfg->cbb, iargs [0]);
9278                                 NEW_CLASSCONST (cfg, iargs [1], klass);
9279                                 MONO_ADD_INS (cfg->cbb, iargs [1]);
9280                                 *sp++ = mono_emit_jit_icall (cfg, mono_object_new, iargs);
9281                                 ip += 6;
9282                                 inline_costs += 10 * num_calls++;
9283                                 break;
9284                         }
9285                         case CEE_MONO_OBJADDR:
9286                                 CHECK_STACK (1);
9287                                 --sp;
9288                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
9289                                 ins->dreg = alloc_preg (cfg);
9290                                 ins->sreg1 = sp [0]->dreg;
9291                                 ins->type = STACK_MP;
9292                                 MONO_ADD_INS (cfg->cbb, ins);
9293                                 *sp++ = ins;
9294                                 ip += 2;
9295                                 break;
9296                         case CEE_MONO_LDNATIVEOBJ:
9297                                 /*
9298                                  * Similar to LDOBJ, but instead load the unmanaged
9299                                  * representation of the vtype to the stack.
9300                                  */
9301                                 CHECK_STACK (1);
9302                                 CHECK_OPSIZE (6);
9303                                 --sp;
9304                                 token = read32 (ip + 2);
9305                                 klass = mono_method_get_wrapper_data (method, token);
9306                                 g_assert (klass->valuetype);
9307                                 mono_class_init (klass);
9308
9309                                 {
9310                                         MonoInst *src, *dest, *temp;
9311
9312                                         src = sp [0];
9313                                         temp = mono_compile_create_var (cfg, &klass->byval_arg, OP_LOCAL);
9314                                         temp->backend.is_pinvoke = 1;
9315                                         EMIT_NEW_TEMPLOADA (cfg, dest, temp->inst_c0);
9316                                         mini_emit_stobj (cfg, dest, src, klass, TRUE);
9317
9318                                         EMIT_NEW_TEMPLOAD (cfg, dest, temp->inst_c0);
9319                                         dest->type = STACK_VTYPE;
9320                                         dest->klass = klass;
9321
9322                                         *sp ++ = dest;
9323                                         ip += 6;
9324                                 }
9325                                 break;
9326                         case CEE_MONO_RETOBJ: {
9327                                 /*
9328                                  * Same as RET, but return the native representation of a vtype
9329                                  * to the caller.
9330                                  */
9331                                 g_assert (cfg->ret);
9332                                 g_assert (mono_method_signature (method)->pinvoke);
9333                                 CHECK_STACK (1);
9334                                 --sp;
9335
9336                                 CHECK_OPSIZE (6);
9337                                 token = read32 (ip + 2);
9338                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
9339
9340                                 if (!cfg->vret_addr) {
9341                                         g_assert (cfg->ret_var_is_local);
9342
9343                                         EMIT_NEW_VARLOADA (cfg, ins, cfg->ret, cfg->ret->inst_vtype);
9344                                 } else {
9345                                         EMIT_NEW_RETLOADA (cfg, ins);
9346                                 }
9347                                 mini_emit_stobj (cfg, ins, sp [0], klass, TRUE);
9348
9349                                 if (sp != stack_start)
9350                                         UNVERIFIED;
9351
9352                                 MONO_INST_NEW (cfg, ins, OP_BR);
9353                                 ins->inst_target_bb = end_bblock;
9354                                 MONO_ADD_INS (bblock, ins);
9355                                 link_bblock (cfg, bblock, end_bblock);
9356                                 start_new_bblock = 1;
9357                                 ip += 6;
9358                                 break;
9359                         }
9360                         case CEE_MONO_CISINST:
9361                         case CEE_MONO_CCASTCLASS: {
9362                                 int token;
9363                                 CHECK_STACK (1);
9364                                 --sp;
9365                                 CHECK_OPSIZE (6);
9366                                 token = read32 (ip + 2);
9367                                 klass = (MonoClass *)mono_method_get_wrapper_data (method, token);
9368                                 if (ip [1] == CEE_MONO_CISINST)
9369                                         ins = handle_cisinst (cfg, klass, sp [0]);
9370                                 else
9371                                         ins = handle_ccastclass (cfg, klass, sp [0]);
9372                                 bblock = cfg->cbb;
9373                                 *sp++ = ins;
9374                                 ip += 6;
9375                                 break;
9376                         }
9377                         case CEE_MONO_SAVE_LMF:
9378                         case CEE_MONO_RESTORE_LMF:
9379 #ifdef MONO_ARCH_HAVE_LMF_OPS
9380                                 MONO_INST_NEW (cfg, ins, (ip [1] == CEE_MONO_SAVE_LMF) ? OP_SAVE_LMF : OP_RESTORE_LMF);
9381                                 MONO_ADD_INS (bblock, ins);
9382                                 cfg->need_lmf_area = TRUE;
9383 #endif
9384                                 ip += 2;
9385                                 break;
9386                         case CEE_MONO_CLASSCONST:
9387                                 CHECK_STACK_OVF (1);
9388                                 CHECK_OPSIZE (6);
9389                                 token = read32 (ip + 2);
9390                                 EMIT_NEW_CLASSCONST (cfg, ins, mono_method_get_wrapper_data (method, token));
9391                                 *sp++ = ins;
9392                                 ip += 6;
9393                                 inline_costs += 10 * num_calls++;
9394                                 break;
9395                         case CEE_MONO_NOT_TAKEN:
9396                                 bblock->out_of_line = TRUE;
9397                                 ip += 2;
9398                                 break;
9399                         case CEE_MONO_TLS:
9400                                 CHECK_STACK_OVF (1);
9401                                 CHECK_OPSIZE (6);
9402                                 MONO_INST_NEW (cfg, ins, OP_TLS_GET);
9403                                 ins->dreg = alloc_preg (cfg);
9404                                 ins->inst_offset = (gint32)read32 (ip + 2);
9405                                 ins->type = STACK_PTR;
9406                                 MONO_ADD_INS (bblock, ins);
9407                                 *sp++ = ins;
9408                                 ip += 6;
9409                                 break;
9410                         case CEE_MONO_DYN_CALL: {
9411                                 MonoCallInst *call;
9412
9413                                 /* It would be easier to call a trampoline, but that would put an
9414                                  * extra frame on the stack, confusing exception handling. So
9415                                  * implement it inline using an opcode for now.
9416                                  */
9417
9418                                 if (!cfg->dyn_call_var) {
9419                                         cfg->dyn_call_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
9420                                         /* prevent it from being register allocated */
9421                                         cfg->dyn_call_var->flags |= MONO_INST_INDIRECT;
9422                                 }
9423
9424                                 /* Has to use a call inst since it local regalloc expects it */
9425                                 MONO_INST_NEW_CALL (cfg, call, OP_DYN_CALL);
9426                                 ins = (MonoInst*)call;
9427                                 sp -= 2;
9428                                 ins->sreg1 = sp [0]->dreg;
9429                                 ins->sreg2 = sp [1]->dreg;
9430                                 MONO_ADD_INS (bblock, ins);
9431
9432 #ifdef MONO_ARCH_DYN_CALL_PARAM_AREA
9433                                 cfg->param_area = MAX (cfg->param_area, MONO_ARCH_DYN_CALL_PARAM_AREA);
9434 #endif
9435
9436                                 ip += 2;
9437                                 inline_costs += 10 * num_calls++;
9438
9439                                 break;
9440                         }
9441                         default:
9442                                 g_error ("opcode 0x%02x 0x%02x not handled", MONO_CUSTOM_PREFIX, ip [1]);
9443                                 break;
9444                         }
9445                         break;
9446                 }
9447
9448                 case CEE_PREFIX1: {
9449                         CHECK_OPSIZE (2);
9450                         switch (ip [1]) {
9451                         case CEE_ARGLIST: {
9452                                 /* somewhat similar to LDTOKEN */
9453                                 MonoInst *addr, *vtvar;
9454                                 CHECK_STACK_OVF (1);
9455                                 vtvar = mono_compile_create_var (cfg, &mono_defaults.argumenthandle_class->byval_arg, OP_LOCAL);
9456
9457                                 EMIT_NEW_TEMPLOADA (cfg, addr, vtvar->inst_c0);
9458                                 EMIT_NEW_UNALU (cfg, ins, OP_ARGLIST, -1, addr->dreg);
9459
9460                                 EMIT_NEW_TEMPLOAD (cfg, ins, vtvar->inst_c0);
9461                                 ins->type = STACK_VTYPE;
9462                                 ins->klass = mono_defaults.argumenthandle_class;
9463                                 *sp++ = ins;
9464                                 ip += 2;
9465                                 break;
9466                         }
9467                         case CEE_CEQ:
9468                         case CEE_CGT:
9469                         case CEE_CGT_UN:
9470                         case CEE_CLT:
9471                         case CEE_CLT_UN: {
9472                                 MonoInst *cmp;
9473                                 CHECK_STACK (2);
9474                                 /*
9475                                  * The following transforms:
9476                                  *    CEE_CEQ    into OP_CEQ
9477                                  *    CEE_CGT    into OP_CGT
9478                                  *    CEE_CGT_UN into OP_CGT_UN
9479                                  *    CEE_CLT    into OP_CLT
9480                                  *    CEE_CLT_UN into OP_CLT_UN
9481                                  */
9482                                 MONO_INST_NEW (cfg, cmp, (OP_CEQ - CEE_CEQ) + ip [1]);
9483
9484                                 MONO_INST_NEW (cfg, ins, cmp->opcode);
9485                                 sp -= 2;
9486                                 cmp->sreg1 = sp [0]->dreg;
9487                                 cmp->sreg2 = sp [1]->dreg;
9488                                 type_from_op (cmp, sp [0], sp [1]);
9489                                 CHECK_TYPE (cmp);
9490                                 if ((sp [0]->type == STACK_I8) || ((SIZEOF_REGISTER == 8) && ((sp [0]->type == STACK_PTR) || (sp [0]->type == STACK_OBJ) || (sp [0]->type == STACK_MP))))
9491                                         cmp->opcode = OP_LCOMPARE;
9492                                 else if (sp [0]->type == STACK_R8)
9493                                         cmp->opcode = OP_FCOMPARE;
9494                                 else
9495                                         cmp->opcode = OP_ICOMPARE;
9496                                 MONO_ADD_INS (bblock, cmp);
9497                                 ins->type = STACK_I4;
9498                                 ins->dreg = alloc_dreg (cfg, ins->type);
9499                                 type_from_op (ins, sp [0], sp [1]);
9500
9501                                 if (cmp->opcode == OP_FCOMPARE) {
9502                                         /*
9503                                          * The backends expect the fceq opcodes to do the
9504                                          * comparison too.
9505                                          */
9506                                         cmp->opcode = OP_NOP;
9507                                         ins->sreg1 = cmp->sreg1;
9508                                         ins->sreg2 = cmp->sreg2;
9509                                 }
9510                                 MONO_ADD_INS (bblock, ins);
9511                                 *sp++ = ins;
9512                                 ip += 2;
9513                                 break;
9514                         }
9515                         case CEE_LDFTN: {
9516                                 MonoInst *argconst;
9517                                 MonoMethod *cil_method;
9518                                 gboolean needs_static_rgctx_invoke;
9519
9520                                 CHECK_STACK_OVF (1);
9521                                 CHECK_OPSIZE (6);
9522                                 n = read32 (ip + 2);
9523                                 cmethod = mini_get_method (cfg, method, n, NULL, generic_context);
9524                                 if (!cmethod)
9525                                         goto load_error;
9526                                 mono_class_init (cmethod->klass);
9527
9528                                 mono_save_token_info (cfg, image, n, cmethod);
9529
9530                                 if (cfg->generic_sharing_context)
9531                                         context_used = mono_method_check_context_used (cmethod);
9532
9533                                 needs_static_rgctx_invoke = mono_method_needs_static_rgctx_invoke (cmethod, TRUE);
9534
9535                                 cil_method = cmethod;
9536                                 if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_method (method, cmethod))
9537                                         METHOD_ACCESS_FAILURE;
9538
9539                                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
9540                                         if (check_linkdemand (cfg, method, cmethod))
9541                                                 INLINE_FAILURE;
9542                                         CHECK_CFG_EXCEPTION;
9543                                 } else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
9544                                         ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock, ip);
9545                                 }
9546
9547                                 /*
9548                                  * Optimize the common case of ldftn+delegate creation
9549                                  */
9550                                 if ((sp > stack_start) && (ip + 6 + 5 < end) && ip_in_bb (cfg, bblock, ip + 6) && (ip [6] == CEE_NEWOBJ)) {
9551                                         MonoMethod *ctor_method = mini_get_method (cfg, method, read32 (ip + 7), NULL, generic_context);
9552                                         if (ctor_method && (ctor_method->klass->parent == mono_defaults.multicastdelegate_class)) {
9553                                                 MonoMethod *invoke;
9554                                                 int invoke_context_used = 0;
9555
9556                                                 invoke = mono_get_delegate_invoke (ctor_method->klass);
9557                                                 if (!invoke || !mono_method_signature (invoke))
9558                                                         goto load_error;
9559
9560                                                 if (cfg->generic_sharing_context)
9561                                                         invoke_context_used = mono_method_check_context_used (invoke);
9562
9563 #if defined(MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE)
9564                                                 /* FIXME: SGEN support */
9565                                                 if (!cfg->gen_write_barriers && invoke_context_used == 0) {
9566                                                         MonoInst *target_ins;
9567
9568                                                         ip += 6;
9569                                                         if (cfg->verbose_level > 3)
9570                                                                 g_print ("converting (in B%d: stack: %d) %s", bblock->block_num, (int)(sp - stack_start), mono_disasm_code_one (NULL, method, ip, NULL));
9571                                                         target_ins = sp [-1];
9572                                                         sp --;
9573                                                         *sp = handle_delegate_ctor (cfg, ctor_method->klass, target_ins, cmethod, context_used);
9574                                                         CHECK_CFG_EXCEPTION;
9575                                                         ip += 5;
9576                                                         sp ++;
9577                                                         break;
9578                                                 }
9579 #endif
9580                                         }
9581                                 }
9582
9583                                 argconst = emit_get_rgctx_method (cfg, context_used, cmethod, MONO_RGCTX_INFO_METHOD);
9584                                 ins = mono_emit_jit_icall (cfg, mono_ldftn, &argconst);
9585                                 *sp++ = ins;
9586
9587                                 ip += 6;
9588                                 inline_costs += 10 * num_calls++;
9589                                 break;
9590                         }
9591                         case CEE_LDVIRTFTN: {
9592                                 MonoInst *args [2];
9593
9594                                 CHECK_STACK (1);
9595                                 CHECK_OPSIZE (6);
9596                                 n = read32 (ip + 2);
9597                                 cmethod = mini_get_method (cfg, method, n, NULL, generic_context);
9598                                 if (!cmethod)
9599                                         goto load_error;
9600                                 mono_class_init (cmethod->klass);
9601
9602                                 if (cfg->generic_sharing_context)
9603                                         context_used = mono_method_check_context_used (cmethod);
9604
9605                                 if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
9606                                         if (check_linkdemand (cfg, method, cmethod))
9607                                                 INLINE_FAILURE;
9608                                         CHECK_CFG_EXCEPTION;
9609                                 } else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
9610                                         ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock, ip);
9611                                 }
9612
9613                                 --sp;
9614                                 args [0] = *sp;
9615
9616                                 args [1] = emit_get_rgctx_method (cfg, context_used,
9617                                                                                                   cmethod, MONO_RGCTX_INFO_METHOD);
9618
9619                                 if (context_used)
9620                                         *sp++ = mono_emit_jit_icall (cfg, mono_ldvirtfn_gshared, args);
9621                                 else
9622                                         *sp++ = mono_emit_jit_icall (cfg, mono_ldvirtfn, args);
9623
9624                                 ip += 6;
9625                                 inline_costs += 10 * num_calls++;
9626                                 break;
9627                         }
9628                         case CEE_LDARG:
9629                                 CHECK_STACK_OVF (1);
9630                                 CHECK_OPSIZE (4);
9631                                 n = read16 (ip + 2);
9632                                 CHECK_ARG (n);
9633                                 EMIT_NEW_ARGLOAD (cfg, ins, n);
9634                                 *sp++ = ins;
9635                                 ip += 4;
9636                                 break;
9637                         case CEE_LDARGA:
9638                                 CHECK_STACK_OVF (1);
9639                                 CHECK_OPSIZE (4);
9640                                 n = read16 (ip + 2);
9641                                 CHECK_ARG (n);
9642                                 NEW_ARGLOADA (cfg, ins, n);
9643                                 MONO_ADD_INS (cfg->cbb, ins);
9644                                 *sp++ = ins;
9645                                 ip += 4;
9646                                 break;
9647                         case CEE_STARG:
9648                                 CHECK_STACK (1);
9649                                 --sp;
9650                                 CHECK_OPSIZE (4);
9651                                 n = read16 (ip + 2);
9652                                 CHECK_ARG (n);
9653                                 if (!dont_verify_stloc && target_type_is_incompatible (cfg, param_types [n], *sp))
9654                                         UNVERIFIED;
9655                                 EMIT_NEW_ARGSTORE (cfg, ins, n, *sp);
9656                                 ip += 4;
9657                                 break;
9658                         case CEE_LDLOC:
9659                                 CHECK_STACK_OVF (1);
9660                                 CHECK_OPSIZE (4);
9661                                 n = read16 (ip + 2);
9662                                 CHECK_LOCAL (n);
9663                                 EMIT_NEW_LOCLOAD (cfg, ins, n);
9664                                 *sp++ = ins;
9665                                 ip += 4;
9666                                 break;
9667                         case CEE_LDLOCA: {
9668                                 unsigned char *tmp_ip;
9669                                 CHECK_STACK_OVF (1);
9670                                 CHECK_OPSIZE (4);
9671                                 n = read16 (ip + 2);
9672                                 CHECK_LOCAL (n);
9673
9674                                 if ((tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 2))) {
9675                                         ip = tmp_ip;
9676                                         inline_costs += 1;
9677                                         break;
9678                                 }
9679
9680                                 EMIT_NEW_LOCLOADA (cfg, ins, n);
9681                                 *sp++ = ins;
9682                                 ip += 4;
9683                                 break;
9684                         }
9685                         case CEE_STLOC:
9686                                 CHECK_STACK (1);
9687                                 --sp;
9688                                 CHECK_OPSIZE (4);
9689                                 n = read16 (ip + 2);
9690                                 CHECK_LOCAL (n);
9691                                 if (!dont_verify_stloc && target_type_is_incompatible (cfg, header->locals [n], *sp))
9692                                         UNVERIFIED;
9693                                 emit_stloc_ir (cfg, sp, header, n);
9694                                 ip += 4;
9695                                 inline_costs += 1;
9696                                 break;
9697                         case CEE_LOCALLOC:
9698                                 CHECK_STACK (1);
9699                                 --sp;
9700                                 if (sp != stack_start)
9701                                         UNVERIFIED;
9702                                 if (cfg->method != method)
9703                                         /*
9704                                          * Inlining this into a loop in a parent could lead to
9705                                          * stack overflows which is different behavior than the
9706                                          * non-inlined case, thus disable inlining in this case.
9707                                          */
9708                                         goto inline_failure;
9709
9710                                 MONO_INST_NEW (cfg, ins, OP_LOCALLOC);
9711                                 ins->dreg = alloc_preg (cfg);
9712                                 ins->sreg1 = sp [0]->dreg;
9713                                 ins->type = STACK_PTR;
9714                                 MONO_ADD_INS (cfg->cbb, ins);
9715
9716                                 cfg->flags |= MONO_CFG_HAS_ALLOCA;
9717                                 if (init_locals)
9718                                         ins->flags |= MONO_INST_INIT;
9719
9720                                 *sp++ = ins;
9721                                 ip += 2;
9722                                 break;
9723                         case CEE_ENDFILTER: {
9724                                 MonoExceptionClause *clause, *nearest;
9725                                 int cc, nearest_num;
9726
9727                                 CHECK_STACK (1);
9728                                 --sp;
9729                                 if ((sp != stack_start) || (sp [0]->type != STACK_I4))
9730                                         UNVERIFIED;
9731                                 MONO_INST_NEW (cfg, ins, OP_ENDFILTER);
9732                                 ins->sreg1 = (*sp)->dreg;
9733                                 MONO_ADD_INS (bblock, ins);
9734                                 start_new_bblock = 1;
9735                                 ip += 2;
9736
9737                                 nearest = NULL;
9738                                 nearest_num = 0;
9739                                 for (cc = 0; cc < header->num_clauses; ++cc) {
9740                                         clause = &header->clauses [cc];
9741                                         if ((clause->flags & MONO_EXCEPTION_CLAUSE_FILTER) &&
9742                                                 ((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
9743                                             (!nearest || (clause->data.filter_offset < nearest->data.filter_offset))) {
9744                                                 nearest = clause;
9745                                                 nearest_num = cc;
9746                                         }
9747                                 }
9748                                 g_assert (nearest);
9749                                 if ((ip - header->code) != nearest->handler_offset)
9750                                         UNVERIFIED;
9751
9752                                 break;
9753                         }
9754                         case CEE_UNALIGNED_:
9755                                 ins_flag |= MONO_INST_UNALIGNED;
9756                                 /* FIXME: record alignment? we can assume 1 for now */
9757                                 CHECK_OPSIZE (3);
9758                                 ip += 3;
9759                                 break;
9760                         case CEE_VOLATILE_:
9761                                 ins_flag |= MONO_INST_VOLATILE;
9762                                 ip += 2;
9763                                 break;
9764                         case CEE_TAIL_:
9765                                 ins_flag   |= MONO_INST_TAILCALL;
9766                                 cfg->flags |= MONO_CFG_HAS_TAIL;
9767                                 /* Can't inline tail calls at this time */
9768                                 inline_costs += 100000;
9769                                 ip += 2;
9770                                 break;
9771                         case CEE_INITOBJ:
9772                                 CHECK_STACK (1);
9773                                 --sp;
9774                                 CHECK_OPSIZE (6);
9775                                 token = read32 (ip + 2);
9776                                 klass = mini_get_class (method, token, generic_context);
9777                                 CHECK_TYPELOAD (klass);
9778                                 if (generic_class_is_reference_type (cfg, klass))
9779                                         MONO_EMIT_NEW_STORE_MEMBASE_IMM (cfg, OP_STORE_MEMBASE_IMM, sp [0]->dreg, 0, 0);
9780                                 else
9781                                         mini_emit_initobj (cfg, *sp, NULL, klass);
9782                                 ip += 6;
9783                                 inline_costs += 1;
9784                                 break;
9785                         case CEE_CONSTRAINED_:
9786                                 CHECK_OPSIZE (6);
9787                                 token = read32 (ip + 2);
9788                                 if (method->wrapper_type != MONO_WRAPPER_NONE)
9789                                         constrained_call =  (MonoClass *)mono_method_get_wrapper_data (method, token);
9790                                 else
9791                                         constrained_call = mono_class_get_full (image, token, generic_context);
9792                                 CHECK_TYPELOAD (constrained_call);
9793                                 ip += 6;
9794                                 break;
9795                         case CEE_CPBLK:
9796                         case CEE_INITBLK: {
9797                                 MonoInst *iargs [3];
9798                                 CHECK_STACK (3);
9799                                 sp -= 3;
9800
9801                                 if ((ip [1] == CEE_CPBLK) && (cfg->opt & MONO_OPT_INTRINS) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof (gpointer) * 5)) {
9802                                         mini_emit_memcpy (cfg, sp [0]->dreg, 0, sp [1]->dreg, 0, sp [2]->inst_c0, 0);
9803                                 } else if ((ip [1] == CEE_INITBLK) && (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)) {
9804                                         /* emit_memset only works when val == 0 */
9805                                         mini_emit_memset (cfg, sp [0]->dreg, 0, sp [2]->inst_c0, sp [1]->inst_c0, 0);
9806                                 } else {
9807                                         iargs [0] = sp [0];
9808                                         iargs [1] = sp [1];
9809                                         iargs [2] = sp [2];
9810                                         if (ip [1] == CEE_CPBLK) {
9811                                                 MonoMethod *memcpy_method = get_memcpy_method ();
9812                                                 mono_emit_method_call (cfg, memcpy_method, iargs, NULL);
9813                                         } else {
9814                                                 MonoMethod *memset_method = get_memset_method ();
9815                                                 mono_emit_method_call (cfg, memset_method, iargs, NULL);
9816                                         }
9817                                 }
9818                                 ip += 2;
9819                                 inline_costs += 1;
9820                                 break;
9821                         }
9822                         case CEE_NO_:
9823                                 CHECK_OPSIZE (3);
9824                                 if (ip [2] & 0x1)
9825                                         ins_flag |= MONO_INST_NOTYPECHECK;
9826                                 if (ip [2] & 0x2)
9827                                         ins_flag |= MONO_INST_NORANGECHECK;
9828                                 /* we ignore the no-nullcheck for now since we
9829                                  * really do it explicitly only when doing callvirt->call
9830                                  */
9831                                 ip += 3;
9832                                 break;
9833                         case CEE_RETHROW: {
9834                                 MonoInst *load;
9835                                 int handler_offset = -1;
9836
9837                                 for (i = 0; i < header->num_clauses; ++i) {
9838                                         MonoExceptionClause *clause = &header->clauses [i];
9839                                         if (MONO_OFFSET_IN_HANDLER (clause, ip - header->code) && !(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
9840                                                 handler_offset = clause->handler_offset;
9841                                                 break;
9842                                         }
9843                                 }
9844
9845                                 bblock->flags |= BB_EXCEPTION_UNSAFE;
9846
9847                                 g_assert (handler_offset != -1);
9848
9849                                 EMIT_NEW_TEMPLOAD (cfg, load, mono_find_exvar_for_offset (cfg, handler_offset)->inst_c0);
9850                                 MONO_INST_NEW (cfg, ins, OP_RETHROW);
9851                                 ins->sreg1 = load->dreg;
9852                                 MONO_ADD_INS (bblock, ins);
9853
9854                                 MONO_INST_NEW (cfg, ins, OP_NOT_REACHED);
9855                                 MONO_ADD_INS (bblock, ins);
9856
9857                                 sp = stack_start;
9858                                 link_bblock (cfg, bblock, end_bblock);
9859                                 start_new_bblock = 1;
9860                                 ip += 2;
9861                                 break;
9862                         }
9863                         case CEE_SIZEOF: {
9864                                 guint32 align;
9865                                 int ialign;
9866
9867                                 CHECK_STACK_OVF (1);
9868                                 CHECK_OPSIZE (6);
9869                                 token = read32 (ip + 2);
9870                                 if (mono_metadata_token_table (token) == MONO_TABLE_TYPESPEC && !method->klass->image->dynamic) {
9871                                         MonoType *type = mono_type_create_from_typespec (image, token);
9872                                         token = mono_type_size (type, &ialign);
9873                                 } else {
9874                                         MonoClass *klass = mono_class_get_full (image, token, generic_context);
9875                                         CHECK_TYPELOAD (klass);
9876                                         mono_class_init (klass);
9877                                         token = mono_class_value_size (klass, &align);
9878                                 }
9879                                 EMIT_NEW_ICONST (cfg, ins, token);
9880                                 *sp++= ins;
9881                                 ip += 6;
9882                                 break;
9883                         }
9884                         case CEE_REFANYTYPE: {
9885                                 MonoInst *src_var, *src;
9886
9887                                 CHECK_STACK (1);
9888                                 --sp;
9889
9890                                 // FIXME:
9891                                 src_var = get_vreg_to_inst (cfg, sp [0]->dreg);
9892                                 if (!src_var)
9893                                         src_var = mono_compile_create_var_for_vreg (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL, sp [0]->dreg);
9894                                 EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype);
9895                                 EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &mono_defaults.typehandle_class->byval_arg, src->dreg, G_STRUCT_OFFSET (MonoTypedRef, type));
9896                                 *sp++ = ins;
9897                                 ip += 2;
9898                                 break;
9899                         }
9900                         case CEE_READONLY_:
9901                                 readonly = TRUE;
9902                                 ip += 2;
9903                                 break;
9904
9905                         case CEE_UNUSED56:
9906                         case CEE_UNUSED57:
9907                         case CEE_UNUSED70:
9908                         case CEE_UNUSED:
9909                         case CEE_UNUSED99:
9910                                 UNVERIFIED;
9911
9912                         default:
9913                                 g_warning ("opcode 0xfe 0x%02x not handled", ip [1]);
9914                                 UNVERIFIED;
9915                         }
9916                         break;
9917                 }
9918                 case CEE_UNUSED58:
9919                 case CEE_UNUSED1:
9920                         UNVERIFIED;
9921
9922                 default:
9923                         g_warning ("opcode 0x%02x not handled", *ip);
9924                         UNVERIFIED;
9925                 }
9926         }
9927         if (start_new_bblock != 1)
9928                 UNVERIFIED;
9929
9930         bblock->cil_length = ip - bblock->cil_code;
9931         bblock->next_bb = end_bblock;
9932
9933         if (cfg->method == method && cfg->domainvar) {
9934                 MonoInst *store;
9935                 MonoInst *get_domain;
9936
9937                 cfg->cbb = init_localsbb;
9938
9939                 if (! (get_domain = mono_arch_get_domain_intrinsic (cfg))) {
9940                         get_domain = mono_emit_jit_icall (cfg, mono_domain_get, NULL);
9941                 }
9942                 else {
9943                         get_domain->dreg = alloc_preg (cfg);
9944                         MONO_ADD_INS (cfg->cbb, get_domain);
9945                 }
9946                 NEW_TEMPSTORE (cfg, store, cfg->domainvar->inst_c0, get_domain);
9947                 MONO_ADD_INS (cfg->cbb, store);
9948         }
9949
9950 #if defined(TARGET_POWERPC) || defined(TARGET_X86)
9951         if (cfg->compile_aot)
9952                 /* FIXME: The plt slots require a GOT var even if the method doesn't use it */
9953                 mono_get_got_var (cfg);
9954 #endif
9955
9956         if (cfg->method == method && cfg->got_var)
9957                 mono_emit_load_got_addr (cfg);
9958
9959         if (init_locals) {
9960                 MonoInst *store;
9961
9962                 cfg->cbb = init_localsbb;
9963                 cfg->ip = NULL;
9964                 for (i = 0; i < header->num_locals; ++i) {
9965                         MonoType *ptype = header->locals [i];
9966                         int t = ptype->type;
9967                         dreg = cfg->locals [i]->dreg;
9968
9969                         if (t == MONO_TYPE_VALUETYPE && ptype->data.klass->enumtype)
9970                                 t = mono_class_enum_basetype (ptype->data.klass)->type;
9971                         if (ptype->byref) {
9972                                 MONO_EMIT_NEW_PCONST (cfg, dreg, NULL);
9973                         } else if (t >= MONO_TYPE_BOOLEAN && t <= MONO_TYPE_U4) {
9974                                 MONO_EMIT_NEW_ICONST (cfg, cfg->locals [i]->dreg, 0);
9975                         } else if (t == MONO_TYPE_I8 || t == MONO_TYPE_U8) {
9976                                 MONO_EMIT_NEW_I8CONST (cfg, cfg->locals [i]->dreg, 0);
9977                         } else if (t == MONO_TYPE_R4 || t == MONO_TYPE_R8) {
9978                                 MONO_INST_NEW (cfg, ins, OP_R8CONST);
9979                                 ins->type = STACK_R8;
9980                                 ins->inst_p0 = (void*)&r8_0;
9981                                 ins->dreg = alloc_dreg (cfg, STACK_R8);
9982                                 MONO_ADD_INS (init_localsbb, ins);
9983                                 EMIT_NEW_LOCSTORE (cfg, store, i, ins);
9984                         } else if ((t == MONO_TYPE_VALUETYPE) || (t == MONO_TYPE_TYPEDBYREF) ||
9985                                    ((t == MONO_TYPE_GENERICINST) && mono_type_generic_inst_is_valuetype (ptype))) {
9986                                 MONO_EMIT_NEW_VZERO (cfg, dreg, mono_class_from_mono_type (ptype));
9987                         } else {
9988                                 MONO_EMIT_NEW_PCONST (cfg, dreg, NULL);
9989                         }
9990                 }
9991         }
9992
9993         if (cfg->init_ref_vars && cfg->method == method) {
9994                 /* Emit initialization for ref vars */
9995                 // FIXME: Avoid duplication initialization for IL locals.
9996                 for (i = 0; i < cfg->num_varinfo; ++i) {
9997                         MonoInst *ins = cfg->varinfo [i];
9998
9999                         if (ins->opcode == OP_LOCAL && ins->type == STACK_OBJ)
10000                                 MONO_EMIT_NEW_PCONST (cfg, ins->dreg, NULL);
10001                 }
10002         }
10003
10004         /* Add a sequence point for method entry/exit events */
10005         if (seq_points) {
10006                 NEW_SEQ_POINT (cfg, ins, METHOD_ENTRY_IL_OFFSET, FALSE);
10007                 MONO_ADD_INS (init_localsbb, ins);
10008                 NEW_SEQ_POINT (cfg, ins, METHOD_EXIT_IL_OFFSET, FALSE);
10009                 MONO_ADD_INS (cfg->bb_exit, ins);
10010         }
10011
10012         cfg->ip = NULL;
10013
10014         if (cfg->method == method) {
10015                 MonoBasicBlock *bb;
10016                 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
10017                         bb->region = mono_find_block_region (cfg, bb->real_offset);
10018                         if (cfg->spvars)
10019                                 mono_create_spvar_for_region (cfg, bb->region);
10020                         if (cfg->verbose_level > 2)
10021                                 printf ("REGION BB%d IL_%04x ID_%08X\n", bb->block_num, bb->real_offset, bb->region);
10022                 }
10023         }
10024
10025         g_slist_free (class_inits);
10026         dont_inline = g_list_remove (dont_inline, method);
10027
10028         if (inline_costs < 0) {
10029                 char *mname;
10030
10031                 /* Method is too large */
10032                 mname = mono_method_full_name (method, TRUE);
10033                 cfg->exception_type = MONO_EXCEPTION_INVALID_PROGRAM;
10034                 cfg->exception_message = g_strdup_printf ("Method %s is too complex.", mname);
10035                 g_free (mname);
10036                 cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
10037                 mono_basic_block_free (original_bb);
10038                 return -1;
10039         }
10040
10041         if ((cfg->verbose_level > 2) && (cfg->method == method))
10042                 mono_print_code (cfg, "AFTER METHOD-TO-IR");
10043
10044         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
10045         mono_basic_block_free (original_bb);
10046         return inline_costs;
10047
10048  exception_exit:
10049         g_assert (cfg->exception_type != MONO_EXCEPTION_NONE);
10050         goto cleanup;
10051
10052  inline_failure:
10053         goto cleanup;
10054
10055  load_error:
10056         cfg->exception_type = MONO_EXCEPTION_TYPE_LOAD;
10057         goto cleanup;
10058
10059  unverified:
10060         set_exception_type_from_invalid_il (cfg, method, ip);
10061         goto cleanup;
10062
10063  cleanup:
10064         g_slist_free (class_inits);
10065         mono_basic_block_free (original_bb);
10066         dont_inline = g_list_remove (dont_inline, method);
10067         cfg->headers_to_free = g_slist_prepend_mempool (cfg->mempool, cfg->headers_to_free, header);
10068         return -1;
10069 }
10070
10071 static int
10072 store_membase_reg_to_store_membase_imm (int opcode)
10073 {
10074         switch (opcode) {
10075         case OP_STORE_MEMBASE_REG:
10076                 return OP_STORE_MEMBASE_IMM;
10077         case OP_STOREI1_MEMBASE_REG:
10078                 return OP_STOREI1_MEMBASE_IMM;
10079         case OP_STOREI2_MEMBASE_REG:
10080                 return OP_STOREI2_MEMBASE_IMM;
10081         case OP_STOREI4_MEMBASE_REG:
10082                 return OP_STOREI4_MEMBASE_IMM;
10083         case OP_STOREI8_MEMBASE_REG:
10084                 return OP_STOREI8_MEMBASE_IMM;
10085         default:
10086                 g_assert_not_reached ();
10087         }
10088
10089         return -1;
10090 }
10091
10092 #endif /* DISABLE_JIT */
10093
10094 int
10095 mono_op_to_op_imm (int opcode)
10096 {
10097         switch (opcode) {
10098         case OP_IADD:
10099                 return OP_IADD_IMM;
10100         case OP_ISUB:
10101                 return OP_ISUB_IMM;
10102         case OP_IDIV:
10103                 return OP_IDIV_IMM;
10104         case OP_IDIV_UN:
10105                 return OP_IDIV_UN_IMM;
10106         case OP_IREM:
10107                 return OP_IREM_IMM;
10108         case OP_IREM_UN:
10109                 return OP_IREM_UN_IMM;
10110         case OP_IMUL:
10111                 return OP_IMUL_IMM;
10112         case OP_IAND:
10113                 return OP_IAND_IMM;
10114         case OP_IOR:
10115                 return OP_IOR_IMM;
10116         case OP_IXOR:
10117                 return OP_IXOR_IMM;
10118         case OP_ISHL:
10119                 return OP_ISHL_IMM;
10120         case OP_ISHR:
10121                 return OP_ISHR_IMM;
10122         case OP_ISHR_UN:
10123                 return OP_ISHR_UN_IMM;
10124
10125         case OP_LADD:
10126                 return OP_LADD_IMM;
10127         case OP_LSUB:
10128                 return OP_LSUB_IMM;
10129         case OP_LAND:
10130                 return OP_LAND_IMM;
10131         case OP_LOR:
10132                 return OP_LOR_IMM;
10133         case OP_LXOR:
10134                 return OP_LXOR_IMM;
10135         case OP_LSHL:
10136                 return OP_LSHL_IMM;
10137         case OP_LSHR:
10138                 return OP_LSHR_IMM;
10139         case OP_LSHR_UN:
10140                 return OP_LSHR_UN_IMM;
10141
10142         case OP_COMPARE:
10143                 return OP_COMPARE_IMM;
10144         case OP_ICOMPARE:
10145                 return OP_ICOMPARE_IMM;
10146         case OP_LCOMPARE:
10147                 return OP_LCOMPARE_IMM;
10148
10149         case OP_STORE_MEMBASE_REG:
10150                 return OP_STORE_MEMBASE_IMM;
10151         case OP_STOREI1_MEMBASE_REG:
10152                 return OP_STOREI1_MEMBASE_IMM;
10153         case OP_STOREI2_MEMBASE_REG:
10154                 return OP_STOREI2_MEMBASE_IMM;
10155         case OP_STOREI4_MEMBASE_REG:
10156                 return OP_STOREI4_MEMBASE_IMM;
10157
10158 #if defined(TARGET_X86) || defined (TARGET_AMD64)
10159         case OP_X86_PUSH:
10160                 return OP_X86_PUSH_IMM;
10161         case OP_X86_COMPARE_MEMBASE_REG:
10162                 return OP_X86_COMPARE_MEMBASE_IMM;
10163 #endif
10164 #if defined(TARGET_AMD64)
10165         case OP_AMD64_ICOMPARE_MEMBASE_REG:
10166                 return OP_AMD64_ICOMPARE_MEMBASE_IMM;
10167 #endif
10168         case OP_VOIDCALL_REG:
10169                 return OP_VOIDCALL;
10170         case OP_CALL_REG:
10171                 return OP_CALL;
10172         case OP_LCALL_REG:
10173                 return OP_LCALL;
10174         case OP_FCALL_REG:
10175                 return OP_FCALL;
10176         case OP_LOCALLOC:
10177                 return OP_LOCALLOC_IMM;
10178         }
10179
10180         return -1;
10181 }
10182
10183 static int
10184 ldind_to_load_membase (int opcode)
10185 {
10186         switch (opcode) {
10187         case CEE_LDIND_I1:
10188                 return OP_LOADI1_MEMBASE;
10189         case CEE_LDIND_U1:
10190                 return OP_LOADU1_MEMBASE;
10191         case CEE_LDIND_I2:
10192                 return OP_LOADI2_MEMBASE;
10193         case CEE_LDIND_U2:
10194                 return OP_LOADU2_MEMBASE;
10195         case CEE_LDIND_I4:
10196                 return OP_LOADI4_MEMBASE;
10197         case CEE_LDIND_U4:
10198                 return OP_LOADU4_MEMBASE;
10199         case CEE_LDIND_I:
10200                 return OP_LOAD_MEMBASE;
10201         case CEE_LDIND_REF:
10202                 return OP_LOAD_MEMBASE;
10203         case CEE_LDIND_I8:
10204                 return OP_LOADI8_MEMBASE;
10205         case CEE_LDIND_R4:
10206                 return OP_LOADR4_MEMBASE;
10207         case CEE_LDIND_R8:
10208                 return OP_LOADR8_MEMBASE;
10209         default:
10210                 g_assert_not_reached ();
10211         }
10212
10213         return -1;
10214 }
10215
10216 static int
10217 stind_to_store_membase (int opcode)
10218 {
10219         switch (opcode) {
10220         case CEE_STIND_I1:
10221                 return OP_STOREI1_MEMBASE_REG;
10222         case CEE_STIND_I2:
10223                 return OP_STOREI2_MEMBASE_REG;
10224         case CEE_STIND_I4:
10225                 return OP_STOREI4_MEMBASE_REG;
10226         case CEE_STIND_I:
10227         case CEE_STIND_REF:
10228                 return OP_STORE_MEMBASE_REG;
10229         case CEE_STIND_I8:
10230                 return OP_STOREI8_MEMBASE_REG;
10231         case CEE_STIND_R4:
10232                 return OP_STORER4_MEMBASE_REG;
10233         case CEE_STIND_R8:
10234                 return OP_STORER8_MEMBASE_REG;
10235         default:
10236                 g_assert_not_reached ();
10237         }
10238
10239         return -1;
10240 }
10241
10242 int
10243 mono_load_membase_to_load_mem (int opcode)
10244 {
10245         // FIXME: Add a MONO_ARCH_HAVE_LOAD_MEM macro
10246 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10247         switch (opcode) {
10248         case OP_LOAD_MEMBASE:
10249                 return OP_LOAD_MEM;
10250         case OP_LOADU1_MEMBASE:
10251                 return OP_LOADU1_MEM;
10252         case OP_LOADU2_MEMBASE:
10253                 return OP_LOADU2_MEM;
10254         case OP_LOADI4_MEMBASE:
10255                 return OP_LOADI4_MEM;
10256         case OP_LOADU4_MEMBASE:
10257                 return OP_LOADU4_MEM;
10258 #if SIZEOF_REGISTER == 8
10259         case OP_LOADI8_MEMBASE:
10260                 return OP_LOADI8_MEM;
10261 #endif
10262         }
10263 #endif
10264
10265         return -1;
10266 }
10267
10268 static inline int
10269 op_to_op_dest_membase (int store_opcode, int opcode)
10270 {
10271 #if defined(TARGET_X86)
10272         if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG)))
10273                 return -1;
10274
10275         switch (opcode) {
10276         case OP_IADD:
10277                 return OP_X86_ADD_MEMBASE_REG;
10278         case OP_ISUB:
10279                 return OP_X86_SUB_MEMBASE_REG;
10280         case OP_IAND:
10281                 return OP_X86_AND_MEMBASE_REG;
10282         case OP_IOR:
10283                 return OP_X86_OR_MEMBASE_REG;
10284         case OP_IXOR:
10285                 return OP_X86_XOR_MEMBASE_REG;
10286         case OP_ADD_IMM:
10287         case OP_IADD_IMM:
10288                 return OP_X86_ADD_MEMBASE_IMM;
10289         case OP_SUB_IMM:
10290         case OP_ISUB_IMM:
10291                 return OP_X86_SUB_MEMBASE_IMM;
10292         case OP_AND_IMM:
10293         case OP_IAND_IMM:
10294                 return OP_X86_AND_MEMBASE_IMM;
10295         case OP_OR_IMM:
10296         case OP_IOR_IMM:
10297                 return OP_X86_OR_MEMBASE_IMM;
10298         case OP_XOR_IMM:
10299         case OP_IXOR_IMM:
10300                 return OP_X86_XOR_MEMBASE_IMM;
10301         case OP_MOVE:
10302                 return OP_NOP;
10303         }
10304 #endif
10305
10306 #if defined(TARGET_AMD64)
10307         if (!((store_opcode == OP_STORE_MEMBASE_REG) || (store_opcode == OP_STOREI4_MEMBASE_REG) || (store_opcode == OP_STOREI8_MEMBASE_REG)))
10308                 return -1;
10309
10310         switch (opcode) {
10311         case OP_IADD:
10312                 return OP_X86_ADD_MEMBASE_REG;
10313         case OP_ISUB:
10314                 return OP_X86_SUB_MEMBASE_REG;
10315         case OP_IAND:
10316                 return OP_X86_AND_MEMBASE_REG;
10317         case OP_IOR:
10318                 return OP_X86_OR_MEMBASE_REG;
10319         case OP_IXOR:
10320                 return OP_X86_XOR_MEMBASE_REG;
10321         case OP_IADD_IMM:
10322                 return OP_X86_ADD_MEMBASE_IMM;
10323         case OP_ISUB_IMM:
10324                 return OP_X86_SUB_MEMBASE_IMM;
10325         case OP_IAND_IMM:
10326                 return OP_X86_AND_MEMBASE_IMM;
10327         case OP_IOR_IMM:
10328                 return OP_X86_OR_MEMBASE_IMM;
10329         case OP_IXOR_IMM:
10330                 return OP_X86_XOR_MEMBASE_IMM;
10331         case OP_LADD:
10332                 return OP_AMD64_ADD_MEMBASE_REG;
10333         case OP_LSUB:
10334                 return OP_AMD64_SUB_MEMBASE_REG;
10335         case OP_LAND:
10336                 return OP_AMD64_AND_MEMBASE_REG;
10337         case OP_LOR:
10338                 return OP_AMD64_OR_MEMBASE_REG;
10339         case OP_LXOR:
10340                 return OP_AMD64_XOR_MEMBASE_REG;
10341         case OP_ADD_IMM:
10342         case OP_LADD_IMM:
10343                 return OP_AMD64_ADD_MEMBASE_IMM;
10344         case OP_SUB_IMM:
10345         case OP_LSUB_IMM:
10346                 return OP_AMD64_SUB_MEMBASE_IMM;
10347         case OP_AND_IMM:
10348         case OP_LAND_IMM:
10349                 return OP_AMD64_AND_MEMBASE_IMM;
10350         case OP_OR_IMM:
10351         case OP_LOR_IMM:
10352                 return OP_AMD64_OR_MEMBASE_IMM;
10353         case OP_XOR_IMM:
10354         case OP_LXOR_IMM:
10355                 return OP_AMD64_XOR_MEMBASE_IMM;
10356         case OP_MOVE:
10357                 return OP_NOP;
10358         }
10359 #endif
10360
10361         return -1;
10362 }
10363
10364 static inline int
10365 op_to_op_store_membase (int store_opcode, int opcode)
10366 {
10367 #if defined(TARGET_X86) || defined(TARGET_AMD64)
10368         switch (opcode) {
10369         case OP_ICEQ:
10370                 if (store_opcode == OP_STOREI1_MEMBASE_REG)
10371                         return OP_X86_SETEQ_MEMBASE;
10372         case OP_CNE:
10373                 if (store_opcode == OP_STOREI1_MEMBASE_REG)
10374                         return OP_X86_SETNE_MEMBASE;
10375         }
10376 #endif
10377
10378         return -1;
10379 }
10380
10381 static inline int
10382 op_to_op_src1_membase (int load_opcode, int opcode)
10383 {
10384 #ifdef TARGET_X86
10385         /* FIXME: This has sign extension issues */
10386         /*
10387         if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10388                 return OP_X86_COMPARE_MEMBASE8_IMM;
10389         */
10390
10391         if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10392                 return -1;
10393
10394         switch (opcode) {
10395         case OP_X86_PUSH:
10396                 return OP_X86_PUSH_MEMBASE;
10397         case OP_COMPARE_IMM:
10398         case OP_ICOMPARE_IMM:
10399                 return OP_X86_COMPARE_MEMBASE_IMM;
10400         case OP_COMPARE:
10401         case OP_ICOMPARE:
10402                 return OP_X86_COMPARE_MEMBASE_REG;
10403         }
10404 #endif
10405
10406 #ifdef TARGET_AMD64
10407         /* FIXME: This has sign extension issues */
10408         /*
10409         if ((opcode == OP_ICOMPARE_IMM) && (load_opcode == OP_LOADU1_MEMBASE))
10410                 return OP_X86_COMPARE_MEMBASE8_IMM;
10411         */
10412
10413         switch (opcode) {
10414         case OP_X86_PUSH:
10415                 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10416                         return OP_X86_PUSH_MEMBASE;
10417                 break;
10418                 /* FIXME: This only works for 32 bit immediates
10419         case OP_COMPARE_IMM:
10420         case OP_LCOMPARE_IMM:
10421                 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10422                         return OP_AMD64_COMPARE_MEMBASE_IMM;
10423                 */
10424         case OP_ICOMPARE_IMM:
10425                 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE))
10426                         return OP_AMD64_ICOMPARE_MEMBASE_IMM;
10427                 break;
10428         case OP_COMPARE:
10429         case OP_LCOMPARE:
10430                 if ((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI8_MEMBASE))
10431                         return OP_AMD64_COMPARE_MEMBASE_REG;
10432                 break;
10433         case OP_ICOMPARE:
10434                 if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE))
10435                         return OP_AMD64_ICOMPARE_MEMBASE_REG;
10436                 break;
10437         }
10438 #endif
10439
10440         return -1;
10441 }
10442
10443 static inline int
10444 op_to_op_src2_membase (int load_opcode, int opcode)
10445 {
10446 #ifdef TARGET_X86
10447         if (!((load_opcode == OP_LOAD_MEMBASE) || (load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)))
10448                 return -1;
10449
10450         switch (opcode) {
10451         case OP_COMPARE:
10452         case OP_ICOMPARE:
10453                 return OP_X86_COMPARE_REG_MEMBASE;
10454         case OP_IADD:
10455                 return OP_X86_ADD_REG_MEMBASE;
10456         case OP_ISUB:
10457                 return OP_X86_SUB_REG_MEMBASE;
10458         case OP_IAND:
10459                 return OP_X86_AND_REG_MEMBASE;
10460         case OP_IOR:
10461                 return OP_X86_OR_REG_MEMBASE;
10462         case OP_IXOR:
10463                 return OP_X86_XOR_REG_MEMBASE;
10464         }
10465 #endif
10466
10467 #ifdef TARGET_AMD64
10468         if ((load_opcode == OP_LOADI4_MEMBASE) || (load_opcode == OP_LOADU4_MEMBASE)) {
10469                 switch (opcode) {
10470                 case OP_ICOMPARE:
10471                         return OP_AMD64_ICOMPARE_REG_MEMBASE;
10472                 case OP_IADD:
10473                         return OP_X86_ADD_REG_MEMBASE;
10474                 case OP_ISUB:
10475                         return OP_X86_SUB_REG_MEMBASE;
10476                 case OP_IAND:
10477                         return OP_X86_AND_REG_MEMBASE;
10478                 case OP_IOR:
10479                         return OP_X86_OR_REG_MEMBASE;
10480                 case OP_IXOR:
10481                         return OP_X86_XOR_REG_MEMBASE;
10482                 }
10483         } else if ((load_opcode == OP_LOADI8_MEMBASE) || (load_opcode == OP_LOAD_MEMBASE)) {
10484                 switch (opcode) {
10485                 case OP_COMPARE:
10486                 case OP_LCOMPARE:
10487                         return OP_AMD64_COMPARE_REG_MEMBASE;
10488                 case OP_LADD:
10489                         return OP_AMD64_ADD_REG_MEMBASE;
10490                 case OP_LSUB:
10491                         return OP_AMD64_SUB_REG_MEMBASE;
10492                 case OP_LAND:
10493                         return OP_AMD64_AND_REG_MEMBASE;
10494                 case OP_LOR:
10495                         return OP_AMD64_OR_REG_MEMBASE;
10496                 case OP_LXOR:
10497                         return OP_AMD64_XOR_REG_MEMBASE;
10498                 }
10499         }
10500 #endif
10501
10502         return -1;
10503 }
10504
10505 int
10506 mono_op_to_op_imm_noemul (int opcode)
10507 {
10508         switch (opcode) {
10509 #if SIZEOF_REGISTER == 4 && !defined(MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS)
10510         case OP_LSHR:
10511         case OP_LSHL:
10512         case OP_LSHR_UN:
10513                 return -1;
10514 #endif
10515 #if defined(MONO_ARCH_EMULATE_MUL_DIV) || defined(MONO_ARCH_EMULATE_DIV)
10516         case OP_IDIV:
10517         case OP_IDIV_UN:
10518         case OP_IREM:
10519         case OP_IREM_UN:
10520                 return -1;
10521 #endif
10522         default:
10523                 return mono_op_to_op_imm (opcode);
10524         }
10525 }
10526
10527 #ifndef DISABLE_JIT
10528
10529 /**
10530  * mono_handle_global_vregs:
10531  *
10532  *   Make vregs used in more than one bblock 'global', i.e. allocate a variable
10533  * for them.
10534  */
10535 void
10536 mono_handle_global_vregs (MonoCompile *cfg)
10537 {
10538         gint32 *vreg_to_bb;
10539         MonoBasicBlock *bb;
10540         int i, pos;
10541
10542         vreg_to_bb = mono_mempool_alloc0 (cfg->mempool, sizeof (gint32*) * cfg->next_vreg + 1);
10543
10544 #ifdef MONO_ARCH_SIMD_INTRINSICS
10545         if (cfg->uses_simd_intrinsics)
10546                 mono_simd_simplify_indirection (cfg);
10547 #endif
10548
10549         /* Find local vregs used in more than one bb */
10550         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
10551                 MonoInst *ins = bb->code;
10552                 int block_num = bb->block_num;
10553
10554                 if (cfg->verbose_level > 2)
10555                         printf ("\nHANDLE-GLOBAL-VREGS BLOCK %d:\n", bb->block_num);
10556
10557                 cfg->cbb = bb;
10558                 for (; ins; ins = ins->next) {
10559                         const char *spec = INS_INFO (ins->opcode);
10560                         int regtype = 0, regindex;
10561                         gint32 prev_bb;
10562
10563                         if (G_UNLIKELY (cfg->verbose_level > 2))
10564                                 mono_print_ins (ins);
10565
10566                         g_assert (ins->opcode >= MONO_CEE_LAST);
10567
10568                         for (regindex = 0; regindex < 4; regindex ++) {
10569                                 int vreg = 0;
10570
10571                                 if (regindex == 0) {
10572                                         regtype = spec [MONO_INST_DEST];
10573                                         if (regtype == ' ')
10574                                                 continue;
10575                                         vreg = ins->dreg;
10576                                 } else if (regindex == 1) {
10577                                         regtype = spec [MONO_INST_SRC1];
10578                                         if (regtype == ' ')
10579                                                 continue;
10580                                         vreg = ins->sreg1;
10581                                 } else if (regindex == 2) {
10582                                         regtype = spec [MONO_INST_SRC2];
10583                                         if (regtype == ' ')
10584                                                 continue;
10585                                         vreg = ins->sreg2;
10586                                 } else if (regindex == 3) {
10587                                         regtype = spec [MONO_INST_SRC3];
10588                                         if (regtype == ' ')
10589                                                 continue;
10590                                         vreg = ins->sreg3;
10591                                 }
10592
10593 #if SIZEOF_REGISTER == 4
10594                                 /* In the LLVM case, the long opcodes are not decomposed */
10595                                 if (regtype == 'l' && !COMPILE_LLVM (cfg)) {
10596                                         /*
10597                                          * Since some instructions reference the original long vreg,
10598                                          * and some reference the two component vregs, it is quite hard
10599                                          * to determine when it needs to be global. So be conservative.
10600                                          */
10601                                         if (!get_vreg_to_inst (cfg, vreg)) {
10602                                                 mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10603
10604                                                 if (cfg->verbose_level > 2)
10605                                                         printf ("LONG VREG R%d made global.\n", vreg);
10606                                         }
10607
10608                                         /*
10609                                          * Make the component vregs volatile since the optimizations can
10610                                          * get confused otherwise.
10611                                          */
10612                                         get_vreg_to_inst (cfg, vreg + 1)->flags |= MONO_INST_VOLATILE;
10613                                         get_vreg_to_inst (cfg, vreg + 2)->flags |= MONO_INST_VOLATILE;
10614                                 }
10615 #endif
10616
10617                                 g_assert (vreg != -1);
10618
10619                                 prev_bb = vreg_to_bb [vreg];
10620                                 if (prev_bb == 0) {
10621                                         /* 0 is a valid block num */
10622                                         vreg_to_bb [vreg] = block_num + 1;
10623                                 } else if ((prev_bb != block_num + 1) && (prev_bb != -1)) {
10624                                         if (((regtype == 'i' && (vreg < MONO_MAX_IREGS))) || (regtype == 'f' && (vreg < MONO_MAX_FREGS)))
10625                                                 continue;
10626
10627                                         if (!get_vreg_to_inst (cfg, vreg)) {
10628                                                 if (G_UNLIKELY (cfg->verbose_level > 2))
10629                                                         printf ("VREG R%d used in BB%d and BB%d made global.\n", vreg, vreg_to_bb [vreg], block_num);
10630
10631                                                 switch (regtype) {
10632                                                 case 'i':
10633                                                         mono_compile_create_var_for_vreg (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL, vreg);
10634                                                         break;
10635                                                 case 'l':
10636                                                         mono_compile_create_var_for_vreg (cfg, &mono_defaults.int64_class->byval_arg, OP_LOCAL, vreg);
10637                                                         break;
10638                                                 case 'f':
10639                                                         mono_compile_create_var_for_vreg (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL, vreg);
10640                                                         break;
10641                                                 case 'v':
10642                                                         mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, vreg);
10643                                                         break;
10644                                                 default:
10645                                                         g_assert_not_reached ();
10646                                                 }
10647                                         }
10648
10649                                         /* Flag as having been used in more than one bb */
10650                                         vreg_to_bb [vreg] = -1;
10651                                 }
10652                         }
10653                 }
10654         }
10655
10656         /* If a variable is used in only one bblock, convert it into a local vreg */
10657         for (i = 0; i < cfg->num_varinfo; i++) {
10658                 MonoInst *var = cfg->varinfo [i];
10659                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
10660
10661                 switch (var->type) {
10662                 case STACK_I4:
10663                 case STACK_OBJ:
10664                 case STACK_PTR:
10665                 case STACK_MP:
10666                 case STACK_VTYPE:
10667 #if SIZEOF_REGISTER == 8
10668                 case STACK_I8:
10669 #endif
10670 #if !defined(TARGET_X86) && !defined(MONO_ARCH_SOFT_FLOAT)
10671                 /* Enabling this screws up the fp stack on x86 */
10672                 case STACK_R8:
10673 #endif
10674                         /* Arguments are implicitly global */
10675                         /* Putting R4 vars into registers doesn't work currently */
10676                         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) {
10677                                 /*
10678                                  * Make that the variable's liveness interval doesn't contain a call, since
10679                                  * that would cause the lvreg to be spilled, making the whole optimization
10680                                  * useless.
10681                                  */
10682                                 /* This is too slow for JIT compilation */
10683 #if 0
10684                                 if (cfg->compile_aot && vreg_to_bb [var->dreg]) {
10685                                         MonoInst *ins;
10686                                         int def_index, call_index, ins_index;
10687                                         gboolean spilled = FALSE;
10688
10689                                         def_index = -1;
10690                                         call_index = -1;
10691                                         ins_index = 0;
10692                                         for (ins = vreg_to_bb [var->dreg]->code; ins; ins = ins->next) {
10693                                                 const char *spec = INS_INFO (ins->opcode);
10694
10695                                                 if ((spec [MONO_INST_DEST] != ' ') && (ins->dreg == var->dreg))
10696                                                         def_index = ins_index;
10697
10698                                                 if (((spec [MONO_INST_SRC1] != ' ') && (ins->sreg1 == var->dreg)) ||
10699                                                         ((spec [MONO_INST_SRC1] != ' ') && (ins->sreg1 == var->dreg))) {
10700                                                         if (call_index > def_index) {
10701                                                                 spilled = TRUE;
10702                                                                 break;
10703                                                         }
10704                                                 }
10705
10706                                                 if (MONO_IS_CALL (ins))
10707                                                         call_index = ins_index;
10708
10709                                                 ins_index ++;
10710                                         }
10711
10712                                         if (spilled)
10713                                                 break;
10714                                 }
10715 #endif
10716
10717                                 if (G_UNLIKELY (cfg->verbose_level > 2))
10718                                         printf ("CONVERTED R%d(%d) TO VREG.\n", var->dreg, vmv->idx);
10719                                 var->flags |= MONO_INST_IS_DEAD;
10720                                 cfg->vreg_to_inst [var->dreg] = NULL;
10721                         }
10722                         break;
10723                 }
10724         }
10725
10726         /*
10727          * Compress the varinfo and vars tables so the liveness computation is faster and
10728          * takes up less space.
10729          */
10730         pos = 0;
10731         for (i = 0; i < cfg->num_varinfo; ++i) {
10732                 MonoInst *var = cfg->varinfo [i];
10733                 if (pos < i && cfg->locals_start == i)
10734                         cfg->locals_start = pos;
10735                 if (!(var->flags & MONO_INST_IS_DEAD)) {
10736                         if (pos < i) {
10737                                 cfg->varinfo [pos] = cfg->varinfo [i];
10738                                 cfg->varinfo [pos]->inst_c0 = pos;
10739                                 memcpy (&cfg->vars [pos], &cfg->vars [i], sizeof (MonoMethodVar));
10740                                 cfg->vars [pos].idx = pos;
10741 #if SIZEOF_REGISTER == 4
10742                                 if (cfg->varinfo [pos]->type == STACK_I8) {
10743                                         /* Modify the two component vars too */
10744                                         MonoInst *var1;
10745
10746                                         var1 = get_vreg_to_inst (cfg, cfg->varinfo [pos]->dreg + 1);
10747                                         var1->inst_c0 = pos;
10748                                         var1 = get_vreg_to_inst (cfg, cfg->varinfo [pos]->dreg + 2);
10749                                         var1->inst_c0 = pos;
10750                                 }
10751 #endif
10752                         }
10753                         pos ++;
10754                 }
10755         }
10756         cfg->num_varinfo = pos;
10757         if (cfg->locals_start > cfg->num_varinfo)
10758                 cfg->locals_start = cfg->num_varinfo;
10759 }
10760
10761 /**
10762  * mono_spill_global_vars:
10763  *
10764  *   Generate spill code for variables which are not allocated to registers,
10765  * and replace vregs with their allocated hregs. *need_local_opts is set to TRUE if
10766  * code is generated which could be optimized by the local optimization passes.
10767  */
10768 void
10769 mono_spill_global_vars (MonoCompile *cfg, gboolean *need_local_opts)
10770 {
10771         MonoBasicBlock *bb;
10772         char spec2 [16];
10773         int orig_next_vreg;
10774         guint32 *vreg_to_lvreg;
10775         guint32 *lvregs;
10776         guint32 i, lvregs_len;
10777         gboolean dest_has_lvreg = FALSE;
10778         guint32 stacktypes [128];
10779         MonoInst **live_range_start, **live_range_end;
10780         MonoBasicBlock **live_range_start_bb, **live_range_end_bb;
10781
10782         *need_local_opts = FALSE;
10783
10784         memset (spec2, 0, sizeof (spec2));
10785
10786         /* FIXME: Move this function to mini.c */
10787         stacktypes ['i'] = STACK_PTR;
10788         stacktypes ['l'] = STACK_I8;
10789         stacktypes ['f'] = STACK_R8;
10790 #ifdef MONO_ARCH_SIMD_INTRINSICS
10791         stacktypes ['x'] = STACK_VTYPE;
10792 #endif
10793
10794 #if SIZEOF_REGISTER == 4
10795         /* Create MonoInsts for longs */
10796         for (i = 0; i < cfg->num_varinfo; i++) {
10797                 MonoInst *ins = cfg->varinfo [i];
10798
10799                 if ((ins->opcode != OP_REGVAR) && !(ins->flags & MONO_INST_IS_DEAD)) {
10800                         switch (ins->type) {
10801                         case STACK_R8:
10802                         case STACK_I8: {
10803                                 MonoInst *tree;
10804
10805                                 if (ins->type == STACK_R8 && !COMPILE_SOFT_FLOAT (cfg))
10806                                         break;
10807
10808                                 g_assert (ins->opcode == OP_REGOFFSET);
10809
10810                                 tree = get_vreg_to_inst (cfg, ins->dreg + 1);
10811                                 g_assert (tree);
10812                                 tree->opcode = OP_REGOFFSET;
10813                                 tree->inst_basereg = ins->inst_basereg;
10814                                 tree->inst_offset = ins->inst_offset + MINI_LS_WORD_OFFSET;
10815
10816                                 tree = get_vreg_to_inst (cfg, ins->dreg + 2);
10817                                 g_assert (tree);
10818                                 tree->opcode = OP_REGOFFSET;
10819                                 tree->inst_basereg = ins->inst_basereg;
10820                                 tree->inst_offset = ins->inst_offset + MINI_MS_WORD_OFFSET;
10821                                 break;
10822                         }
10823                         default:
10824                                 break;
10825                         }
10826                 }
10827         }
10828 #endif
10829
10830         /* FIXME: widening and truncation */
10831
10832         /*
10833          * As an optimization, when a variable allocated to the stack is first loaded into
10834          * an lvreg, we will remember the lvreg and use it the next time instead of loading
10835          * the variable again.
10836          */
10837         orig_next_vreg = cfg->next_vreg;
10838         vreg_to_lvreg = mono_mempool_alloc0 (cfg->mempool, sizeof (guint32) * cfg->next_vreg);
10839         lvregs = mono_mempool_alloc (cfg->mempool, sizeof (guint32) * 1024);
10840         lvregs_len = 0;
10841
10842         /*
10843          * These arrays contain the first and last instructions accessing a given
10844          * variable.
10845          * Since we emit bblocks in the same order we process them here, and we
10846          * don't split live ranges, these will precisely describe the live range of
10847          * the variable, i.e. the instruction range where a valid value can be found
10848          * in the variables location.
10849          * The live range is computed using the liveness info computed by the liveness pass.
10850          * We can't use vmv->range, since that is an abstract live range, and we need
10851          * one which is instruction precise.
10852          * FIXME: Variables used in out-of-line bblocks have a hole in their live range.
10853          */
10854         /* FIXME: Only do this if debugging info is requested */
10855         live_range_start = g_new0 (MonoInst*, cfg->next_vreg);
10856         live_range_end = g_new0 (MonoInst*, cfg->next_vreg);
10857         live_range_start_bb = g_new (MonoBasicBlock*, cfg->next_vreg);
10858         live_range_end_bb = g_new (MonoBasicBlock*, cfg->next_vreg);
10859
10860         /* Add spill loads/stores */
10861         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
10862                 MonoInst *ins;
10863
10864                 if (cfg->verbose_level > 2)
10865                         printf ("\nSPILL BLOCK %d:\n", bb->block_num);
10866
10867                 /* Clear vreg_to_lvreg array */
10868                 for (i = 0; i < lvregs_len; i++)
10869                         vreg_to_lvreg [lvregs [i]] = 0;
10870                 lvregs_len = 0;
10871
10872                 cfg->cbb = bb;
10873                 MONO_BB_FOR_EACH_INS (bb, ins) {
10874                         const char *spec = INS_INFO (ins->opcode);
10875                         int regtype, srcindex, sreg, tmp_reg, prev_dreg, num_sregs;
10876                         gboolean store, no_lvreg;
10877                         int sregs [MONO_MAX_SRC_REGS];
10878
10879                         if (G_UNLIKELY (cfg->verbose_level > 2))
10880                                 mono_print_ins (ins);
10881
10882                         if (ins->opcode == OP_NOP)
10883                                 continue;
10884
10885                         /*
10886                          * We handle LDADDR here as well, since it can only be decomposed
10887                          * when variable addresses are known.
10888                          */
10889                         if (ins->opcode == OP_LDADDR) {
10890                                 MonoInst *var = ins->inst_p0;
10891
10892                                 if (var->opcode == OP_VTARG_ADDR) {
10893                                         /* Happens on SPARC/S390 where vtypes are passed by reference */
10894                                         MonoInst *vtaddr = var->inst_left;
10895                                         if (vtaddr->opcode == OP_REGVAR) {
10896                                                 ins->opcode = OP_MOVE;
10897                                                 ins->sreg1 = vtaddr->dreg;
10898                                         }
10899                                         else if (var->inst_left->opcode == OP_REGOFFSET) {
10900                                                 ins->opcode = OP_LOAD_MEMBASE;
10901                                                 ins->inst_basereg = vtaddr->inst_basereg;
10902                                                 ins->inst_offset = vtaddr->inst_offset;
10903                                         } else
10904                                                 NOT_IMPLEMENTED;
10905                                 } else {
10906                                         g_assert (var->opcode == OP_REGOFFSET);
10907
10908                                         ins->opcode = OP_ADD_IMM;
10909                                         ins->sreg1 = var->inst_basereg;
10910                                         ins->inst_imm = var->inst_offset;
10911                                 }
10912
10913                                 *need_local_opts = TRUE;
10914                                 spec = INS_INFO (ins->opcode);
10915                         }
10916
10917                         if (ins->opcode < MONO_CEE_LAST) {
10918                                 mono_print_ins (ins);
10919                                 g_assert_not_reached ();
10920                         }
10921
10922                         /*
10923                          * Store opcodes have destbasereg in the dreg, but in reality, it is an
10924                          * src register.
10925                          * FIXME:
10926                          */
10927                         if (MONO_IS_STORE_MEMBASE (ins)) {
10928                                 tmp_reg = ins->dreg;
10929                                 ins->dreg = ins->sreg2;
10930                                 ins->sreg2 = tmp_reg;
10931                                 store = TRUE;
10932
10933                                 spec2 [MONO_INST_DEST] = ' ';
10934                                 spec2 [MONO_INST_SRC1] = spec [MONO_INST_SRC1];
10935                                 spec2 [MONO_INST_SRC2] = spec [MONO_INST_DEST];
10936                                 spec2 [MONO_INST_SRC3] = ' ';
10937                                 spec = spec2;
10938                         } else if (MONO_IS_STORE_MEMINDEX (ins))
10939                                 g_assert_not_reached ();
10940                         else
10941                                 store = FALSE;
10942                         no_lvreg = FALSE;
10943
10944                         if (G_UNLIKELY (cfg->verbose_level > 2)) {
10945                                 printf ("\t %.3s %d", spec, ins->dreg);
10946                                 num_sregs = mono_inst_get_src_registers (ins, sregs);
10947                                 for (srcindex = 0; srcindex < 3; ++srcindex)
10948                                         printf (" %d", sregs [srcindex]);
10949                                 printf ("\n");
10950                         }
10951
10952                         /***************/
10953                         /*    DREG     */
10954                         /***************/
10955                         regtype = spec [MONO_INST_DEST];
10956                         g_assert (((ins->dreg == -1) && (regtype == ' ')) || ((ins->dreg != -1) && (regtype != ' ')));
10957                         prev_dreg = -1;
10958
10959                         if ((ins->dreg != -1) && get_vreg_to_inst (cfg, ins->dreg)) {
10960                                 MonoInst *var = get_vreg_to_inst (cfg, ins->dreg);
10961                                 MonoInst *store_ins;
10962                                 int store_opcode;
10963                                 MonoInst *def_ins = ins;
10964                                 int dreg = ins->dreg; /* The original vreg */
10965
10966                                 store_opcode = mono_type_to_store_membase (cfg, var->inst_vtype);
10967
10968                                 if (var->opcode == OP_REGVAR) {
10969                                         ins->dreg = var->dreg;
10970                                 } 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)) {
10971                                         /*
10972                                          * Instead of emitting a load+store, use a _membase opcode.
10973                                          */
10974                                         g_assert (var->opcode == OP_REGOFFSET);
10975                                         if (ins->opcode == OP_MOVE) {
10976                                                 NULLIFY_INS (ins);
10977                                                 def_ins = NULL;
10978                                         } else {
10979                                                 ins->opcode = op_to_op_dest_membase (store_opcode, ins->opcode);
10980                                                 ins->inst_basereg = var->inst_basereg;
10981                                                 ins->inst_offset = var->inst_offset;
10982                                                 ins->dreg = -1;
10983                                         }
10984                                         spec = INS_INFO (ins->opcode);
10985                                 } else {
10986                                         guint32 lvreg;
10987
10988                                         g_assert (var->opcode == OP_REGOFFSET);
10989
10990                                         prev_dreg = ins->dreg;
10991
10992                                         /* Invalidate any previous lvreg for this vreg */
10993                                         vreg_to_lvreg [ins->dreg] = 0;
10994
10995                                         lvreg = 0;
10996
10997                                         if (COMPILE_SOFT_FLOAT (cfg) && store_opcode == OP_STORER8_MEMBASE_REG) {
10998                                                 regtype = 'l';
10999                                                 store_opcode = OP_STOREI8_MEMBASE_REG;
11000                                         }
11001
11002                                         ins->dreg = alloc_dreg (cfg, stacktypes [regtype]);
11003
11004                                         if (regtype == 'l') {
11005                                                 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET, ins->dreg + 1);
11006                                                 mono_bblock_insert_after_ins (bb, ins, store_ins);
11007                                                 NEW_STORE_MEMBASE (cfg, store_ins, OP_STOREI4_MEMBASE_REG, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET, ins->dreg + 2);
11008                                                 mono_bblock_insert_after_ins (bb, ins, store_ins);
11009                                                 def_ins = store_ins;
11010                                         }
11011                                         else {
11012                                                 g_assert (store_opcode != OP_STOREV_MEMBASE);
11013
11014                                                 /* Try to fuse the store into the instruction itself */
11015                                                 /* FIXME: Add more instructions */
11016                                                 if (!lvreg && ((ins->opcode == OP_ICONST) || ((ins->opcode == OP_I8CONST) && (ins->inst_c0 == 0)))) {
11017                                                         ins->opcode = store_membase_reg_to_store_membase_imm (store_opcode);
11018                                                         ins->inst_imm = ins->inst_c0;
11019                                                         ins->inst_destbasereg = var->inst_basereg;
11020                                                         ins->inst_offset = var->inst_offset;
11021                                                         spec = INS_INFO (ins->opcode);
11022                                                 } else if (!lvreg && ((ins->opcode == OP_MOVE) || (ins->opcode == OP_FMOVE) || (ins->opcode == OP_LMOVE))) {
11023                                                         ins->opcode = store_opcode;
11024                                                         ins->inst_destbasereg = var->inst_basereg;
11025                                                         ins->inst_offset = var->inst_offset;
11026
11027                                                         no_lvreg = TRUE;
11028
11029                                                         tmp_reg = ins->dreg;
11030                                                         ins->dreg = ins->sreg2;
11031                                                         ins->sreg2 = tmp_reg;
11032                                                         store = TRUE;
11033
11034                                                         spec2 [MONO_INST_DEST] = ' ';
11035                                                         spec2 [MONO_INST_SRC1] = spec [MONO_INST_SRC1];
11036                                                         spec2 [MONO_INST_SRC2] = spec [MONO_INST_DEST];
11037                                                         spec2 [MONO_INST_SRC3] = ' ';
11038                                                         spec = spec2;
11039                                                 } else if (!lvreg && (op_to_op_store_membase (store_opcode, ins->opcode) != -1)) {
11040                                                         // FIXME: The backends expect the base reg to be in inst_basereg
11041                                                         ins->opcode = op_to_op_store_membase (store_opcode, ins->opcode);
11042                                                         ins->dreg = -1;
11043                                                         ins->inst_basereg = var->inst_basereg;
11044                                                         ins->inst_offset = var->inst_offset;
11045                                                         spec = INS_INFO (ins->opcode);
11046                                                 } else {
11047                                                         /* printf ("INS: "); mono_print_ins (ins); */
11048                                                         /* Create a store instruction */
11049                                                         NEW_STORE_MEMBASE (cfg, store_ins, store_opcode, var->inst_basereg, var->inst_offset, ins->dreg);
11050
11051                                                         /* Insert it after the instruction */
11052                                                         mono_bblock_insert_after_ins (bb, ins, store_ins);
11053
11054                                                         def_ins = store_ins;
11055
11056                                                         /*
11057                                                          * We can't assign ins->dreg to var->dreg here, since the
11058                                                          * sregs could use it. So set a flag, and do it after
11059                                                          * the sregs.
11060                                                          */
11061                                                         if ((!MONO_ARCH_USE_FPSTACK || ((store_opcode != OP_STORER8_MEMBASE_REG) && (store_opcode != OP_STORER4_MEMBASE_REG))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)))
11062                                                                 dest_has_lvreg = TRUE;
11063                                                 }
11064                                         }
11065                                 }
11066
11067                                 if (def_ins && !live_range_start [dreg]) {
11068                                         live_range_start [dreg] = def_ins;
11069                                         live_range_start_bb [dreg] = bb;
11070                                 }
11071                         }
11072
11073                         /************/
11074                         /*  SREGS   */
11075                         /************/
11076                         num_sregs = mono_inst_get_src_registers (ins, sregs);
11077                         for (srcindex = 0; srcindex < 3; ++srcindex) {
11078                                 regtype = spec [MONO_INST_SRC1 + srcindex];
11079                                 sreg = sregs [srcindex];
11080
11081                                 g_assert (((sreg == -1) && (regtype == ' ')) || ((sreg != -1) && (regtype != ' ')));
11082                                 if ((sreg != -1) && get_vreg_to_inst (cfg, sreg)) {
11083                                         MonoInst *var = get_vreg_to_inst (cfg, sreg);
11084                                         MonoInst *use_ins = ins;
11085                                         MonoInst *load_ins;
11086                                         guint32 load_opcode;
11087
11088                                         if (var->opcode == OP_REGVAR) {
11089                                                 sregs [srcindex] = var->dreg;
11090                                                 //mono_inst_set_src_registers (ins, sregs);
11091                                                 live_range_end [sreg] = use_ins;
11092                                                 live_range_end_bb [sreg] = bb;
11093                                                 continue;
11094                                         }
11095
11096                                         g_assert (var->opcode == OP_REGOFFSET);
11097
11098                                         load_opcode = mono_type_to_load_membase (cfg, var->inst_vtype);
11099
11100                                         g_assert (load_opcode != OP_LOADV_MEMBASE);
11101
11102                                         if (vreg_to_lvreg [sreg]) {
11103                                                 g_assert (vreg_to_lvreg [sreg] != -1);
11104
11105                                                 /* The variable is already loaded to an lvreg */
11106                                                 if (G_UNLIKELY (cfg->verbose_level > 2))
11107                                                         printf ("\t\tUse lvreg R%d for R%d.\n", vreg_to_lvreg [sreg], sreg);
11108                                                 sregs [srcindex] = vreg_to_lvreg [sreg];
11109                                                 //mono_inst_set_src_registers (ins, sregs);
11110                                                 continue;
11111                                         }
11112
11113                                         /* Try to fuse the load into the instruction */
11114                                         if ((srcindex == 0) && (op_to_op_src1_membase (load_opcode, ins->opcode) != -1)) {
11115                                                 ins->opcode = op_to_op_src1_membase (load_opcode, ins->opcode);
11116                                                 sregs [0] = var->inst_basereg;
11117                                                 //mono_inst_set_src_registers (ins, sregs);
11118                                                 ins->inst_offset = var->inst_offset;
11119                                         } else if ((srcindex == 1) && (op_to_op_src2_membase (load_opcode, ins->opcode) != -1)) {
11120                                                 ins->opcode = op_to_op_src2_membase (load_opcode, ins->opcode);
11121                                                 sregs [1] = var->inst_basereg;
11122                                                 //mono_inst_set_src_registers (ins, sregs);
11123                                                 ins->inst_offset = var->inst_offset;
11124                                         } else {
11125                                                 if (MONO_IS_REAL_MOVE (ins)) {
11126                                                         ins->opcode = OP_NOP;
11127                                                         sreg = ins->dreg;
11128                                                 } else {
11129                                                         //printf ("%d ", srcindex); mono_print_ins (ins);
11130
11131                                                         sreg = alloc_dreg (cfg, stacktypes [regtype]);
11132
11133                                                         if ((!MONO_ARCH_USE_FPSTACK || ((load_opcode != OP_LOADR8_MEMBASE) && (load_opcode != OP_LOADR4_MEMBASE))) && !((var)->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) && !no_lvreg) {
11134                                                                 if (var->dreg == prev_dreg) {
11135                                                                         /*
11136                                                                          * sreg refers to the value loaded by the load
11137                                                                          * emitted below, but we need to use ins->dreg
11138                                                                          * since it refers to the store emitted earlier.
11139                                                                          */
11140                                                                         sreg = ins->dreg;
11141                                                                 }
11142                                                                 g_assert (sreg != -1);
11143                                                                 vreg_to_lvreg [var->dreg] = sreg;
11144                                                                 g_assert (lvregs_len < 1024);
11145                                                                 lvregs [lvregs_len ++] = var->dreg;
11146                                                         }
11147                                                 }
11148
11149                                                 sregs [srcindex] = sreg;
11150                                                 //mono_inst_set_src_registers (ins, sregs);
11151
11152                                                 if (regtype == 'l') {
11153                                                         NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 2, var->inst_basereg, var->inst_offset + MINI_MS_WORD_OFFSET);
11154                                                         mono_bblock_insert_before_ins (bb, ins, load_ins);
11155                                                         NEW_LOAD_MEMBASE (cfg, load_ins, OP_LOADI4_MEMBASE, sreg + 1, var->inst_basereg, var->inst_offset + MINI_LS_WORD_OFFSET);
11156                                                         mono_bblock_insert_before_ins (bb, ins, load_ins);
11157                                                         use_ins = load_ins;
11158                                                 }
11159                                                 else {
11160 #if SIZEOF_REGISTER == 4
11161                                                         g_assert (load_opcode != OP_LOADI8_MEMBASE);
11162 #endif
11163                                                         NEW_LOAD_MEMBASE (cfg, load_ins, load_opcode, sreg, var->inst_basereg, var->inst_offset);
11164                                                         mono_bblock_insert_before_ins (bb, ins, load_ins);
11165                                                         use_ins = load_ins;
11166                                                 }
11167                                         }
11168
11169                                         if (var->dreg < orig_next_vreg) {
11170                                                 live_range_end [var->dreg] = use_ins;
11171                                                 live_range_end_bb [var->dreg] = bb;
11172                                         }
11173                                 }
11174                         }
11175                         mono_inst_set_src_registers (ins, sregs);
11176
11177                         if (dest_has_lvreg) {
11178                                 g_assert (ins->dreg != -1);
11179                                 vreg_to_lvreg [prev_dreg] = ins->dreg;
11180                                 g_assert (lvregs_len < 1024);
11181                                 lvregs [lvregs_len ++] = prev_dreg;
11182                                 dest_has_lvreg = FALSE;
11183                         }
11184
11185                         if (store) {
11186                                 tmp_reg = ins->dreg;
11187                                 ins->dreg = ins->sreg2;
11188                                 ins->sreg2 = tmp_reg;
11189                         }
11190
11191                         if (MONO_IS_CALL (ins)) {
11192                                 /* Clear vreg_to_lvreg array */
11193                                 for (i = 0; i < lvregs_len; i++)
11194                                         vreg_to_lvreg [lvregs [i]] = 0;
11195                                 lvregs_len = 0;
11196                         } else if (ins->opcode == OP_NOP) {
11197                                 ins->dreg = -1;
11198                                 MONO_INST_NULLIFY_SREGS (ins);
11199                         }
11200
11201                         if (cfg->verbose_level > 2)
11202                                 mono_print_ins_index (1, ins);
11203                 }
11204
11205                 /* Extend the live range based on the liveness info */
11206                 if (cfg->compute_precise_live_ranges && bb->live_out_set && bb->code) {
11207                         for (i = 0; i < cfg->num_varinfo; i ++) {
11208                                 MonoMethodVar *vi = MONO_VARINFO (cfg, i);
11209
11210                                 if (vreg_is_volatile (cfg, vi->vreg))
11211                                         /* The liveness info is incomplete */
11212                                         continue;
11213
11214                                 if (mono_bitset_test_fast (bb->live_in_set, i) && !live_range_start [vi->vreg]) {
11215                                         /* Live from at least the first ins of this bb */
11216                                         live_range_start [vi->vreg] = bb->code;
11217                                         live_range_start_bb [vi->vreg] = bb;
11218                                 }
11219
11220                                 if (mono_bitset_test_fast (bb->live_out_set, i)) {
11221                                         /* Live at least until the last ins of this bb */
11222                                         live_range_end [vi->vreg] = bb->last_ins;
11223                                         live_range_end_bb [vi->vreg] = bb;
11224                                 }
11225                         }
11226                 }
11227         }
11228
11229 #ifdef MONO_ARCH_HAVE_LIVERANGE_OPS
11230         /*
11231          * Emit LIVERANGE_START/LIVERANGE_END opcodes, the backend will implement them
11232          * by storing the current native offset into MonoMethodVar->live_range_start/end.
11233          */
11234         if (cfg->compute_precise_live_ranges && cfg->comp_done & MONO_COMP_LIVENESS) {
11235                 for (i = 0; i < cfg->num_varinfo; ++i) {
11236                         int vreg = MONO_VARINFO (cfg, i)->vreg;
11237                         MonoInst *ins;
11238
11239                         if (live_range_start [vreg]) {
11240                                 MONO_INST_NEW (cfg, ins, OP_LIVERANGE_START);
11241                                 ins->inst_c0 = i;
11242                                 ins->inst_c1 = vreg;
11243                                 mono_bblock_insert_after_ins (live_range_start_bb [vreg], live_range_start [vreg], ins);
11244                         }
11245                         if (live_range_end [vreg]) {
11246                                 MONO_INST_NEW (cfg, ins, OP_LIVERANGE_END);
11247                                 ins->inst_c0 = i;
11248                                 ins->inst_c1 = vreg;
11249                                 if (live_range_end [vreg] == live_range_end_bb [vreg]->last_ins)
11250                                         mono_add_ins_to_end (live_range_end_bb [vreg], ins);
11251                                 else
11252                                         mono_bblock_insert_after_ins (live_range_end_bb [vreg], live_range_end [vreg], ins);
11253                         }
11254                 }
11255         }
11256 #endif
11257
11258         g_free (live_range_start);
11259         g_free (live_range_end);
11260         g_free (live_range_start_bb);
11261         g_free (live_range_end_bb);
11262 }
11263
11264 /**
11265  * FIXME:
11266  * - use 'iadd' instead of 'int_add'
11267  * - handling ovf opcodes: decompose in method_to_ir.
11268  * - unify iregs/fregs
11269  *   -> partly done, the missing parts are:
11270  *   - a more complete unification would involve unifying the hregs as well, so
11271  *     code wouldn't need if (fp) all over the place. but that would mean the hregs
11272  *     would no longer map to the machine hregs, so the code generators would need to
11273  *     be modified. Also, on ia64 for example, niregs + nfregs > 256 -> bitmasks
11274  *     wouldn't work any more. Duplicating the code in mono_local_regalloc () into
11275  *     fp/non-fp branches speeds it up by about 15%.
11276  * - use sext/zext opcodes instead of shifts
11277  * - add OP_ICALL
11278  * - get rid of TEMPLOADs if possible and use vregs instead
11279  * - clean up usage of OP_P/OP_ opcodes
11280  * - cleanup usage of DUMMY_USE
11281  * - cleanup the setting of ins->type for MonoInst's which are pushed on the
11282  *   stack
11283  * - set the stack type and allocate a dreg in the EMIT_NEW macros
11284  * - get rid of all the <foo>2 stuff when the new JIT is ready.
11285  * - make sure handle_stack_args () is called before the branch is emitted
11286  * - when the new IR is done, get rid of all unused stuff
11287  * - COMPARE/BEQ as separate instructions or unify them ?
11288  *   - keeping them separate allows specialized compare instructions like
11289  *     compare_imm, compare_membase
11290  *   - most back ends unify fp compare+branch, fp compare+ceq
11291  * - integrate mono_save_args into inline_method
11292  * - get rid of the empty bblocks created by MONO_EMIT_NEW_BRACH_BLOCK2
11293  * - handle long shift opts on 32 bit platforms somehow: they require
11294  *   3 sregs (2 for arg1 and 1 for arg2)
11295  * - make byref a 'normal' type.
11296  * - use vregs for bb->out_stacks if possible, handle_global_vreg will make them a
11297  *   variable if needed.
11298  * - do not start a new IL level bblock when cfg->cbb is changed by a function call
11299  *   like inline_method.
11300  * - remove inlining restrictions
11301  * - fix LNEG and enable cfold of INEG
11302  * - generalize x86 optimizations like ldelema as a peephole optimization
11303  * - add store_mem_imm for amd64
11304  * - optimize the loading of the interruption flag in the managed->native wrappers
11305  * - avoid special handling of OP_NOP in passes
11306  * - move code inserting instructions into one function/macro.
11307  * - try a coalescing phase after liveness analysis
11308  * - add float -> vreg conversion + local optimizations on !x86
11309  * - figure out how to handle decomposed branches during optimizations, ie.
11310  *   compare+branch, op_jump_table+op_br etc.
11311  * - promote RuntimeXHandles to vregs
11312  * - vtype cleanups:
11313  *   - add a NEW_VARLOADA_VREG macro
11314  * - the vtype optimizations are blocked by the LDADDR opcodes generated for
11315  *   accessing vtype fields.
11316  * - get rid of I8CONST on 64 bit platforms
11317  * - dealing with the increase in code size due to branches created during opcode
11318  *   decomposition:
11319  *   - use extended basic blocks
11320  *     - all parts of the JIT
11321  *     - handle_global_vregs () && local regalloc
11322  *   - avoid introducing global vregs during decomposition, like 'vtable' in isinst
11323  * - sources of increase in code size:
11324  *   - vtypes
11325  *   - long compares
11326  *   - isinst and castclass
11327  *   - lvregs not allocated to global registers even if used multiple times
11328  * - call cctors outside the JIT, to make -v output more readable and JIT timings more
11329  *   meaningful.
11330  * - check for fp stack leakage in other opcodes too. (-> 'exceptions' optimization)
11331  * - add all micro optimizations from the old JIT
11332  * - put tree optimizations into the deadce pass
11333  * - decompose op_start_handler/op_endfilter/op_endfinally earlier using an arch
11334  *   specific function.
11335  * - unify the float comparison opcodes with the other comparison opcodes, i.e.
11336  *   fcompare + branchCC.
11337  * - create a helper function for allocating a stack slot, taking into account
11338  *   MONO_CFG_HAS_SPILLUP.
11339  * - merge r68207.
11340  * - merge the ia64 switch changes.
11341  * - optimize mono_regstate2_alloc_int/float.
11342  * - fix the pessimistic handling of variables accessed in exception handler blocks.
11343  * - need to write a tree optimization pass, but the creation of trees is difficult, i.e.
11344  *   parts of the tree could be separated by other instructions, killing the tree
11345  *   arguments, or stores killing loads etc. Also, should we fold loads into other
11346  *   instructions if the result of the load is used multiple times ?
11347  * - make the REM_IMM optimization in mini-x86.c arch-independent.
11348  * - LAST MERGE: 108395.
11349  * - when returning vtypes in registers, generate IR and append it to the end of the
11350  *   last bb instead of doing it in the epilog.
11351  * - change the store opcodes so they use sreg1 instead of dreg to store the base register.
11352  */
11353
11354 /*
11355
11356 NOTES
11357 -----
11358
11359 - When to decompose opcodes:
11360   - earlier: this makes some optimizations hard to implement, since the low level IR
11361   no longer contains the neccessary information. But it is easier to do.
11362   - later: harder to implement, enables more optimizations.
11363 - Branches inside bblocks:
11364   - created when decomposing complex opcodes.
11365     - branches to another bblock: harmless, but not tracked by the branch
11366       optimizations, so need to branch to a label at the start of the bblock.
11367     - branches to inside the same bblock: very problematic, trips up the local
11368       reg allocator. Can be fixed by spitting the current bblock, but that is a
11369       complex operation, since some local vregs can become global vregs etc.
11370 - Local/global vregs:
11371   - local vregs: temporary vregs used inside one bblock. Assigned to hregs by the
11372     local register allocator.
11373   - global vregs: used in more than one bblock. Have an associated MonoMethodVar
11374     structure, created by mono_create_var (). Assigned to hregs or the stack by
11375     the global register allocator.
11376 - When to do optimizations like alu->alu_imm:
11377   - earlier -> saves work later on since the IR will be smaller/simpler
11378   - later -> can work on more instructions
11379 - Handling of valuetypes:
11380   - When a vtype is pushed on the stack, a new temporary is created, an
11381     instruction computing its address (LDADDR) is emitted and pushed on
11382     the stack. Need to optimize cases when the vtype is used immediately as in
11383     argument passing, stloc etc.
11384 - Instead of the to_end stuff in the old JIT, simply call the function handling
11385   the values on the stack before emitting the last instruction of the bb.
11386 */
11387
11388 #endif /* DISABLE_JIT */