mono/mini/inssel.brg

   1 /*
   2  * inssel.brg: instruction selection
   3  *
   4  * Author:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *   Paolo Molaro (lupus@ximian.com)
   7  *
   8  * (C) 2002 Ximian, Inc.
   9  *
  10  */
  11 #include <config.h>
  12 #include <string.h>
  13
  14 #include "mini.h"
  15 #include <mono/metadata/marshal.h>
  16 #include <mono/metadata/debug-helpers.h>
  17
  18 #define MBTREE_TYPE  MonoInst
  19 #define MBCGEN_TYPE  MonoCompile
  20 #define MBCOST_DATA  MonoCompile
  21 #define MBALLOC_STATE mono_mempool_alloc (data->state_pool, sizeof (MBState))
  22 #define MBMAX_OPCODES OP_LAST
  23 #define MBGET_OP_NAME(op) mono_inst_name (op)
  24
  25 #define MBTREE_OP(t) ((t)->opcode)
  26 #define MBTREE_LEFT(t) ((t)->inst_left)
  27 #define MBTREE_RIGHT(t) ((t)->inst_right)
  28
  29 #define MONO_EMIT_UNALU(cfg,inst,op,dr,sr1) do { \
  30                 (inst)->opcode = op; \
  31                 (inst)->dreg = dr; \
  32                 (inst)->sreg1 = sr1; \
  33                 mono_bblock_add_inst (cfg->cbb, inst); \
  34         } while (0)
  35
  36 #define MONO_EMIT_NEW_UNALU(cfg,op,dr,sr1) do { \
  37                 MonoInst *inst; \
  38                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
  39                 inst->opcode = op; \
  40                 inst->dreg = dr; \
  41                 inst->sreg1 = sr1; \
  42                 mono_bblock_add_inst (cfg->cbb, inst); \
  43         } while (0)
  44
  45 #define MONO_EMIT_BIALU(cfg,inst,op,dr,sr1,sr2) do { \
  46                 (inst)->opcode = op; \
  47                 (inst)->dreg = dr; \
  48                 (inst)->sreg1 = sr1; \
  49                 (inst)->sreg2 = sr2; \
  50                 mono_bblock_add_inst (cfg->cbb, inst); \
  51         } while (0)
  52
  53 #define MONO_EMIT_NEW_BIALU(cfg,op,dr,sr1,sr2) do { \
  54                 MonoInst *inst; \
  55                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
  56                 inst->opcode = op; \
  57                 inst->dreg = dr; \
  58                 inst->sreg1 = sr1; \
  59                 inst->sreg2 = sr2; \
  60                 mono_bblock_add_inst (cfg->cbb, inst); \
  61         } while (0)
  62
  63 #define MONO_EMIT_BIALU_IMM(cfg,inst,op,dr,sr,imm) do { \
  64                 (inst)->opcode = op; \
  65                 (inst)->dreg = dr; \
  66                 (inst)->sreg1 = sr; \
  67                 (inst)->inst_p1 = (gpointer)(gssize)(imm); \
  68                 mono_bblock_add_inst (cfg->cbb, inst); \
  69         } while (0)
  70
  71 #define MONO_EMIT_NEW_BIALU_IMM(cfg,op,dr,sr,imm) do { \
  72                 MonoInst *inst; \
  73                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
  74                 inst->opcode = op; \
  75                 inst->dreg = dr; \
  76                 inst->sreg1 = sr; \
  77                 inst->inst_p1 = (gpointer)(gssize)(imm); \
  78                 mono_bblock_add_inst (cfg->cbb, inst); \
  79         } while (0)
  80
  81 #define MONO_EMIT_BIALU_MEMBASE(cfg,tree,op,dr,sr,basereg,offset) do { \
  82                                 tree->opcode = op; \
  83                                 tree->dreg = dr; \
  84                                 tree->sreg1 = sr; \
  85                                 tree->sreg2 = basereg; \
  86                                 tree->inst_offset = offset; \
  87                                 mono_bblock_add_inst (s->cbb, tree); \
  88         } while (0)
  89
  90 #define MONO_EMIT_LOAD_MEMBASE(cfg,inst,dr,base,offset) do { \
  91                 (inst)->opcode = OP_LOAD_MEMBASE; \
  92                 (inst)->dreg = dr; \
  93                 (inst)->inst_basereg = base; \
  94                 (inst)->inst_offset = offset; \
  95                 mono_bblock_add_inst (cfg->cbb, inst); \
  96         } while (0)
  97
  98 #define MONO_EMIT_LOAD_MEMBASE_OP(cfg,inst,op,dr,base,offset) do { \
  99                 (inst)->opcode = op; \
 100                 (inst)->dreg = dr; \
 101                 (inst)->inst_basereg = base; \
 102                 (inst)->inst_offset = offset; \
 103                 mono_bblock_add_inst (cfg->cbb, inst); \
 104         } while (0)
 105
 106 #define MONO_EMIT_NEW_LOAD_MEM(cfg,dr,addr) do { \
 107                 MonoInst *inst; \
 108                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 109                 inst->opcode = OP_LOADU4_MEM; \
 110                 inst->dreg = dr; \
 111                 inst->inst_p0 = addr; \
 112                 mono_bblock_add_inst (cfg->cbb, inst); \
 113         } while (0)
 114
 115 #define MONO_EMIT_NEW_LOAD_MEMBASE(cfg,dr,base,offset) do { \
 116                 MonoInst *inst; \
 117                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 118                 inst->opcode = OP_LOAD_MEMBASE; \
 119                 inst->dreg = dr; \
 120                 inst->inst_basereg = base; \
 121                 inst->inst_offset = offset; \
 122                 mono_bblock_add_inst (cfg->cbb, inst); \
 123         } while (0)
 124
 125 #define MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg,op,dr,base,offset) do { \
 126                 MonoInst *inst; \
 127                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 128                 inst->opcode = op; \
 129                 inst->dreg = dr; \
 130                 inst->inst_basereg = base; \
 131                 inst->inst_offset = offset; \
 132                 mono_bblock_add_inst (cfg->cbb, inst); \
 133         } while (0)
 134
 135 #define MONO_EMIT_STORE_MEMBASE(cfg,inst,op,base,offset,sr) do { \
 136                 (inst)->opcode = op; \
 137                 (inst)->sreg1 = sr; \
 138                 (inst)->inst_destbasereg = base; \
 139                 (inst)->inst_offset = offset; \
 140                 mono_bblock_add_inst (cfg->cbb, inst); \
 141         } while (0)
 142
 143 #define MONO_EMIT_NEW_STORE_MEMBASE(cfg,op,base,offset,sr) do { \
 144                 MonoInst *inst; \
 145                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 146                 inst->opcode = op; \
 147                 inst->sreg1 = sr; \
 148                 inst->inst_destbasereg = base; \
 149                 inst->inst_offset = offset; \
 150                 mono_bblock_add_inst (cfg->cbb, inst); \
 151         } while (0)
 152
 153 #define MONO_EMIT_STORE_MEMBASE_IMM(cfg,inst,op,base,offset,imm) do { \
 154                 (inst)->opcode = op; \
 155                 (inst)->inst_destbasereg = base; \
 156                 (inst)->inst_offset = offset; \
 157                 (inst)->inst_p1 = (gpointer)imm; \
 158                 mono_bblock_add_inst (cfg->cbb, inst); \
 159         } while (0)
 160
 161 #define MONO_EMIT_NEW_STORE_MEMBASE_IMM(cfg,op,base,offset,imm) do { \
 162                 MonoInst *inst; \
 163                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 164                 inst->opcode = op; \
 165                 inst->inst_destbasereg = base; \
 166                 inst->inst_offset = offset; \
 167                 inst->inst_p1 = (gpointer)imm; \
 168                 mono_bblock_add_inst (cfg->cbb, inst); \
 169         } while (0)
 170
 171 #define MONO_EMIT_NEW_COMPARE_IMM(cfg,sr1,imm) do { \
 172                 MonoInst *inst; \
 173                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 174                 inst->opcode = OP_COMPARE_IMM;  \
 175                 inst->sreg1 = sr1; \
 176                 inst->inst_p1 = (gpointer)imm; \
 177                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 178         } while (0)
 179
 180 #define MONO_EMIT_NEW_ICOMPARE_IMM(cfg,sr1,imm) do { \
 181                 MonoInst *inst; \
 182                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 183                 inst->opcode = sizeof (void*) == 8 ? OP_ICOMPARE_IMM : OP_COMPARE_IMM;  \
 184                 inst->sreg1 = sr1; \
 185                 inst->inst_p1 = (gpointer)imm; \
 186                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 187         } while (0)
 188
 189 #define MONO_EMIT_NEW_COND_EXC(cfg,cond,name) do { \
 190                 MonoInst *inst; \
 191                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 192                 inst->opcode = OP_COND_EXC_##cond;  \
 193                 inst->inst_p1 = (char*)name; \
 194                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 195         } while (0)
 196
 197 #define MONO_EMIT_NEW_ICONST(cfg,dr,imm) do { \
 198                 MonoInst *inst; \
 199                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 200                 inst->opcode = OP_ICONST;       \
 201                 inst->dreg = dr; \
 202                 inst->inst_c0 = imm; \
 203                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 204         } while (0)
 205
 206 #define MONO_EMIT_NEW_I8CONST(cfg,dr,imm) do { \
 207                 MonoInst *inst; \
 208                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 209                 inst->opcode = OP_I8CONST;      \
 210                 inst->dreg = dr; \
 211                 inst->inst_l = imm; \
 212                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 213         } while (0)
 214
 215 #define MONO_EMIT_NEW_PCONST(cfg,dr,imm) do { \
 216                 MonoInst *inst; \
 217                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 218                 inst->opcode = OP_ICONST;       \
 219                 inst->dreg = dr; \
 220                 inst->inst_p0 = (gpointer) imm; \
 221                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 222         } while (0)
 223
 224
 225 #ifdef MONO_ARCH_NEED_GOT_VAR
 226
 227 #define MONO_EMIT_NEW_AOTCONST(cfg,dr,cons,patch_type) do { \
 228                 mini_emit_aotconst ((cfg), (dr), (patch_type), (cons)); \
 229     } while (0)
 230
 231 #else
 232
 233 #define MONO_EMIT_NEW_AOTCONST(cfg,dr,imm,type) do { \
 234                 MonoInst *inst; \
 235                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 236                 inst->opcode = OP_AOTCONST;     \
 237                 inst->dreg = dr; \
 238                 inst->inst_p0 = imm; \
 239                 inst->inst_c1 = type; \
 240                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 241         } while (0)
 242
 243 #endif
 244
 245 #define MONO_EMIT_NEW_CLASSCONST(cfg,dr,imm) MONO_EMIT_NEW_AOTCONST(cfg,dr,imm,MONO_PATCH_INFO_CLASS)
 246 #define MONO_EMIT_NEW_VTABLECONST(cfg,dest,vtable) MONO_EMIT_NEW_AOTCONST ((cfg), (dest), (cfg)->compile_aot ? (gpointer)((vtable)->klass) : (vtable), MONO_PATCH_INFO_VTABLE)
 247
 248 #define MONO_EMIT_NEW_BRANCH_BLOCK(cfg,op,targetbb) do { \
 249                 MonoInst *inst; \
 250                 MonoInst *target_label; \
 251                 target_label = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 252                 target_label->opcode = OP_LABEL;        \
 253                 target_label->next = (targetbb)->code; \
 254                 target_label->inst_c0 = (targetbb)->native_offset; \
 255                 (targetbb)->code = target_label; \
 256                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 257                 inst->opcode = op;      \
 258                 inst->inst_i0 = target_label;   \
 259                 inst->flags = MONO_INST_BRLABEL;        \
 260                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 261         } while (0)
 262
 263 #define MONO_EMIT_NEW_BRANCH_LABEL(cfg,op,label) do { \
 264                 MonoInst *inst; \
 265                 inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
 266                 inst->opcode = op;      \
 267                 inst->inst_i0 = label;  \
 268                 inst->flags = MONO_INST_BRLABEL;        \
 269                 mono_bblock_add_inst ((cfg)->cbb, inst); \
 270         } while (0)
 271
 272 #define MONO_NEW_LABEL(cfg,inst) do { \
 273                 (inst) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst));       \
 274                 (inst)->opcode = OP_LABEL;      \
 275         } while (0)
 276
 277 #define MONO_EMIT_BOUNDS_CHECK(cfg, array_reg, array_type, array_length_field, index_reg) do { \
 278                 if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \
 279                         int _length_reg = mono_regstate_next_int (cfg->rs); \
 280                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \
 281                         MONO_EMIT_NEW_COMPARE_EXC (cfg, LE_UN, _length_reg, index_reg, "IndexOutOfRangeException"); \
 282                 } \
 283         } while (0)
 284
 285 #define MONO_EMIT_BOUNDS_CHECK_IMM(cfg, array_reg, array_type, array_length_field, index_imm) do { \
 286                 if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \
 287                         int _length_reg = mono_regstate_next_int (cfg->rs); \
 288                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \
 289                         MONO_EMIT_NEW_COMPARE_IMM_EXC (cfg, LE_UN, _length_reg, index_imm, "IndexOutOfRangeException"); \
 290                 } \
 291         } while (0)
 292
 293 #ifndef MONO_EMIT_NEW_COMPARE_EXC
 294 #define MONO_EMIT_NEW_COMPARE_EXC(cfg, cmp_op, sreg1, sreg2, exc) do { \
 295                 MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, sreg1, sreg2); \
 296                 MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \
 297         } while (0)
 298 #endif
 299
 300 #ifndef MONO_EMIT_NEW_COMPARE_IMM_EXC
 301 #define MONO_EMIT_NEW_COMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
 302                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, sreg1, imm); \
 303                 MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \
 304         } while (0)
 305 #endif
 306
 307 #ifndef MONO_EMIT_NEW_ICOMPARE_IMM_EXC
 308 #define MONO_EMIT_NEW_ICOMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
 309                 MONO_EMIT_NEW_ICOMPARE_IMM(cfg, sreg1, imm); \
 310                 MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \
 311         } while (0)
 312 #endif
 313
 314 #ifndef MONO_EMIT_NEW_COMPARE_BRANCH_LABEL
 315 #define MONO_EMIT_NEW_COMPARE_BRANCH_LABEL(cfg, cmp_op, sreg1, sreg2, label) \
 316         do { \
 317                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, (sreg1), (sreg2)); \
 318                 MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \
 319         } while (0)
 320 #endif
 321
 322 #ifndef MONO_EMIT_NEW_COMPARE_BRANCH_LABEL_CHAINED
 323 #define MONO_EMIT_NEW_COMPARE_BRANCH_LABEL_CHAINED(cfg, cmp_op, sreg1, sreg2, label) \
 324         do { \
 325                 MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \
 326 } while (0)
 327 #endif
 328
 329 #ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL
 330 #define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL(cfg, cmp_op, sreg1, imm, label) \
 331         do { \
 332                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, (sreg1), (imm)); \
 333                 MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \
 334         } while (0)
 335 #endif
 336
 337 #ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL_CHAINED
 338 #define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL_CHAINED(cfg, cmp_op, sreg1, imm, label) \
 339         do { \
 340                 MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \
 341 } while (0)
 342 #endif
 343
 344 #ifndef MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK
 345 #define MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK(cfg, cmp_op, sreg1, sreg2, block) \
 346         do { \
 347                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, (sreg1), (sreg2)); \
 348                 MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \
 349         } while (0)
 350 #endif
 351
 352 #ifndef MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK_CHAINED
 353 #define MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK_CHAINED(cfg, cmp_op, sreg1, sreg2, block) \
 354         do { \
 355                 MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \
 356 } while (0)
 357 #endif
 358
 359 #ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK
 360 #define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK(cfg, cmp_op, sreg1, imm, block) \
 361         do { \
 362                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, (sreg1), (imm)); \
 363                 MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \
 364         } while (0)
 365 #endif
 366
 367 #ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK_CHAINED
 368 #define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK_CHAINED(cfg, cmp_op, sreg1, imm, block) \
 369         do { \
 370                 MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \
 371 } while (0)
 372 #endif
 373
 374 %%
 375
 376 %termprefix OP_ CEE_
 377
 378 %start stmt
 379
 380 #
 381 # base addressing mode
 382 #
 383
 384 base: reg "0" {
 385         /* we create a new MonoInst in chain rules and set state->tree to it
 386          * since a MBState (and hence state->tree) is reused in chain rules and
 387          * normal rules.
 388          */
 389         MonoInst *inst;
 390         inst = mono_mempool_alloc0 (s->mempool, sizeof (MonoInst));
 391         inst->opcode = OP_ICONST; /* doesn't matter */
 392         inst->inst_basereg = state->reg1;
 393         inst->inst_offset = 0;
 394         state->tree = inst;
 395         //g_print ("mybase: (assigned R%d from R%d - R%d)\n", state->reg1, tree->dreg, state->reg2);
 396         //tree->inst_offset = 0;
 397         //tree->inst_basereg = state->reg1;
 398 }
 399
 400 base: CEE_LDIND_I (OP_REGVAR) "0" {
 401         tree->inst_offset = 0;
 402         tree->inst_basereg = state->left->tree->dreg;
 403 }
 404
 405 base: OP_REGOFFSET "0" {
 406         /* nothing to do */
 407 }
 408
 409 base: OP_LDADDR (OP_REGOFFSET),
 410 base: CEE_LDOBJ (OP_REGOFFSET) "0" {
 411         tree->inst_offset = state->left->tree->inst_offset;
 412         tree->inst_basereg = state->left->tree->inst_basereg;
 413 }
 414
 415 base: CEE_ADD (base, OP_ICONST) "0" {
 416         tree->inst_offset = state->left->tree->inst_offset + state->right->tree->inst_c0;
 417         tree->inst_basereg = state->left->tree->inst_basereg;
 418 }
 419
 420 base: CEE_ADD (CEE_LDIND_REF (OP_REGVAR), OP_ICONST),
 421 base: CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST) "0" {
 422         tree->inst_offset = state->right->tree->inst_c0;
 423         tree->inst_basereg = state->left->left->tree->dreg;
 424 }
 425
 426 #
 427 # helpers
 428 #
 429
 430 reg: OP_ICONST {
 431         tree->dreg = state->reg1;
 432         MONO_EMIT_NEW_ICONST (s, state->reg1, tree->inst_c0);
 433 }
 434
 435 reg: OP_AOTCONST {
 436         MONO_EMIT_NEW_AOTCONST (s, state->reg1, tree->inst_p0, tree->inst_c1);
 437 }
 438
 439 reg: OP_LOAD_GOTADDR {
 440         tree->dreg = state->reg1;
 441         mono_bblock_add_inst (s->cbb, tree);
 442 }
 443
 444 stmt: CEE_STIND_I (OP_REGVAR, OP_LOAD_GOTADDR) {
 445         tree->opcode = OP_LOAD_GOTADDR;
 446         tree->dreg = state->left->tree->dreg;
 447         mono_bblock_add_inst (s->cbb, tree);
 448 }
 449
 450 reg: OP_GOT_ENTRY (reg, OP_PATCH_INFO) {
 451         tree->inst_basereg = state->left->tree->dreg;
 452         tree->dreg = state->reg1;
 453         mono_bblock_add_inst (s->cbb, tree);
 454 }
 455
 456 reg: OP_GOT_ENTRY (CEE_LDIND_I (OP_REGVAR), OP_PATCH_INFO) {
 457         tree->inst_basereg = state->left->left->tree->dreg;
 458         tree->dreg = state->reg1;
 459         mono_bblock_add_inst (s->cbb, tree);
 460 }
 461
 462 stmt: OP_DUMMY_USE (CEE_LDIND_I (OP_REGVAR)) {
 463 }
 464
 465 stmt: OP_DUMMY_USE (CEE_LDIND_I (OP_REGOFFSET)) {
 466 }
 467
 468 stmt: OP_DUMMY_USE (CEE_LDIND_REF (OP_REGOFFSET)) {
 469 }
 470
 471 stmt: OP_DUMMY_STORE {
 472 }
 473
 474 stmt: OP_NOT_REACHED {
 475 }
 476
 477 stmt: OP_MEMORY_BARRIER {
 478         mono_bblock_add_inst (s->cbb, tree);
 479 }
 480
 481 #
 482 # load/store operations
 483 #
 484
 485 reg: CEE_LDIND_I (base),
 486 reg: CEE_LDIND_REF (base),
 487 reg: CEE_LDIND_I1 (base),
 488 reg: CEE_LDIND_U1 (base),
 489 reg: CEE_LDIND_I2 (base),
 490 reg: CEE_LDIND_U2 (base),
 491 reg: CEE_LDIND_I4 (base),
 492 reg: CEE_LDIND_U4 (base) {
 493         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, ldind_to_load_membase (tree->opcode),
 494                                    state->reg1, state->left->tree->inst_basereg, state->left->tree->inst_offset);
 495 }
 496
 497 reg: OP_LDADDR (OP_REGOFFSET),
 498 reg: CEE_LDOBJ (OP_REGOFFSET) "2" {
 499         /* use LEA */
 500         tree->opcode = OP_MOVE;
 501         tree->sreg1 = state->left->tree->inst_basereg;
 502         tree->dreg = state->reg1;
 503         mono_bblock_add_inst (s->cbb, tree);
 504         if (state->left->tree->inst_offset)
 505                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tree->dreg, tree->dreg, state->left->tree->inst_offset);
 506 }
 507
 508 reg: CEE_LDOBJ (reg),
 509 reg: OP_OBJADDR (reg),
 510 reg: OP_VTADDR (reg) {
 511         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 512 }
 513
 514 reg: CEE_LDIND_U1 (OP_REGVAR) {
 515         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->tree->dreg, 0xff);
 516 }
 517
 518 reg: CEE_LDIND_U2 (OP_REGVAR) {
 519         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->tree->dreg, 0xffff);
 520 }
 521
 522 stmt: CEE_STIND_REF (base, CEE_LDIND_REF (OP_REGVAR)),
 523 stmt: CEE_STIND_REF (base, CEE_LDIND_I (OP_REGVAR)),
 524 stmt: CEE_STIND_I (base, CEE_LDIND_REF (OP_REGVAR)),
 525 stmt: CEE_STIND_I (base, CEE_LDIND_I (OP_REGVAR)) {
 526         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STORE_MEMBASE_REG, state->left->tree->inst_basereg,
 527                                  state->left->tree->inst_offset, state->right->left->tree->dreg);
 528 }
 529
 530 stmt: CEE_STIND_REF (OP_REGVAR, CEE_LDIND_REF (OP_REGVAR)),
 531 stmt: CEE_STIND_REF (OP_REGVAR, CEE_LDIND_I (OP_REGVAR)),
 532 stmt: CEE_STIND_I (OP_REGVAR, CEE_LDIND_REF (OP_REGVAR)),
 533 stmt: CEE_STIND_I (OP_REGVAR, CEE_LDIND_I (OP_REGVAR)),
 534 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_LDIND_I4 (OP_REGVAR)) {
 535         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->left->tree->dreg, state->right->left->tree->dreg);
 536 }
 537
 538
 539 stmt: CEE_STIND_I (base, reg),
 540 stmt: CEE_STIND_REF (base, reg) {
 541         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STORE_MEMBASE_REG, state->left->tree->inst_basereg,
 542                                  state->left->tree->inst_offset, state->right->reg1);
 543 }
 544
 545 stmt: CEE_STIND_I (base, OP_ICONST),
 546 stmt: CEE_STIND_REF (base, OP_ICONST) {
 547         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STORE_MEMBASE_IMM, state->left->tree->inst_basereg,
 548                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 549 }
 550
 551 reg: CEE_LDIND_REF (OP_REGVAR),
 552 reg: CEE_LDIND_I (OP_REGVAR),
 553 reg: CEE_LDIND_I4 (OP_REGVAR),
 554 reg: CEE_LDIND_U4 (OP_REGVAR) {
 555         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->tree->dreg);
 556 }
 557
 558 stmt: CEE_STIND_I4 (base, reg) {
 559         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI4_MEMBASE_REG, state->left->tree->inst_basereg,
 560                                  state->left->tree->inst_offset, state->right->reg1);
 561 }
 562
 563 stmt: CEE_STIND_I4 (base, CEE_LDIND_I4 (OP_REGVAR)) {
 564         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI4_MEMBASE_REG, state->left->tree->inst_basereg,
 565                                  state->left->tree->inst_offset, state->right->left->tree->dreg);
 566 }
 567
 568 stmt: CEE_STIND_I4 (base, OP_ICONST) {
 569         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI4_MEMBASE_IMM, state->left->tree->inst_basereg,
 570                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 571 }
 572
 573 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_LDIND_I4 (base)) {
 574         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->left->tree->dreg,
 575                                    state->right->left->tree->inst_basereg,
 576                                    state->right->left->tree->inst_offset);
 577 }
 578
 579 stmt: CEE_STIND_I1 (base, reg) {
 580         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI1_MEMBASE_REG, state->left->tree->inst_basereg,
 581                                  state->left->tree->inst_offset, state->right->reg1);
 582 }
 583
 584 stmt: CEE_STIND_I1 (base, OP_ICONST) {
 585         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI1_MEMBASE_IMM, state->left->tree->inst_basereg,
 586                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 587 }
 588
 589 stmt: CEE_STIND_I2 (base, reg) {
 590         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI2_MEMBASE_REG, state->left->tree->inst_basereg,
 591                                  state->left->tree->inst_offset, state->right->reg1);
 592 }
 593
 594 stmt: CEE_STIND_I2 (base, OP_ICONST) {
 595         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI2_MEMBASE_IMM, state->left->tree->inst_basereg,
 596                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 597 }
 598
 599 stmt: CEE_STIND_I2 (OP_REGVAR, reg) {
 600         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->reg1, 0xffff);
 601 }
 602
 603 stmt: CEE_STIND_I1 (OP_REGVAR, reg) {
 604         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->reg1, 0xff);
 605 }
 606
 607 stmt: CEE_STIND_I1 (OP_REGVAR, CEE_LDIND_U1 (OP_REGVAR)),
 608 stmt: CEE_STIND_I1 (OP_REGVAR, CEE_LDIND_I1 (OP_REGVAR)) {
 609         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->left->tree->dreg, 0xff);
 610 }
 611
 612 stmt: CEE_STIND_I2 (OP_REGVAR, CEE_LDIND_U2 (OP_REGVAR)),
 613 stmt: CEE_STIND_I2 (OP_REGVAR, CEE_LDIND_I2 (OP_REGVAR)) {
 614         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->left->tree->dreg, 0xffff);
 615 }
 616
 617 stmt: CEE_STIND_I4 (OP_REGVAR, OP_ICONST),
 618 stmt: CEE_STIND_I2 (OP_REGVAR, OP_ICONST),
 619 stmt: CEE_STIND_I1 (OP_REGVAR, OP_ICONST),
 620 stmt: CEE_STIND_REF (OP_REGVAR, OP_ICONST),
 621 stmt: CEE_STIND_I (OP_REGVAR, OP_ICONST) {
 622         tree->inst_c0 = state->right->tree->inst_c0;
 623         if (tree->opcode == CEE_STIND_I2)
 624                 tree->inst_c0 &= 0xffff;
 625         if (tree->opcode == CEE_STIND_I1)
 626                 tree->inst_c0 &= 0xff;
 627
 628         tree->opcode = OP_ICONST;
 629         tree->dreg = state->left->tree->dreg;
 630         mono_bblock_add_inst (s->cbb, tree);
 631 }
 632
 633 stmt: CEE_STIND_I4 (OP_REGVAR, reg),
 634 stmt: CEE_STIND_REF (OP_REGVAR, reg),
 635 stmt: CEE_STIND_I (OP_REGVAR, reg) {
 636         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->left->tree->dreg, state->right->reg1);
 637 }
 638
 639 stmt: OP_MEMCPY (base, base) {
 640         int size = tree->backend.memcpy_args->size;
 641         int align = tree->backend.memcpy_args->align;
 642         if (size > 0)
 643                 mini_emit_memcpy (s, state->left->tree->inst_basereg, state->left->tree->inst_offset,
 644                                   state->right->tree->inst_basereg, state->right->tree->inst_offset, size, align);
 645 }
 646
 647 stmt: OP_MEMSET (base) {
 648         int size = tree->backend.memcpy_args->size;
 649         int align = tree->backend.memcpy_args->align;
 650         if (size > 0)
 651                 mini_emit_memset (s, state->left->tree->inst_basereg, state->left->tree->inst_offset, size, tree->inst_imm, align);
 652 }
 653
 654 reg: OP_LDELEMA2D (reg, OP_GROUP (reg, reg)) "20" {
 655         int bounds_reg = mono_regstate_next_int (s->rs);
 656         int add_reg = mono_regstate_next_int (s->rs);
 657         int mult_reg = mono_regstate_next_int (s->rs);
 658         int mult2_reg = mono_regstate_next_int (s->rs);
 659         int low1_reg = mono_regstate_next_int (s->rs);
 660         int low2_reg = mono_regstate_next_int (s->rs);
 661         int high1_reg = mono_regstate_next_int (s->rs);
 662         int high2_reg = mono_regstate_next_int (s->rs);
 663         int realidx1_reg = mono_regstate_next_int (s->rs);
 664         int realidx2_reg = mono_regstate_next_int (s->rs);
 665         int sum_reg = mono_regstate_next_int (s->rs);
 666         int index1, index2;
 667         guint32 size = mono_class_array_element_size (tree->klass);
 668
 669         index1 = state->right->left->reg1;
 670         index2 = state->right->right->reg1;
 671
 672         /* range checking */
 673         MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg,
 674                                        state->left->reg1, G_STRUCT_OFFSET (MonoArray, bounds));
 675
 676         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, low1_reg,
 677                                        bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
 678         MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx1_reg, index1, low1_reg);
 679         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high1_reg,
 680                                        bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, length));
 681         MONO_EMIT_NEW_COMPARE_EXC (s, LE_UN, high1_reg, realidx1_reg, "IndexOutOfRangeException");
 682
 683         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, low2_reg,
 684                                        bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
 685         MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx2_reg, index2, low2_reg);
 686         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high2_reg,
 687                                        bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, length));
 688         MONO_EMIT_NEW_COMPARE_EXC (s, LE_UN, high2_reg, realidx2_reg, "IndexOutOfRangeException");
 689
 690         MONO_EMIT_NEW_BIALU (s, CEE_MUL, mult_reg, high2_reg, realidx1_reg);
 691         MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, mult_reg, realidx2_reg);
 692         MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, mult2_reg, sum_reg, size);
 693         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult2_reg, state->left->reg1);
 694         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoArray, vector));
 695 }
 696
 697 #
 698 # conversions: conv_u can be implemented with AND, also all _ovf conversions?
 699 #
 700
 701 reg: CEE_CONV_I1 (reg),
 702 reg: CEE_CONV_I2 (reg),
 703 reg: CEE_CONV_I4 (reg) {
 704         MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 705 }
 706
 707 reg: CEE_CONV_U1 (reg) {
 708         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
 709 }
 710
 711 reg: CEE_CONV_U2 (reg) {
 712         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
 713 }
 714
 715 reg: CEE_CONV_U4 (reg),
 716 reg: CEE_CONV_U (reg),
 717 reg: CEE_CONV_I (reg) {
 718         if (sizeof (void *) == 8)
 719                 MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 720         else
 721                 MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 722 }
 723
 724 reg: CEE_CONV_OVF_I4 (reg) {
 725         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 726 }
 727
 728 reg: CEE_CONV_OVF_U4 (reg),
 729 reg: CEE_CONV_OVF_I4_UN (reg) {
 730         if (sizeof (void *) == 8) {
 731                 MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 732         } else {
 733                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT, state->left->reg1, 0, "OverflowException");
 734                 MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 735         }
 736 }
 737
 738 reg: CEE_CONV_OVF_I1 (reg) {
 739         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT, state->left->reg1, 127, "OverflowException");
 740         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, LT, state->left->reg1, -128, "OverflowException");
 741         MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
 742 }
 743
 744 reg: CEE_CONV_OVF_I1_UN (reg) {
 745         /* probe values between 0 to 127 */
 746         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 127, "OverflowException");
 747         MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
 748 }
 749
 750 reg: CEE_CONV_OVF_U1 (reg),
 751 reg: CEE_CONV_OVF_U1_UN (reg) {
 752         /* probe value to be within 0 to 255 */
 753         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 255, "OverflowException");
 754         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
 755 }
 756
 757 reg: CEE_CONV_OVF_I2 (reg) {
 758         /* Probe value to be within -32768 and 32767 */
 759         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT, state->left->reg1, 32767, "OverflowException");
 760         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, LT, state->left->reg1, -32768, "OverflowException");
 761         MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
 762 }
 763
 764 reg: CEE_CONV_OVF_I2_UN (reg) {
 765         /* Convert uint value into short, value within 0 and 32767 */
 766         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 32767, "OverflowException");
 767         MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
 768 }
 769
 770 reg: CEE_CONV_OVF_U2 (reg),
 771 reg: CEE_CONV_OVF_U2_UN (reg) {
 772         /* Probe value to be within 0 and 65535 */
 773         MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 0xffff, "OverflowException");
 774         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
 775 }
 776
 777 #
 778 # other alu operations
 779 #
 780
 781 reg: OP_CEQ (cflags),
 782 reg: OP_CLT (cflags),
 783 reg: OP_CLT_UN (cflags),
 784 reg: OP_CGT (cflags),
 785 reg: OP_CGT_UN (cflags) "2" {
 786         tree->dreg = state->reg1;
 787         mono_bblock_add_inst (s->cbb, tree);
 788 }
 789
 790 #
 791 # control flow commands
 792 #
 793
 794 stmt: OP_LABEL {
 795         mono_bblock_add_inst (s->cbb, tree);
 796 }
 797
 798 stmt: OP_NOP "0" {
 799 }
 800
 801 stmt: OP_BREAK "0" {
 802         mono_bblock_add_inst (s->cbb, tree);
 803 }
 804
 805 reg: OP_TLS_GET {
 806         tree->dreg = state->reg1;
 807         mono_bblock_add_inst (s->cbb, tree);
 808 }
 809
 810 stmt: CEE_SWITCH (reg) "2" {
 811         MonoInst *label;
 812         int offset_reg = mono_regstate_next_int (s->rs);
 813         int target_reg = mono_regstate_next_int (s->rs);
 814         int n = GPOINTER_TO_INT (tree->klass);
 815
 816         MONO_NEW_LABEL (s, label);
 817
 818         if (sizeof (gpointer) == 8) {
 819                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ICOMPARE_IMM, -1, state->left->reg1, n);
 820                 MONO_EMIT_NEW_BRANCH_BLOCK (s, OP_IBGE_UN, tree->inst_many_bb [n]);
 821                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 3);
 822                 /* The upper word might not be zero, and we add it to a 64 bit address later */
 823                 MONO_EMIT_NEW_UNALU (s, CEE_CONV_U8, offset_reg, offset_reg);
 824         } else {
 825                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
 826                 MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
 827                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 2);
 828         }
 829         mono_bblock_add_inst (s->cbb, label);
 830         if (s->compile_aot) {
 831                 int table_reg = mono_regstate_next_int (s->rs);
 832                 int sum_reg = mono_regstate_next_int (s->rs);
 833                 MonoJumpInfoBBTable *table;
 834
 835                 table = mono_mempool_alloc (s->mempool, sizeof (MonoJumpInfoBBTable));
 836                 table->table = tree->inst_many_bb;
 837                 table->table_size = n;
 838
 839                 MONO_EMIT_NEW_AOTCONST (s, table_reg, table, MONO_PATCH_INFO_SWITCH);
 840
 841                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, table_reg, offset_reg);
 842                 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, sum_reg, 0);
 843         } else {
 844                 mono_create_jump_table (s, label, tree->inst_many_bb, n);
 845
 846                  /* the backend must patch the address. we use 0xf0f0f0f0 to avoid the usage
 847                   * of special (short) opcodes on x86 */
 848                 if (sizeof (gpointer) == 8)
 849                         MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, (long)0xf0f0f0f0f0f0f0f1LL);
 850                 else
 851                         MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, 0xf0f0f0f0);
 852         }
 853         MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg);
 854 }
 855
 856 stmt: OP_BR "0" {
 857         mono_bblock_add_inst (s->cbb, tree);
 858 }
 859
 860 stmt: OP_ARGLIST (reg) {
 861         tree->sreg1 = state->left->reg1;
 862         mono_bblock_add_inst (s->cbb, tree);
 863 }
 864
 865 reg: CEE_CALL {
 866         tree->dreg = state->reg1;
 867         mono_bblock_add_inst (s->cbb, tree);
 868 }
 869
 870 reg: CEE_CALLVIRT (reg) {
 871         mini_emit_virtual_call (s, state, tree, CEE_CALL, OP_CALL_MEMBASE);
 872 }
 873
 874 stmt: OP_VOIDCALLVIRT (reg) {
 875         mini_emit_virtual_call (s, state, tree, OP_VOIDCALL, OP_VOIDCALL_MEMBASE);
 876 }
 877
 878 freg: OP_FCALLVIRT (reg) {
 879         mini_emit_virtual_call (s, state, tree, OP_FCALL, OP_FCALL_MEMBASE);
 880 }
 881
 882 stmt: OP_VCALLVIRT (reg, reg) {
 883         mini_emit_virtual_call (s, state, tree, OP_VCALL, OP_VCALL_MEMBASE);
 884 }
 885
 886 reg: OP_CALL_REG (reg) {
 887         tree->sreg1 = state->left->reg1;
 888         tree->dreg = state->reg1;
 889         mono_bblock_add_inst (s->cbb, tree);
 890 }
 891
 892 stmt: OP_VOIDCALL {
 893         mono_bblock_add_inst (s->cbb, tree);
 894 }
 895
 896 stmt: OP_VOIDCALL_REG (reg) {
 897         tree->sreg1 = state->left->reg1;
 898         mono_bblock_add_inst (s->cbb, tree);
 899 }
 900
 901 freg: OP_FCALL {
 902         tree->dreg = state->reg1;
 903         mono_bblock_add_inst (s->cbb, tree);
 904 }
 905
 906 freg: OP_FCALL_REG (reg) {
 907         tree->sreg1 = state->left->reg1;
 908         tree->dreg = state->reg1;
 909         mono_bblock_add_inst (s->cbb, tree);
 910 }
 911
 912 stmt: OP_VCALL (reg) {
 913         mono_arch_emit_this_vret_args (s, (MonoCallInst*)tree, -1, -1, state->left->reg1);
 914         mono_bblock_add_inst (s->cbb, tree);
 915 }
 916
 917 stmt: OP_VCALL_REG (reg, reg) {
 918         mono_arch_emit_this_vret_args (s, (MonoCallInst*)tree, -1, -1, state->right->reg1);
 919
 920         tree->sreg1 = state->left->reg1;
 921         mono_bblock_add_inst (s->cbb, tree);
 922 }
 923
 924 stmt: OP_SAVE_LMF,
 925 stmt: OP_RESTORE_LMF {
 926         mono_bblock_add_inst (s->cbb, tree);
 927 }
 928
 929 #
 930 # Optimized call instructions
 931 #
 932
 933 reg: OP_CALL_REG (OP_ICONST),
 934 reg: OP_CALL_REG (OP_I8CONST) {
 935         tree->opcode = CEE_CALL;
 936         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 937         tree->dreg = state->reg1;
 938         mono_bblock_add_inst (s->cbb, tree);
 939 }
 940
 941 stmt: OP_VOIDCALL_REG (OP_ICONST),
 942 stmt: OP_VOIDCALL_REG (OP_I8CONST) {
 943         tree->opcode = OP_VOIDCALL;
 944         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 945         mono_bblock_add_inst (s->cbb, tree);
 946 }
 947
 948 freg: OP_FCALL_REG (OP_ICONST),
 949 freg: OP_FCALL_REG (OP_I8CONST) {
 950         tree->opcode = OP_FCALL;
 951         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 952         tree->dreg = state->reg1;
 953         mono_bblock_add_inst (s->cbb, tree);
 954 }
 955
 956 stmt: CEE_RET "0" {
 957         mono_bblock_add_inst (s->cbb, tree);
 958 }
 959
 960 stmt: CEE_POP (reg)
 961
 962 # remove some common pops without side effects
 963 stmt: CEE_POP (OP_ICONST)
 964 stmt: CEE_POP (CEE_LDIND_I1 (base))
 965 stmt: CEE_POP (CEE_LDIND_U1 (base))
 966 stmt: CEE_POP (CEE_LDIND_I2 (base))
 967 stmt: CEE_POP (CEE_LDIND_U2 (base))
 968 stmt: CEE_POP (CEE_LDIND_I4 (base))
 969 stmt: CEE_POP (CEE_LDIND_U4 (base))
 970 stmt: CEE_POP (CEE_LDIND_I (base))
 971 stmt: CEE_POP (CEE_LDIND_REF (base))
 972 stmt: CEE_POP (CEE_LDIND_I1 (OP_REGVAR))
 973 stmt: CEE_POP (CEE_LDIND_U1 (OP_REGVAR))
 974 stmt: CEE_POP (CEE_LDIND_I2 (OP_REGVAR))
 975 stmt: CEE_POP (CEE_LDIND_U2 (OP_REGVAR))
 976 stmt: CEE_POP (CEE_LDIND_I4 (OP_REGVAR))
 977 stmt: CEE_POP (CEE_LDIND_U4 (OP_REGVAR))
 978 stmt: CEE_POP (CEE_LDIND_I (OP_REGVAR))
 979 stmt: CEE_POP (CEE_LDIND_REF (OP_REGVAR))
 980
 981 stmt: OP_JMP "0" {
 982         mono_bblock_add_inst (s->cbb, tree);
 983 }
 984
 985 # exception handling
 986
 987 stmt: OP_THROW (reg) {
 988         MONO_EMIT_UNALU (s, tree, OP_THROW, -1, state->left->reg1);
 989 }
 990
 991 stmt: OP_RETHROW (reg) {
 992         MONO_EMIT_UNALU (s, tree, OP_RETHROW, -1, state->left->reg1);
 993 }
 994
 995 stmt: OP_THROW_OR_NULL (reg, reg) {
 996         MonoInst *dont_throw;
 997
 998         MONO_NEW_LABEL (s, dont_throw);
 999
1000         /*
1001          * Currently, we allways rethrow the abort exception, despite the fact
1002          * that this is not correct. See thread6.cs for an example. But propagating
1003          * the abort exception is more important than getting the sematics right.
1004          */
1005         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, state->left->reg1, 0, dont_throw);
1006         MONO_EMIT_UNALU (s, tree, OP_THROW, -1, state->left->reg1);
1007         mono_bblock_add_inst (s->cbb, dont_throw);
1008 }
1009
1010 stmt: OP_THROW (CEE_LDIND_REF (OP_REGVAR)) {
1011         MONO_EMIT_UNALU (s, tree, OP_THROW, -1, state->left->left->tree->dreg);
1012 }
1013
1014 stmt: OP_CALL_HANDLER {
1015         mono_bblock_add_inst (s->cbb, tree);
1016 }
1017
1018 stmt: OP_START_HANDLER "2" {
1019         mono_bblock_add_inst (s->cbb, tree);
1020 }
1021
1022 stmt: OP_ENDFINALLY "2" {
1023         mono_bblock_add_inst (s->cbb, tree);
1024 }
1025
1026 stmt: OP_ENDFILTER (reg) "2" {
1027         MONO_EMIT_UNALU (s, tree, OP_ENDFILTER, -1, state->left->reg1);
1028 }
1029
1030 stmt: OP_CHECK_THIS (reg) {
1031         tree->sreg1 = state->left->reg1;
1032         tree->dreg = state->reg1;
1033         mono_bblock_add_inst (s->cbb, tree);
1034 }
1035
1036 # object related opcodes
1037
1038 reg: CEE_ISINST (reg) {
1039         MonoClass *klass = tree->inst_newa_class;
1040         MonoInst *object_is_null, *end_label, *false_label;
1041         int obj_reg = state->left->reg1;
1042         int vtable_reg = mono_regstate_next_int (s->rs);
1043
1044         MONO_NEW_LABEL (s, object_is_null);
1045         MONO_NEW_LABEL (s, end_label);
1046         MONO_NEW_LABEL (s, false_label);
1047
1048         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, object_is_null);
1049
1050         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1051                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1052                 /* the object_is_null target simply copies the input register to the output */
1053                 mini_emit_isinst_iface (s, vtable_reg, klass, false_label, object_is_null);
1054         } else {
1055                 int klass_reg = mono_regstate_next_int (s->rs);
1056
1057                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1058
1059                 if (klass->rank) {
1060                         int rank_reg = mono_regstate_next_int (s->rs);
1061                         int eclass_reg = mono_regstate_next_int (s->rs);
1062
1063                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
1064                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, rank_reg, klass->rank, false_label);
1065                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1066                         MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1067                         if (klass->cast_class == mono_defaults.object_class) {
1068                                 int parent_reg = mono_regstate_next_int (s->rs);
1069                                 int const_reg = -1;
1070                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
1071                                 if (s->compile_aot) {
1072                                         const_reg = mono_regstate_next_int (s->rs);
1073                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1074                                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg,
1075                                                         const_reg, object_is_null);
1076                                 } else {
1077                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg,
1078                                                         mono_defaults.enum_class->parent, object_is_null);
1079                                 }
1080                                 if (s->compile_aot) {
1081                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1082                                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null);
1083                                 } else {
1084                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg,
1085                                                 mono_defaults.enum_class, object_is_null);
1086                                 }
1087                                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false_label);
1088                         } else if (klass->cast_class == mono_defaults.enum_class->parent) {
1089                                 int const_reg = -1;
1090
1091                                 if (s->compile_aot) {
1092                                         const_reg = mono_regstate_next_int (s->rs);
1093                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1094                                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null);
1095                                 } else {
1096                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg,
1097                                                 mono_defaults.enum_class->parent, object_is_null);
1098                                 }
1099                                 if (s->compile_aot) {
1100                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1101                                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null);
1102                                 } else {
1103                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg,
1104                                                 mono_defaults.enum_class, object_is_null);
1105                                 }
1106                                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false_label);
1107                         } else if (klass->cast_class == mono_defaults.enum_class) {
1108                                 if (s->compile_aot) {
1109                                         int const_reg = mono_regstate_next_int (s->rs);
1110                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1111                                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null);
1112                                 } else {
1113                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg,
1114                                                 mono_defaults.enum_class, object_is_null);
1115                                 }
1116                                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false_label);
1117                         } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
1118                                 mini_emit_isinst_iface_class (s, eclass_reg, klass->cast_class, false_label, object_is_null);
1119                         } else {
1120                                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
1121                                         /* Check that the object is a vector too */
1122                                         int bounds_reg = mono_regstate_next_int (s->rs);
1123                                         MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
1124                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, bounds_reg, 0, false_label);
1125                                 }
1126
1127                                 /* the object_is_null target simply copies the input register to the output */
1128                                 mini_emit_isinst (s, eclass_reg, klass->cast_class, false_label, object_is_null);
1129                         }
1130                 } else if (mono_class_is_nullable (klass)) {
1131                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1132                         /* the object_is_null target simply copies the input register to the output */
1133                         mini_emit_isinst (s, klass_reg, klass->cast_class, false_label, object_is_null);
1134                 } else {
1135                         if (!s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
1136                                 /* the remoting code is broken, access the class for now */
1137                                 if (0) {
1138                                         MonoVTable *vt = mono_class_vtable (s->domain, klass);
1139                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, vtable_reg, vt, false_label);
1140                                 } else {
1141                                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1142                                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, klass, false_label);
1143                                 }
1144                                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, object_is_null);
1145                         } else {
1146                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1147                                 /* the object_is_null target simply copies the input register to the output */
1148                                 mini_emit_isinst (s, klass_reg, klass, false_label, object_is_null);
1149                         }
1150                 }
1151         }
1152
1153         mono_bblock_add_inst (s->cbb, false_label);
1154         MONO_EMIT_NEW_ICONST (s, state->reg1, 0);
1155         MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label);
1156         mono_bblock_add_inst (s->cbb, object_is_null);
1157         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
1158         mono_bblock_add_inst (s->cbb, end_label);
1159 }
1160
1161 reg: OP_CISINST (reg) {
1162         /* This opcode takes as input an object reference and a class, and returns:
1163         0) if the object is an instance of the class,
1164         1) if the object is not instance of the class,
1165         2) if the object is a proxy whose type cannot be determined */
1166
1167         MonoClass *klass = tree->inst_newa_class;
1168         MonoInst *end_label, *true_label, *false_label, *false2_label;
1169         MonoInst *no_proxy_label, *interface_fail_label;
1170         int obj_reg = state->left->reg1;
1171         int tmp_reg = mono_regstate_next_int (s->rs);
1172         int klass_reg = mono_regstate_next_int (s->rs);
1173
1174         MONO_NEW_LABEL (s, end_label);
1175         MONO_NEW_LABEL (s, true_label);
1176         MONO_NEW_LABEL (s, false_label);
1177         MONO_NEW_LABEL (s, false2_label);
1178
1179         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, false_label);
1180
1181         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1182                 MONO_NEW_LABEL (s, interface_fail_label);
1183                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1184                 mini_emit_isinst_iface (s, tmp_reg, klass, interface_fail_label, true_label);
1185
1186                 mono_bblock_add_inst (s->cbb, interface_fail_label);
1187                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1188
1189                 if (s->compile_aot) {
1190                         int tproxy_reg = mono_regstate_next_int (s->rs);
1191                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1192                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, tproxy_reg, false_label);
1193                 } else {
1194                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg,
1195                                 mono_defaults.transparent_proxy_class, false_label);
1196                 }
1197
1198                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1199                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, tmp_reg, 0, false2_label);
1200
1201         } else {
1202                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1203                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1204
1205                 MONO_NEW_LABEL (s, no_proxy_label);
1206
1207                 if (s->compile_aot) {
1208                         int tproxy_reg = mono_regstate_next_int (s->rs);
1209                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1210                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, tproxy_reg, no_proxy_label);
1211                 } else {
1212                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg,
1213                                 mono_defaults.transparent_proxy_class, no_proxy_label);
1214                 }
1215                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1216                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1217
1218                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1219                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, tmp_reg, 0, no_proxy_label);
1220
1221                 mini_emit_isinst (s, klass_reg, klass, false2_label, true_label);
1222                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false2_label);
1223
1224                 mono_bblock_add_inst (s->cbb, no_proxy_label);
1225                 mini_emit_isinst (s, klass_reg, klass, false_label, true_label);
1226         }
1227
1228         mono_bblock_add_inst (s->cbb, false_label);
1229         MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
1230         MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label);
1231         mono_bblock_add_inst (s->cbb, false2_label);
1232         MONO_EMIT_NEW_ICONST (s, state->reg1, 2);
1233         MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label);
1234         mono_bblock_add_inst (s->cbb, true_label);
1235         MONO_EMIT_NEW_ICONST (s, state->reg1, 0);
1236         mono_bblock_add_inst (s->cbb, end_label);
1237 }
1238
1239 reg: OP_UNBOXCAST (reg) {
1240         MonoClass *klass = tree->inst_newa_class;
1241         int obj_reg = state->left->reg1;
1242         int vtable_reg = mono_regstate_next_int (s->rs);
1243         int klass_reg = mono_regstate_next_int (s->rs);
1244         int eclass_reg = mono_regstate_next_int (s->rs);
1245         int rank_reg = mono_regstate_next_int (s->rs);
1246
1247         MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1248         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
1249
1250         /* FIXME: generics */
1251         g_assert (klass->rank == 0);
1252
1253         // Check rank == 0
1254         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, 0, "InvalidCastException");
1255
1256         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1257         MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
1258
1259         if (s->compile_aot) {
1260                 int const_reg = mono_regstate_next_int (s->rs);
1261                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass->element_class);
1262                 MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
1263         } else {
1264                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, klass->element_class, "InvalidCastException");
1265         }
1266
1267         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
1268 }
1269
1270 reg: CEE_CASTCLASS (reg) {
1271         MonoClass *klass = tree->inst_newa_class;
1272         MonoInst *object_is_null;
1273         int obj_reg = state->left->reg1;
1274         int vtable_reg = mono_regstate_next_int (s->rs);
1275
1276         MONO_NEW_LABEL (s, object_is_null);
1277
1278         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, object_is_null);
1279
1280         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1281                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1282                 mini_emit_castclass_iface (s, vtable_reg, klass);
1283         } else {
1284                 int klass_reg = mono_regstate_next_int (s->rs);
1285
1286                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1287
1288                 if (!klass->rank && !s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
1289                         /* the remoting code is broken, access the class for now */
1290                         if (0) {
1291                                 MonoVTable *vt = mono_class_vtable (s->domain, klass);
1292                                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, vtable_reg, vt, "InvalidCastException");
1293                         } else {
1294                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1295                                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, klass, "InvalidCastException");
1296                         }
1297                 } else {
1298                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1299                         mini_emit_castclass (s, obj_reg, klass_reg, klass, object_is_null);
1300                 }
1301         }
1302
1303         mono_bblock_add_inst (s->cbb, object_is_null);
1304         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
1305 }
1306
1307 reg: OP_CCASTCLASS (reg) {
1308         /* This opcode takes as input an object reference and a class, and returns:
1309         0) if the object is an instance of the class,
1310         1) if the object is a proxy whose type cannot be determined
1311         an InvalidCastException exception is thrown otherwhise*/
1312
1313         MonoClass *klass = tree->inst_newa_class;
1314         MonoInst *end_label, *fail_label, *no_proxy_label, *ok_result_label;
1315         int obj_reg = state->left->reg1;
1316         int tmp_reg = mono_regstate_next_int (s->rs);
1317         int klass_reg = mono_regstate_next_int (s->rs);
1318
1319         MONO_NEW_LABEL (s, end_label);
1320         MONO_NEW_LABEL (s, ok_result_label);
1321
1322         /* Return 0 if the object is null */
1323         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, ok_result_label);
1324
1325         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1326
1327                 MONO_NEW_LABEL (s, fail_label);
1328
1329                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1330                 mini_emit_isinst_iface (s, tmp_reg, klass, fail_label, ok_result_label);
1331
1332                 mono_bblock_add_inst (s->cbb, fail_label);
1333                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1334
1335                 if (s->compile_aot) {
1336                         int tproxy_reg = mono_regstate_next_int (s->rs);
1337                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1338                         MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, tproxy_reg, "InvalidCastException");
1339                 } else {
1340                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, mono_defaults.transparent_proxy_class, "InvalidCastException");
1341                 }
1342
1343
1344                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1345                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1346
1347                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1348                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, tmp_reg, 0, "InvalidCastException");
1349
1350                 MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
1351                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label);
1352
1353         } else {
1354
1355                 MONO_NEW_LABEL (s, no_proxy_label);
1356                 MONO_NEW_LABEL (s, fail_label);
1357
1358                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1359                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1360
1361                 if (s->compile_aot) {
1362                         int tproxy_reg = mono_regstate_next_int (s->rs);
1363                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1364                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, tproxy_reg, no_proxy_label);
1365                 } else {
1366                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg,
1367                                 mono_defaults.transparent_proxy_class, no_proxy_label);
1368                 }
1369
1370                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1371                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1372
1373                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1374                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, tmp_reg, 0, no_proxy_label);
1375
1376                 mini_emit_isinst (s, klass_reg, klass, fail_label, ok_result_label);
1377                 mono_bblock_add_inst (s->cbb, fail_label);
1378                 MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
1379                 MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label);
1380
1381                 mono_bblock_add_inst (s->cbb, no_proxy_label);
1382                 /* Again, use ok_result_label as "object_is_null" */
1383                 mini_emit_castclass (s, obj_reg, klass_reg, klass, ok_result_label);
1384         }
1385
1386         mono_bblock_add_inst (s->cbb, ok_result_label);
1387         MONO_EMIT_NEW_ICONST (s, state->reg1, 0);
1388         mono_bblock_add_inst (s->cbb, end_label);
1389 }
1390
1391 stmt: CEE_STELEM_REF (OP_GROUP (reg, reg), reg),
1392 reg: OP_GROUP (reg, reg),
1393 reg: CEE_NEWARR (reg),
1394 lreg: OP_LMUL (lreg, lreg),
1395 lreg: OP_LMUL_OVF (lreg, lreg),
1396 lreg: OP_LMUL_OVF_UN (lreg, lreg),
1397 lreg: OP_LDIV (lreg, lreg),
1398 lreg: OP_LDIV_UN (lreg, lreg),
1399 lreg: OP_LREM (lreg, lreg),
1400 lreg: OP_LREM_UN (lreg, lreg),
1401 lreg: OP_LSHL (lreg, reg),
1402 lreg: OP_LSHR (lreg, reg),
1403 lreg: OP_LSHR_UN (lreg, reg) {
1404         g_assert_not_reached ();
1405 }
1406
1407 #
1408 # string support
1409 #
1410 reg: OP_GETCHR (reg, reg) "4" {
1411         int mult_reg = mono_regstate_next_int (s->rs);
1412         int add_reg = mono_regstate_next_int (s->rs);
1413
1414         MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoString, length, state->right->reg1);
1415         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, mult_reg, state->right->reg1, 1);
1416         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1);
1417         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU2_MEMBASE, state->reg1,
1418                                    add_reg, G_STRUCT_OFFSET (MonoString, chars));
1419 }
1420
1421 reg: OP_GETCHR (reg, OP_ICONST) {
1422         int ind = 2 * state->right->tree->inst_c0 + G_STRUCT_OFFSET (MonoString, chars);
1423
1424         MONO_EMIT_BOUNDS_CHECK_IMM (s, state->left->reg1, MonoString, length, state->right->tree->inst_c0);
1425         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU2_MEMBASE, state->reg1, state->left->reg1, ind);
1426 }
1427
1428 reg: OP_STR_CHAR_ADDR (reg, reg) "4" {
1429         int mult_reg = mono_regstate_next_int (s->rs);
1430         int add_reg = mono_regstate_next_int (s->rs);
1431
1432         /*
1433          * The corlib functions check for oob already.
1434          * MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoString, length, state->right->reg1);
1435          */
1436         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, mult_reg, state->right->reg1, 1);
1437         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1);
1438         MONO_EMIT_BIALU_IMM (s, tree, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoString, chars));
1439 }
1440
1441 reg: OP_STRLEN (reg) {
1442         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->reg1,
1443                                    state->left->reg1, G_STRUCT_OFFSET (MonoString, length));
1444 }
1445
1446 reg: OP_GETTYPE (reg) {
1447         int vt_reg = mono_regstate_next_int (s->rs);
1448         MONO_EMIT_NEW_LOAD_MEMBASE (s, vt_reg, state->left->reg1, G_STRUCT_OFFSET (MonoObject, vtable));
1449         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOAD_MEMBASE, state->reg1, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
1450 }
1451
1452 reg: OP_GETHASHCODE (reg) {
1453         int t1 = mono_regstate_next_int (s->rs);
1454
1455         #define MONO_OBJECT_ALIGNMENT_SHIFT     3
1456
1457         /* return (GPOINTER_TO_UINT (this) >> MONO_OBJECT_ALIGNMENT_SHIFT) * 2654435761u; */
1458
1459         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, t1, state->left->reg1, MONO_OBJECT_ALIGNMENT_SHIFT);
1460         MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, state->reg1, t1, 2654435761u);
1461 }
1462
1463 #
1464 # array support
1465 #
1466 reg: CEE_LDLEN (reg) {
1467         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->reg1,
1468                                    state->left->reg1, G_STRUCT_OFFSET (MonoArray, max_length));
1469 }
1470
1471 reg: OP_ARRAY_RANK (reg) {
1472         int vtable_reg = mono_regstate_next_int (s->rs);
1473         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, vtable_reg,
1474                                        state->left->reg1, G_STRUCT_OFFSET (MonoObject, vtable));
1475         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, state->reg1,
1476                                        vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
1477 }
1478
1479 reg: OP_CHECK_ARRAY_TYPE (reg) {
1480
1481         MonoClass* array_class = mono_array_class_get (tree->klass, 1);
1482
1483         int vtable_reg = mono_regstate_next_int (s->rs);
1484
1485         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, vtable_reg,
1486                                        state->left->reg1, G_STRUCT_OFFSET (MonoObject, vtable));
1487
1488         if (s->opt & MONO_OPT_SHARED) {
1489                 int class_reg = mono_regstate_next_int (s->rs);
1490                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, class_reg,
1491                                                vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1492                 if (s->compile_aot) {
1493                         int klass_reg = mono_regstate_next_int (s->rs);
1494                         MONO_EMIT_NEW_CLASSCONST (s, klass_reg, array_class);
1495                         MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, class_reg, klass_reg, "ArrayTypeMismatchException");
1496                 } else {
1497                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, class_reg, array_class, "ArrayTypeMismatchException");
1498                 }
1499         } else {
1500                 if (s->compile_aot) {
1501                         int vt_reg = mono_regstate_next_int (s->rs);
1502                         MONO_EMIT_NEW_VTABLECONST (s, vt_reg, mono_class_vtable (s->domain, array_class));
1503                         MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, vtable_reg, vt_reg, "ArrayTypeMismatchException");
1504                 } else {
1505                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, vtable_reg, mono_class_vtable (s->domain, array_class), "ArrayTypeMismatchException");
1506                 }
1507         }
1508
1509         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
1510 }
1511
1512 reg: CEE_LDELEMA (reg, OP_ICONST) "15" {
1513         guint32 size = mono_class_array_element_size (tree->klass);
1514
1515         int ind = size * state->right->tree->inst_c0 + G_STRUCT_OFFSET (MonoArray, vector);
1516
1517         MONO_EMIT_BOUNDS_CHECK_IMM (s, state->left->reg1, MonoArray, max_length, state->right->tree->inst_c0);
1518         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->left->reg1, ind);
1519 }
1520
1521 reg: CEE_LDELEMA (reg, reg) "20" {
1522         int mult_reg = mono_regstate_next_int (s->rs);
1523         int add_reg = mono_regstate_next_int (s->rs);
1524         guint32 size = mono_class_array_element_size (tree->klass);
1525
1526         MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoArray, max_length, state->right->reg1);
1527         MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, mult_reg, state->right->reg1, size);
1528         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1);
1529         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoArray, vector));
1530 }
1531
1532 reg: CEE_REFANYVAL (reg) {
1533         int klass_reg = mono_regstate_next_int (s->rs);
1534         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass));
1535         if (s->compile_aot) {
1536                 int const_reg = mono_regstate_next_int (s->rs);
1537                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, tree->inst_newa_class);
1538                 MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, const_reg, "InvalidCastException");
1539         } else {
1540                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, tree->inst_newa_class, "InvalidCastException");
1541         }
1542         MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, value));
1543 }
1544
1545 reg: OP_REFANYTYPE (reg) {
1546         MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, type));
1547 }
1548
1549 stmt: CEE_MKREFANY (OP_GROUP (reg, OP_ICONST), reg),
1550 stmt: CEE_MKREFANY (OP_GROUP (reg, OP_I8CONST), reg) {
1551         MonoClass *klass = (MonoClass*)(tree->inst_left->inst_right->inst_p0);
1552         if (s->compile_aot) {
1553                 int const_reg = mono_regstate_next_int (s->rs);
1554                 int type_reg = mono_regstate_next_int (s->rs);
1555                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
1556                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
1557                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
1558                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
1559         }
1560         else {
1561                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STOREP_MEMBASE_IMM, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
1562                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STOREP_MEMBASE_IMM, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
1563         }
1564         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, value), state->left->left->reg1);
1565 }
1566
1567 reg: OP_MIN (reg, reg) "2" {
1568         /* min (x,y) = y + (((x-y)>>31)&(x-y)); */
1569         int diff = mono_regstate_next_int (s->rs);
1570         int shifted = mono_regstate_next_int (s->rs);
1571         int anded = mono_regstate_next_int (s->rs);
1572         MONO_EMIT_NEW_BIALU (s, CEE_SUB, diff, state->left->reg1, state->right->reg1);
1573         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHR_IMM, shifted, diff, (sizeof(void*)*8-1));
1574         MONO_EMIT_NEW_BIALU (s, CEE_AND, anded, shifted, diff);
1575         MONO_EMIT_NEW_BIALU (s, CEE_ADD, state->reg1, anded, state->right->reg1);
1576 }
1577
1578 reg: OP_MAX (reg, reg) "2" {
1579         /* max (x,y) = x - (((x-y)>>31)&(x-y)); */
1580         int diff = mono_regstate_next_int (s->rs);
1581         int shifted = mono_regstate_next_int (s->rs);
1582         int anded = mono_regstate_next_int (s->rs);
1583         MONO_EMIT_NEW_BIALU (s, CEE_SUB, diff, state->left->reg1, state->right->reg1);
1584         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHR_IMM, shifted, diff, (sizeof(void*)*8-1));
1585         MONO_EMIT_NEW_BIALU (s, CEE_AND, anded, shifted, diff);
1586         MONO_EMIT_NEW_BIALU (s, CEE_SUB, state->reg1, state->left->reg1, anded);
1587 }
1588
1589 %%
1590
1591 #ifdef MONO_ARCH_NEED_GOT_VAR
1592
1593 static void mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpointer cons);
1594
1595 #endif
1596
1597 /*
1598  * Emit code which checks whenever the interface id of @klass is smaller than
1599  * than the value given by max_iid_reg.
1600 */
1601 static void
1602 mini_emit_max_iid_check (MonoCompile *s, int max_iid_reg, MonoClass *klass,
1603                                                  MonoInst *false_target)
1604 {
1605         if (s->compile_aot) {
1606                 int iid_reg = mono_regstate_next_int (s->rs);
1607                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
1608                 if (false_target)
1609                         MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BLT_UN, max_iid_reg, iid_reg, false_target);
1610                 else
1611                         MONO_EMIT_NEW_COMPARE_EXC (s, LT_UN, max_iid_reg, iid_reg, "InvalidCastException");
1612         } else {
1613                 if (false_target)
1614                         MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BLT_UN, max_iid_reg, klass->interface_id, false_target);
1615                 else
1616                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT_UN, max_iid_reg, klass->interface_id, "InvalidCastException");
1617         }
1618 }
1619
1620 /* Same as above, but obtains max_iid from a vtable */
1621 static void
1622 mini_emit_max_iid_check_vtable (MonoCompile *s, int vtable_reg, MonoClass *klass,
1623                                                                  MonoInst *false_target)
1624 {
1625         int max_iid_reg = mono_regstate_next_int (s->rs);
1626
1627         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1628         mini_emit_max_iid_check (s, max_iid_reg, klass, false_target);
1629 }
1630
1631 /* Same as above, but obtains max_iid from a klass */
1632 static void
1633 mini_emit_max_iid_check_class (MonoCompile *s, int klass_reg, MonoClass *klass,
1634                                                                  MonoInst *false_target)
1635 {
1636         int max_iid_reg = mono_regstate_next_int (s->rs);
1637
1638         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1639         mini_emit_max_iid_check (s, max_iid_reg, klass, false_target);
1640 }
1641
1642 /* Emit code which loads interface_offsets [klass->interface_id]
1643  * The array is stored in memory before vtable.
1644  */
1645 #ifndef MONO_ARCH_HAVE_IMT
1646 static void
1647 mini_emit_load_intf_reg_vtable (MonoCompile *s, int intf_reg, int vtable_reg, MonoClass *klass)
1648 {
1649         if (s->compile_aot) {
1650                 int ioffset_reg = mono_regstate_next_int (s->rs);
1651                 int iid_reg = mono_regstate_next_int (s->rs);
1652                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_ADJUSTED_IID);
1653                 MONO_EMIT_NEW_BIALU (s, OP_PADD, ioffset_reg, iid_reg, vtable_reg);
1654                 MONO_EMIT_NEW_LOAD_MEMBASE (s, intf_reg, ioffset_reg, 0);
1655         } else {
1656                 MONO_EMIT_NEW_LOAD_MEMBASE (s, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1657         }
1658 }
1659 #endif
1660
1661 /*
1662  * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass
1663  * stored in "klass_reg" implements the interface "klass".
1664  */
1665 static void
1666 mini_emit_load_intf_bit_reg_class (MonoCompile *s, int intf_bit_reg, int klass_reg, MonoClass *klass)
1667 {
1668         int ibitmap_reg = mono_regstate_next_int (s->rs);
1669         int ibitmap_byte_reg = mono_regstate_next_int (s->rs);
1670
1671         MONO_EMIT_NEW_LOAD_MEMBASE (s, ibitmap_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap));
1672
1673         if (s->compile_aot) {
1674                 int iid_reg = mono_regstate_next_int (s->rs);
1675                 int shifted_iid_reg = mono_regstate_next_int (s->rs);
1676                 int ibitmap_byte_address_reg = mono_regstate_next_int (s->rs);
1677                 int masked_iid_reg = mono_regstate_next_int (s->rs);
1678                 int iid_one_bit_reg = mono_regstate_next_int (s->rs);
1679                 int iid_bit_reg = mono_regstate_next_int (s->rs);
1680                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
1681                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHR_IMM, shifted_iid_reg, iid_reg, 3);
1682                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, ibitmap_byte_address_reg, ibitmap_reg, shifted_iid_reg);
1683                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1684                 MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, masked_iid_reg, iid_reg, 7);
1685                 MONO_EMIT_NEW_ICONST (s, iid_one_bit_reg, 1);
1686                 MONO_EMIT_NEW_BIALU (s, CEE_SHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg);
1687                 MONO_EMIT_NEW_BIALU (s, CEE_AND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg);
1688         } else {
1689                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1690                 MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1691         }
1692 }
1693 /*
1694  * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable
1695  * stored in "vtable_reg" implements the interface "klass".
1696  */
1697 static void
1698 mini_emit_load_intf_bit_reg_vtable (MonoCompile *s, int intf_bit_reg, int vtable_reg, MonoClass *klass)
1699 {
1700         int ibitmap_reg = mono_regstate_next_int (s->rs);
1701         int ibitmap_byte_reg = mono_regstate_next_int (s->rs);
1702
1703         MONO_EMIT_NEW_LOAD_MEMBASE (s, ibitmap_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap));
1704
1705         if (s->compile_aot) {
1706                 int iid_reg = mono_regstate_next_int (s->rs);
1707                 int shifted_iid_reg = mono_regstate_next_int (s->rs);
1708                 int ibitmap_byte_address_reg = mono_regstate_next_int (s->rs);
1709                 int masked_iid_reg = mono_regstate_next_int (s->rs);
1710                 int iid_one_bit_reg = mono_regstate_next_int (s->rs);
1711                 int iid_bit_reg = mono_regstate_next_int (s->rs);
1712                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
1713                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHR_IMM, shifted_iid_reg, iid_reg, 3);
1714                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, ibitmap_byte_address_reg, ibitmap_reg, shifted_iid_reg);
1715                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0);
1716                 MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, masked_iid_reg, iid_reg, 7);
1717                 MONO_EMIT_NEW_ICONST (s, iid_one_bit_reg, 1);
1718                 MONO_EMIT_NEW_BIALU (s, CEE_SHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg);
1719                 MONO_EMIT_NEW_BIALU (s, CEE_AND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg);
1720         } else {
1721                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3);
1722                 MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7));
1723         }
1724 }
1725
1726 #ifdef MONO_ARCH_HAVE_IMT
1727 static void
1728 emit_imt_argument (MonoCompile *cfg, MonoCallInst *call) {
1729 #ifdef MONO_ARCH_IMT_REG
1730         int method_reg = mono_regstate_next_int (cfg->rs);
1731
1732         if (cfg->compile_aot) {
1733                 MONO_EMIT_NEW_AOTCONST (cfg, method_reg, call->method, MONO_PATCH_INFO_METHODCONST);
1734         } else {
1735                 MonoInst *inst;
1736                 MONO_INST_NEW (cfg, inst, OP_PCONST);
1737                 inst->inst_p0 = call->method;
1738                 inst->dreg = method_reg;
1739                 mono_bblock_add_inst (cfg->cbb, inst);
1740         }
1741
1742         mono_call_inst_add_outarg_reg (cfg, call, method_reg, MONO_ARCH_IMT_REG, FALSE);
1743 #else
1744         mono_arch_emit_imt_argument (cfg, call);
1745 #endif
1746 }
1747 #endif
1748
1749 static void
1750 mini_emit_virtual_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop, int virtop)
1751 {
1752         MonoMethod *method = ((MonoCallInst*)tree)->method;
1753         int vtable_reg, slot_reg, this_reg;
1754         MBState *state = st;
1755
1756         this_reg = state->left->reg1;
1757         mono_arch_emit_this_vret_args (cfg, (MonoCallInst*)tree, this_reg, state->left->tree->type, novirtop == OP_VCALL? state->right->reg1: -1);
1758
1759         if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
1760              ((method->flags & METHOD_ATTRIBUTE_FINAL) &&
1761              method->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)) {
1762                 /*
1763                  * the method is not virtual, we just need to ensure this is not null
1764                  * and then we can call the method directly.
1765                  */
1766                 if (method->klass->marshalbyref || method->klass == mono_defaults.object_class) {
1767                         method = ((MonoCallInst*)tree)->method = mono_marshal_get_remoting_invoke_with_check (method);
1768                 }
1769
1770                 if (!method->string_ctor)
1771                         MONO_EMIT_NEW_UNALU (cfg, OP_CHECK_THIS, -1, this_reg);
1772
1773                 tree->dreg = state->reg1;
1774                 tree->opcode = novirtop;
1775                 mono_bblock_add_inst (cfg->cbb, tree);
1776                 return;
1777         }
1778
1779 #ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
1780         if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) {
1781                 /* Make a call to delegate->invoke_impl */
1782                 tree->dreg = state->reg1;
1783                 tree->opcode = virtop;
1784                 tree->inst_basereg = this_reg;
1785                 tree->inst_offset = G_STRUCT_OFFSET (MonoDelegate, invoke_impl);
1786                 mono_bblock_add_inst (cfg->cbb, tree);
1787                 return;
1788         }
1789 #endif
1790
1791         if ((method->flags & METHOD_ATTRIBUTE_VIRTUAL) &&
1792                 ((method->flags &  METHOD_ATTRIBUTE_FINAL) ||
1793                         (method->klass && method->klass->flags & TYPE_ATTRIBUTE_SEALED))) {
1794                 /*
1795                  * the method is virtual, but we can statically dispatch since either
1796                  * it's class or the method itself are sealed.
1797                  * But first we need to ensure it's not a null reference.
1798                  */
1799                 MONO_EMIT_NEW_UNALU (cfg, OP_CHECK_THIS, -1, this_reg);
1800
1801                 tree->dreg = state->reg1;
1802                 tree->opcode = novirtop;
1803                 mono_bblock_add_inst (cfg->cbb, tree);
1804                 return;
1805         }
1806
1807         /* Initialize method->slot */
1808         mono_class_setup_vtable (method->klass);
1809
1810         vtable_reg = mono_regstate_next_int (cfg->rs);
1811         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1812         if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1813 #ifdef MONO_ARCH_HAVE_IMT
1814                 guint32 imt_slot = mono_method_get_imt_slot (method);
1815                 emit_imt_argument (cfg, (MonoCallInst*)tree);
1816                 slot_reg = vtable_reg;
1817                 tree->inst_offset = ((gint32)imt_slot - MONO_IMT_SIZE) * SIZEOF_VOID_P;
1818 #else
1819                 slot_reg = mono_regstate_next_int (cfg->rs);
1820                 mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, method->klass);
1821                 tree->inst_offset = method->slot * SIZEOF_VOID_P;
1822 #endif
1823         } else {
1824                 slot_reg = vtable_reg;
1825                 tree->inst_offset = G_STRUCT_OFFSET (MonoVTable, vtable) + (method->slot * SIZEOF_VOID_P);
1826         }
1827
1828         tree->dreg = state->reg1;
1829         tree->opcode = virtop;
1830         tree->sreg1 = slot_reg;
1831         ((MonoCallInst*)tree)->virtual = TRUE;
1832         mono_bblock_add_inst (cfg->cbb, tree);
1833 }
1834
1835 /*
1836  * Emit code for ISINST/CASTCLASS
1837  */
1838 static void
1839 mini_emit_isinst (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target)
1840 {
1841         int idepth_reg = mono_regstate_next_int (s->rs);
1842         int stypes_reg = mono_regstate_next_int (s->rs);
1843         int stype = mono_regstate_next_int (s->rs);
1844
1845         if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1846                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1847                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BLT_UN, idepth_reg, klass->idepth, false_target);
1848         }
1849         MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1850         MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1851         if (s->compile_aot) {
1852                 int const_reg = mono_regstate_next_int (s->rs);
1853                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
1854                 MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, stype, const_reg, true_target);
1855         } else {
1856                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, stype, klass, true_target);
1857         }
1858 }
1859
1860 /*
1861  * Emit code for ISINST/CASTCLASS for interfaces
1862  */
1863 static void
1864 mini_emit_isinst_iface (MonoCompile *s, int vtable_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target)
1865 {
1866         int intf_reg = mono_regstate_next_int (s->rs);
1867
1868         mini_emit_max_iid_check_vtable (s, vtable_reg, klass, false_target);
1869         mini_emit_load_intf_bit_reg_vtable (s, intf_reg, vtable_reg, klass);
1870         if (true_target)
1871                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, intf_reg, 0, true_target);
1872         else
1873                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, intf_reg, 0, "InvalidCastException");
1874 }
1875
1876 /*
1877  * Variant of the above that takes a register to the class, not the vtable.
1878  */
1879 static void
1880 mini_emit_isinst_iface_class (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target)
1881 {
1882         int intf_bit_reg = mono_regstate_next_int (s->rs);
1883
1884         mini_emit_max_iid_check_class (s, klass_reg, klass, false_target);
1885         mini_emit_load_intf_bit_reg_class (s, intf_bit_reg, klass_reg, klass);
1886         if (true_target)
1887                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, intf_bit_reg, 0, true_target);
1888         else
1889                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, intf_bit_reg, 0, "InvalidCastException");
1890 }
1891
1892 static void
1893 mini_emit_castclass_iface (MonoCompile *s, int vtable_reg, MonoClass *klass)
1894 {
1895         mini_emit_isinst_iface (s, vtable_reg, klass, NULL, NULL);
1896 }
1897
1898 /*
1899  * Variant of the aboce that takes a register to the class, not the vtable.
1900  */
1901 static void
1902 mini_emit_castclass_iface_class (MonoCompile *s, int klass_reg, MonoClass *klass)
1903 {
1904         mini_emit_isinst_iface_class (s, klass_reg, klass, NULL, NULL);
1905 }
1906
1907 static void
1908 mini_emit_castclass (MonoCompile *s, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *object_is_null)
1909 {
1910         if (klass->rank) {
1911                 int rank_reg = mono_regstate_next_int (s->rs);
1912                 int eclass_reg = mono_regstate_next_int (s->rs);
1913
1914                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank));
1915                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, klass->rank, "InvalidCastException");
1916 //              MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1917                 MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1918                 if (klass->cast_class == mono_defaults.object_class) {
1919                         int parent_reg = mono_regstate_next_int (s->rs);
1920                         int const_reg = -1;
1921                         MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
1922                         if (s->compile_aot) {
1923                                 const_reg = mono_regstate_next_int (s->rs);
1924                                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1925                                 MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg, const_reg, object_is_null);
1926                         } else {
1927                                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg,
1928                                         mono_defaults.enum_class->parent, object_is_null);
1929                         }
1930                         if (s->compile_aot) {
1931                                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1932                                 MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
1933                         } else {
1934                                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException");
1935                         }
1936                 } else if (klass->cast_class == mono_defaults.enum_class->parent) {
1937                         int const_reg = mono_regstate_next_int (s->rs);
1938                         if (s->compile_aot) {
1939                                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1940                                 MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null);
1941                         } else {
1942                                 MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg,
1943                                         mono_defaults.enum_class->parent, object_is_null);
1944                         }
1945                         if (s->compile_aot) {
1946                                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1947                                 MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
1948                         } else {
1949                                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException");
1950                         }
1951                 } else if (klass->cast_class == mono_defaults.enum_class) {
1952                         if (s->compile_aot) {
1953                                 int const_reg = mono_regstate_next_int (s->rs);
1954                                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1955                                 MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
1956                         } else {
1957                                 MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException");
1958                         }
1959                 } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
1960                         mini_emit_castclass_iface_class (s, eclass_reg, klass->cast_class);
1961                 } else {
1962                         mini_emit_castclass (s, obj_reg, eclass_reg, klass->cast_class, object_is_null);
1963                 }
1964
1965                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
1966                         /* Check that the object is a vector too */
1967                         int bounds_reg = mono_regstate_next_int (s->rs);
1968                         MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
1969                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, bounds_reg, 0, "InvalidCastException");
1970                 }
1971         } else {
1972                 int idepth_reg = mono_regstate_next_int (s->rs);
1973                 int stypes_reg = mono_regstate_next_int (s->rs);
1974                 int stype = mono_regstate_next_int (s->rs);
1975
1976                 if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1977                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1978                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT_UN, idepth_reg, klass->idepth, "InvalidCastException");
1979                 }
1980                 MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1981                 MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1982                 if (s->compile_aot) {
1983                         int const_reg = mono_regstate_next_int (s->rs);
1984                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
1985                         MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, stype, const_reg, "InvalidCastException");
1986                 } else {
1987                         MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, stype, klass, "InvalidCastException");
1988                 }
1989         }
1990 }
1991
1992 static void
1993 mini_emit_memcpy (MonoCompile *s, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1994 {
1995         int cur_reg;
1996
1997         if (align < 4) {
1998                 /* This could be optimized further if neccesary */
1999                 while (size >= 1) {
2000                         cur_reg = mono_regstate_next_int (s->rs);
2001                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
2002                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
2003                         doffset += 1;
2004                         soffset += 1;
2005                         size -= 1;
2006                 }
2007         }
2008
2009         /* FIXME: consider alignment for archs that need it. */
2010 #if !NO_UNALIGNED_ACCESS
2011         if (sizeof (gpointer) == 8) {
2012                 while (size >= 8) {
2013                         cur_reg = mono_regstate_next_int (s->rs);
2014                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI8_MEMBASE, cur_reg, srcreg, soffset);
2015                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, destreg, doffset, cur_reg);
2016                         doffset += 8;
2017                         soffset += 8;
2018                         size -= 8;
2019                 }
2020         }
2021 #endif
2022
2023         while (size >= 4) {
2024                 cur_reg = mono_regstate_next_int (s->rs);
2025                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, cur_reg, srcreg, soffset);
2026                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, doffset, cur_reg);
2027                 doffset += 4;
2028                 soffset += 4;
2029                 size -= 4;
2030         }
2031         while (size >= 2) {
2032                 cur_reg = mono_regstate_next_int (s->rs);
2033                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, cur_reg, srcreg, soffset);
2034                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI2_MEMBASE_REG, destreg, doffset, cur_reg);
2035                 doffset += 2;
2036                 soffset += 2;
2037                 size -= 2;
2038         }
2039         while (size >= 1) {
2040                 cur_reg = mono_regstate_next_int (s->rs);
2041                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
2042                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
2043                 doffset += 1;
2044                 soffset += 1;
2045                 size -= 1;
2046         }
2047 }
2048
2049 static void
2050 mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, int align)
2051 {
2052         int val_reg = mono_regstate_next_int (s->rs);
2053
2054         if (sizeof (gpointer) == 8)
2055                 MONO_EMIT_NEW_I8CONST (s, val_reg, val);
2056         else
2057                 MONO_EMIT_NEW_ICONST (s, val_reg, val);
2058
2059         if (align < 4) {
2060                 /* This could be optimized further if neccesary */
2061                 while (size >= 1) {
2062                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
2063                         offset += 1;
2064                         size -= 1;
2065                 }
2066                 return;
2067         }
2068
2069         /* FIXME: consider alignment for archs that need it. */
2070 #if !NO_UNALIGNED_ACCESS
2071         if (sizeof (gpointer) == 8) {
2072                 if (offset % 8) {
2073                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
2074                         offset += 4;
2075                         size -= 4;
2076                 }
2077                 while (size >= 8) {
2078                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, destreg, offset, val_reg);
2079                         offset += 8;
2080                         size -= 8;
2081                 }
2082         }
2083 #endif
2084
2085         while (size >= 4) {
2086                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
2087                 offset += 4;
2088                 size -= 4;
2089         }
2090         while (size >= 2) {
2091                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI2_MEMBASE_REG, destreg, offset, val_reg);
2092                 offset += 2;
2093                 size -= 2;
2094         }
2095         while (size >= 1) {
2096                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
2097                 offset += 1;
2098                 size -= 1;
2099         }
2100 }
2101
2102 #ifdef MONO_ARCH_NEED_GOT_VAR
2103
2104 /* This is similar to NEW_AOTCONST in mini.c, but generates linear IL */
2105 static void
2106 mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpointer cons)
2107 {
2108         MonoInst *dest, *pinfo;
2109         int got_var_reg;
2110
2111         dest = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
2112         dest->opcode = OP_GOT_ENTRY;
2113
2114         g_assert (cfg->got_var);
2115
2116         pinfo = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst));
2117         pinfo->opcode = OP_PATCH_INFO;
2118         pinfo->inst_left = cons;
2119         pinfo->inst_right = (gpointer)(patch_type);
2120
2121         if (cfg->got_var->opcode == OP_REGOFFSET) {
2122                 got_var_reg = mono_regstate_next_int (cfg->rs);
2123                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, got_var_reg, cfg->got_var->inst_basereg, cfg->got_var->inst_offset);
2124         } else {
2125                 g_assert (cfg->got_var->opcode == OP_REGVAR);
2126                 got_var_reg = cfg->got_var->dreg;
2127         }
2128
2129         dest = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst));
2130         dest->opcode = OP_GOT_ENTRY;
2131         dest->inst_left = cfg->got_var; /* not used */
2132         dest->inst_right = pinfo;
2133
2134         dest->inst_basereg = got_var_reg;
2135         dest->dreg = dreg;
2136         mono_bblock_add_inst (cfg->cbb, dest);
2137 }
2138
2139 #endif
2140
2141 static int
2142 ldind_to_load_membase (int opcode)
2143 {
2144         switch (opcode) {
2145         case CEE_LDIND_I1:
2146                 return OP_LOADI1_MEMBASE;
2147         case CEE_LDIND_U1:
2148                 return OP_LOADU1_MEMBASE;
2149         case CEE_LDIND_I2:
2150                 return OP_LOADI2_MEMBASE;
2151         case CEE_LDIND_U2:
2152                 return OP_LOADU2_MEMBASE;
2153         case CEE_LDIND_I4:
2154                 return OP_LOADI4_MEMBASE;
2155         case CEE_LDIND_U4:
2156                 return OP_LOADU4_MEMBASE;
2157         case CEE_LDIND_I:
2158                 return OP_LOAD_MEMBASE;
2159         case CEE_LDIND_REF:
2160                 return OP_LOAD_MEMBASE;
2161         case CEE_LDIND_I8:
2162                 return OP_LOADI8_MEMBASE;
2163         default:
2164                 g_assert_not_reached ();
2165         }
2166
2167         return -1;
2168 }
2169