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