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_BIALU (cfg, OP_COMPARE, -1, _length_reg, index_reg); \
 282                         MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \
 283                 } \
 284         } while (0)
 285
 286 #define MONO_EMIT_BOUNDS_CHECK_IMM(cfg, array_reg, array_type, array_length_field, index_imm) do { \
 287                 if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \
 288                         int _length_reg = mono_regstate_next_int (cfg->rs); \
 289                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \
 290                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, _length_reg, index_imm); \
 291                         MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \
 292                 } \
 293         } while (0)
 294
 295 %%
 296
 297 %termprefix OP_ CEE_
 298
 299 %start stmt
 300
 301 #
 302 # base addressing mode
 303 #
 304
 305 base: reg "0" {
 306         /* we create a new MonoInst in chain rules and set state->tree to it
 307          * since a MBState (and hence state->tree) is reused in chain rules and
 308          * normal rules.
 309          */
 310         MonoInst *inst;
 311         inst = mono_mempool_alloc0 (s->mempool, sizeof (MonoInst));
 312         inst->opcode = OP_ICONST; /* doesn't matter */
 313         inst->inst_basereg = state->reg1;
 314         inst->inst_offset = 0;
 315         state->tree = inst;
 316         //g_print ("mybase: (assigned R%d from R%d - R%d)\n", state->reg1, tree->dreg, state->reg2);
 317         //tree->inst_offset = 0;
 318         //tree->inst_basereg = state->reg1;
 319 }
 320
 321 base: CEE_LDIND_I (OP_REGVAR) "0" {
 322         tree->inst_offset = 0;
 323         tree->inst_basereg = state->left->tree->dreg;
 324 }
 325
 326 base: OP_REGOFFSET "0" {
 327         /* nothing to do */
 328 }
 329
 330 base: OP_LDADDR (OP_REGOFFSET),
 331 base: CEE_LDOBJ (OP_REGOFFSET) "0" {
 332         tree->inst_offset = state->left->tree->inst_offset;
 333         tree->inst_basereg = state->left->tree->inst_basereg;
 334 }
 335
 336 base: CEE_ADD (base, OP_ICONST) "0" {
 337         tree->inst_offset = state->left->tree->inst_offset + state->right->tree->inst_c0;
 338         tree->inst_basereg = state->left->tree->inst_basereg;
 339 }
 340
 341 base: CEE_ADD (CEE_LDIND_REF (OP_REGVAR), OP_ICONST),
 342 base: CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST) "0" {
 343         tree->inst_offset = state->right->tree->inst_c0;
 344         tree->inst_basereg = state->left->left->tree->dreg;
 345 }
 346
 347 #
 348 # helpers
 349 #
 350
 351 reg: OP_ICONST {
 352         MONO_EMIT_NEW_ICONST (s, state->reg1, tree->inst_c0);
 353 }
 354
 355 reg: OP_AOTCONST {
 356         MONO_EMIT_NEW_AOTCONST (s, state->reg1, tree->inst_p0, tree->inst_c1);
 357 }
 358
 359 reg: OP_LOAD_GOTADDR {
 360         tree->dreg = state->reg1;
 361         mono_bblock_add_inst (s->cbb, tree);
 362 }
 363
 364 stmt: CEE_STIND_I (OP_REGVAR, OP_LOAD_GOTADDR) {
 365         tree->opcode = OP_LOAD_GOTADDR;
 366         tree->dreg = state->left->tree->dreg;
 367         mono_bblock_add_inst (s->cbb, tree);
 368 }
 369
 370 reg: OP_GOT_ENTRY (reg, OP_PATCH_INFO) {
 371         tree->inst_basereg = state->left->tree->dreg;
 372         tree->dreg = state->reg1;
 373         mono_bblock_add_inst (s->cbb, tree);
 374 }
 375
 376 reg: OP_GOT_ENTRY (CEE_LDIND_I (OP_REGVAR), OP_PATCH_INFO) {
 377         tree->inst_basereg = state->left->left->tree->dreg;
 378         tree->dreg = state->reg1;
 379         mono_bblock_add_inst (s->cbb, tree);
 380 }
 381
 382 stmt: OP_DUMMY_USE (CEE_LDIND_I (OP_REGVAR)) {
 383 }
 384
 385 stmt: OP_DUMMY_USE (CEE_LDIND_I (OP_REGOFFSET)) {
 386 }
 387
 388 stmt: OP_DUMMY_USE (CEE_LDIND_REF (OP_REGOFFSET)) {
 389 }
 390
 391 stmt: OP_DUMMY_STORE {
 392 }
 393
 394 stmt: OP_NOT_REACHED {
 395 }
 396
 397 stmt: OP_MEMORY_BARRIER {
 398         mono_bblock_add_inst (s->cbb, tree);
 399 }
 400
 401 #
 402 # load/store operations
 403 #
 404
 405 reg: CEE_LDIND_I (base),
 406 reg: CEE_LDIND_REF (base),
 407 reg: CEE_LDIND_I1 (base),
 408 reg: CEE_LDIND_U1 (base),
 409 reg: CEE_LDIND_I2 (base),
 410 reg: CEE_LDIND_U2 (base),
 411 reg: CEE_LDIND_I4 (base),
 412 reg: CEE_LDIND_U4 (base) {
 413         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, ldind_to_load_membase (tree->opcode),
 414                                    state->reg1, state->left->tree->inst_basereg, state->left->tree->inst_offset);
 415 }
 416
 417 reg: OP_LDADDR (OP_REGOFFSET),
 418 reg: CEE_LDOBJ (OP_REGOFFSET) "2" {
 419         /* use LEA */
 420         tree->opcode = OP_MOVE;
 421         tree->sreg1 = state->left->tree->inst_basereg;
 422         tree->dreg = state->reg1;
 423         mono_bblock_add_inst (s->cbb, tree);
 424         if (state->left->tree->inst_offset)
 425                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tree->dreg, tree->dreg, state->left->tree->inst_offset);
 426 }
 427
 428 reg: CEE_LDOBJ (reg),
 429 reg: OP_OBJADDR (reg),
 430 reg: OP_VTADDR (reg) {
 431         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 432 }
 433
 434 reg: CEE_LDIND_U1 (OP_REGVAR) {
 435         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->tree->dreg, 0xff);
 436 }
 437
 438 reg: CEE_LDIND_U2 (OP_REGVAR) {
 439         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->tree->dreg, 0xffff);
 440 }
 441
 442 stmt: CEE_STIND_REF (base, CEE_LDIND_REF (OP_REGVAR)),
 443 stmt: CEE_STIND_REF (base, CEE_LDIND_I (OP_REGVAR)),
 444 stmt: CEE_STIND_I (base, CEE_LDIND_REF (OP_REGVAR)),
 445 stmt: CEE_STIND_I (base, CEE_LDIND_I (OP_REGVAR)) {
 446         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STORE_MEMBASE_REG, state->left->tree->inst_basereg,
 447                                  state->left->tree->inst_offset, state->right->left->tree->dreg);
 448 }
 449
 450 stmt: CEE_STIND_REF (OP_REGVAR, CEE_LDIND_REF (OP_REGVAR)),
 451 stmt: CEE_STIND_REF (OP_REGVAR, CEE_LDIND_I (OP_REGVAR)),
 452 stmt: CEE_STIND_I (OP_REGVAR, CEE_LDIND_REF (OP_REGVAR)),
 453 stmt: CEE_STIND_I (OP_REGVAR, CEE_LDIND_I (OP_REGVAR)),
 454 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_LDIND_I4 (OP_REGVAR)) {
 455         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->left->tree->dreg, state->right->left->tree->dreg);
 456 }
 457
 458
 459 stmt: CEE_STIND_I (base, reg),
 460 stmt: CEE_STIND_REF (base, reg) {
 461         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STORE_MEMBASE_REG, state->left->tree->inst_basereg,
 462                                  state->left->tree->inst_offset, state->right->reg1);
 463 }
 464
 465 stmt: CEE_STIND_I (base, OP_ICONST),
 466 stmt: CEE_STIND_REF (base, OP_ICONST) {
 467         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STORE_MEMBASE_IMM, state->left->tree->inst_basereg,
 468                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 469 }
 470
 471 reg: CEE_LDIND_REF (OP_REGVAR),
 472 reg: CEE_LDIND_I (OP_REGVAR),
 473 reg: CEE_LDIND_I4 (OP_REGVAR),
 474 reg: CEE_LDIND_U4 (OP_REGVAR) {
 475         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->tree->dreg);
 476 }
 477
 478 stmt: CEE_STIND_I4 (base, reg) {
 479         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI4_MEMBASE_REG, state->left->tree->inst_basereg,
 480                                  state->left->tree->inst_offset, state->right->reg1);
 481 }
 482
 483 stmt: CEE_STIND_I4 (base, CEE_LDIND_I4 (OP_REGVAR)) {
 484         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI4_MEMBASE_REG, state->left->tree->inst_basereg,
 485                                  state->left->tree->inst_offset, state->right->left->tree->dreg);
 486 }
 487
 488 stmt: CEE_STIND_I4 (base, OP_ICONST) {
 489         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI4_MEMBASE_IMM, state->left->tree->inst_basereg,
 490                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 491 }
 492
 493 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_LDIND_I4 (base)) {
 494         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->left->tree->dreg,
 495                                    state->right->left->tree->inst_basereg,
 496                                    state->right->left->tree->inst_offset);
 497 }
 498
 499 stmt: CEE_STIND_I1 (base, reg) {
 500         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI1_MEMBASE_REG, state->left->tree->inst_basereg,
 501                                  state->left->tree->inst_offset, state->right->reg1);
 502 }
 503
 504 stmt: CEE_STIND_I1 (base, OP_ICONST) {
 505         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI1_MEMBASE_IMM, state->left->tree->inst_basereg,
 506                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 507 }
 508
 509 stmt: CEE_STIND_I2 (base, reg) {
 510         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI2_MEMBASE_REG, state->left->tree->inst_basereg,
 511                                  state->left->tree->inst_offset, state->right->reg1);
 512 }
 513
 514 stmt: CEE_STIND_I2 (base, OP_ICONST) {
 515         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI2_MEMBASE_IMM, state->left->tree->inst_basereg,
 516                                      state->left->tree->inst_offset, state->right->tree->inst_c0);
 517 }
 518
 519 stmt: CEE_STIND_I2 (OP_REGVAR, reg) {
 520         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->reg1, 0xffff);
 521 }
 522
 523 stmt: CEE_STIND_I1 (OP_REGVAR, reg) {
 524         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->reg1, 0xff);
 525 }
 526
 527 stmt: CEE_STIND_I1 (OP_REGVAR, CEE_LDIND_U1 (OP_REGVAR)),
 528 stmt: CEE_STIND_I1 (OP_REGVAR, CEE_LDIND_I1 (OP_REGVAR)) {
 529         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->left->tree->dreg, 0xff);
 530 }
 531
 532 stmt: CEE_STIND_I2 (OP_REGVAR, CEE_LDIND_U2 (OP_REGVAR)),
 533 stmt: CEE_STIND_I2 (OP_REGVAR, CEE_LDIND_I2 (OP_REGVAR)) {
 534         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->left->tree->dreg, state->right->left->tree->dreg, 0xffff);
 535 }
 536
 537 stmt: CEE_STIND_I4 (OP_REGVAR, OP_ICONST),
 538 stmt: CEE_STIND_I2 (OP_REGVAR, OP_ICONST),
 539 stmt: CEE_STIND_I1 (OP_REGVAR, OP_ICONST),
 540 stmt: CEE_STIND_REF (OP_REGVAR, OP_ICONST),
 541 stmt: CEE_STIND_I (OP_REGVAR, OP_ICONST) {
 542         tree->inst_c0 = state->right->tree->inst_c0;
 543         if (tree->opcode == CEE_STIND_I2)
 544                 tree->inst_c0 &= 0xffff;
 545         if (tree->opcode == CEE_STIND_I1)
 546                 tree->inst_c0 &= 0xff;
 547
 548         tree->opcode = OP_ICONST;
 549         tree->dreg = state->left->tree->dreg;
 550         mono_bblock_add_inst (s->cbb, tree);
 551 }
 552
 553 stmt: CEE_STIND_I4 (OP_REGVAR, reg),
 554 stmt: CEE_STIND_REF (OP_REGVAR, reg),
 555 stmt: CEE_STIND_I (OP_REGVAR, reg) {
 556         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->left->tree->dreg, state->right->reg1);
 557 }
 558
 559 stmt: OP_MEMCPY (base, base) {
 560         int size = tree->backend.size;
 561         if (size > 0)
 562                 mini_emit_memcpy (s, state->left->tree->inst_basereg, state->left->tree->inst_offset,
 563                                   state->right->tree->inst_basereg, state->right->tree->inst_offset, size, 0);
 564 }
 565
 566 stmt: OP_MEMSET (base) {
 567         int size = tree->backend.size;
 568         if (size > 0)
 569                 mini_emit_memset (s, state->left->tree->inst_basereg, state->left->tree->inst_offset, size, tree->inst_imm, 0);
 570 }
 571
 572 reg: OP_LDELEMA2D (reg, OP_GROUP (reg, reg)) "20" {
 573         int bounds_reg = mono_regstate_next_int (s->rs);
 574         int add_reg = mono_regstate_next_int (s->rs);
 575         int mult_reg = mono_regstate_next_int (s->rs);
 576         int mult2_reg = mono_regstate_next_int (s->rs);
 577         int low1_reg = mono_regstate_next_int (s->rs);
 578         int low2_reg = mono_regstate_next_int (s->rs);
 579         int high1_reg = mono_regstate_next_int (s->rs);
 580         int high2_reg = mono_regstate_next_int (s->rs);
 581         int realidx1_reg = mono_regstate_next_int (s->rs);
 582         int realidx2_reg = mono_regstate_next_int (s->rs);
 583         int sum_reg = mono_regstate_next_int (s->rs);
 584         int index1, index2;
 585         guint32 size = mono_class_array_element_size (tree->klass);
 586
 587         index1 = state->right->left->reg1;
 588         index2 = state->right->right->reg1;
 589
 590         /* range checking */
 591         MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg,
 592                                        state->left->reg1, G_STRUCT_OFFSET (MonoArray, bounds));
 593
 594         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, low1_reg,
 595                                        bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
 596         MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx1_reg, index1, low1_reg);
 597         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high1_reg,
 598                                        bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, length));
 599         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, high1_reg, realidx1_reg);
 600         MONO_EMIT_NEW_COND_EXC (s, LE_UN, "IndexOutOfRangeException");
 601
 602         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, low2_reg,
 603                                        bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
 604         MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx2_reg, index2, low2_reg);
 605         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high2_reg,
 606                                        bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, length));
 607         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, high2_reg, realidx2_reg);
 608         MONO_EMIT_NEW_COND_EXC (s, LE_UN, "IndexOutOfRangeException");
 609
 610         MONO_EMIT_NEW_BIALU (s, CEE_MUL, mult_reg, high2_reg, realidx1_reg);
 611         MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, mult_reg, realidx2_reg);
 612         MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, mult2_reg, sum_reg, size);
 613         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult2_reg, state->left->reg1);
 614         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoArray, vector));
 615 }
 616
 617 #
 618 # conversions: conv_u can be implemented with AND, also all _ovf conversions?
 619 #
 620
 621 reg: CEE_CONV_I1 (reg),
 622 reg: CEE_CONV_I2 (reg),
 623 reg: CEE_CONV_I4 (reg) {
 624         MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 625 }
 626
 627 reg: CEE_CONV_U1 (reg) {
 628         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
 629 }
 630
 631 reg: CEE_CONV_U2 (reg) {
 632         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
 633 }
 634
 635 reg: CEE_CONV_U4 (reg),
 636 reg: CEE_CONV_U (reg),
 637 reg: CEE_CONV_I (reg) {
 638         if (sizeof (void *) == 8)
 639                 MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 640         else
 641                 MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 642 }
 643
 644 reg: CEE_CONV_OVF_I4 (reg) {
 645         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 646 }
 647
 648 reg: CEE_CONV_OVF_U4 (reg),
 649 reg: CEE_CONV_OVF_I4_UN (reg) {
 650         if (sizeof (void *) == 8) {
 651                 MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 652         } else {
 653                 MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0);
 654                 MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 655                 MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 656         }
 657 }
 658
 659 reg: CEE_CONV_OVF_I1 (reg) {
 660         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 127);
 661         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 662         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, -128);
 663         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 664         MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
 665 }
 666
 667 reg: CEE_CONV_OVF_I1_UN (reg) {
 668         /* probe values between 0 to 127 */
 669         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 127);
 670         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 671         MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
 672 }
 673
 674 reg: CEE_CONV_OVF_U1 (reg),
 675 reg: CEE_CONV_OVF_U1_UN (reg) {
 676         /* probe value to be within 0 to 255 */
 677         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 255);
 678         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 679         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
 680 }
 681
 682 reg: CEE_CONV_OVF_I2 (reg) {
 683         /* Probe value to be within -32768 and 32767 */
 684         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 32767);
 685         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 686         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, -32768);
 687         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 688         MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
 689 }
 690
 691 reg: CEE_CONV_OVF_I2_UN (reg) {
 692         /* Convert uint value into short, value within 0 and 32767 */
 693         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 32767);
 694         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 695         MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
 696 }
 697
 698 reg: CEE_CONV_OVF_U2 (reg),
 699 reg: CEE_CONV_OVF_U2_UN (reg) {
 700         /* Probe value to be within 0 and 65535 */
 701         MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 0xffff);
 702         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 703         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
 704 }
 705
 706 #
 707 # other alu operations
 708 #
 709
 710 reg: OP_CEQ (cflags),
 711 reg: OP_CLT (cflags),
 712 reg: OP_CLT_UN (cflags),
 713 reg: OP_CGT (cflags),
 714 reg: OP_CGT_UN (cflags) {
 715         tree->dreg = state->reg1;
 716         mono_bblock_add_inst (s->cbb, tree);
 717 }
 718
 719 #
 720 # control flow commands
 721 #
 722
 723 stmt: OP_LABEL {
 724         mono_bblock_add_inst (s->cbb, tree);
 725 }
 726
 727 stmt: CEE_NOP "0" {
 728 }
 729
 730 stmt: CEE_BREAK "0" {
 731         mono_bblock_add_inst (s->cbb, tree);
 732 }
 733
 734 reg: OP_TLS_GET {
 735         tree->dreg = state->reg1;
 736         mono_bblock_add_inst (s->cbb, tree);
 737 }
 738
 739 stmt: CEE_SWITCH (reg) "2" {
 740         MonoInst *label;
 741         int offset_reg = mono_regstate_next_int (s->rs);
 742         int target_reg = mono_regstate_next_int (s->rs);
 743         int n = GPOINTER_TO_INT (tree->klass);
 744
 745         MONO_NEW_LABEL (s, label);
 746
 747         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
 748         MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
 749         if (sizeof (gpointer) == 8)
 750                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 3);
 751         else
 752                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 2);
 753         mono_bblock_add_inst (s->cbb, label);
 754         if (s->compile_aot) {
 755                 int table_reg = mono_regstate_next_int (s->rs);
 756                 int sum_reg = mono_regstate_next_int (s->rs);
 757                 MonoJumpInfoBBTable *table;
 758
 759                 table = mono_mempool_alloc (s->mempool, sizeof (MonoJumpInfoBBTable));
 760                 table->table = tree->inst_many_bb;
 761                 table->table_size = n;
 762
 763                 MONO_EMIT_NEW_AOTCONST (s, table_reg, table, MONO_PATCH_INFO_SWITCH);
 764
 765                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, table_reg, offset_reg);
 766                 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, sum_reg, 0);
 767         } else {
 768                 mono_create_jump_table (s, label, tree->inst_many_bb, n);
 769
 770                  /* the backend must patch the address. we use 0xf0f0f0f0 to avoid the usage
 771                   * of special (short) opcodes on x86 */
 772                 if (sizeof (gpointer) == 8)
 773                         MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, (long)0xf0f0f0f0f0f0f0f1LL);
 774                 else
 775                         MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, 0xf0f0f0f0);
 776         }
 777         MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg);
 778 }
 779
 780 stmt: CEE_BR "0" {
 781         mono_bblock_add_inst (s->cbb, tree);
 782 }
 783
 784 stmt: OP_ARGLIST (reg) {
 785         tree->sreg1 = state->left->reg1;
 786         mono_bblock_add_inst (s->cbb, tree);
 787 }
 788
 789 reg: CEE_CALL {
 790         tree->dreg = state->reg1;
 791         mono_bblock_add_inst (s->cbb, tree);
 792 }
 793
 794 reg: CEE_CALLVIRT (reg) {
 795         mini_emit_virtual_call (s, state, tree, CEE_CALL, OP_CALL_MEMBASE);
 796 }
 797
 798 stmt: OP_VOIDCALLVIRT (reg) {
 799         mini_emit_virtual_call (s, state, tree, OP_VOIDCALL, OP_VOIDCALL_MEMBASE);
 800 }
 801
 802 freg: OP_FCALLVIRT (reg) {
 803         mini_emit_virtual_call (s, state, tree, OP_FCALL, OP_FCALL_MEMBASE);
 804 }
 805
 806 stmt: OP_VCALLVIRT (reg, reg) {
 807         mini_emit_virtual_call (s, state, tree, OP_VCALL, OP_VCALL_MEMBASE);
 808 }
 809
 810 reg: OP_CALL_REG (reg) {
 811         tree->sreg1 = state->left->reg1;
 812         tree->dreg = state->reg1;
 813         mono_bblock_add_inst (s->cbb, tree);
 814 }
 815
 816 stmt: OP_VOIDCALL {
 817         mono_bblock_add_inst (s->cbb, tree);
 818 }
 819
 820 stmt: OP_VOIDCALL_REG (reg) {
 821         tree->sreg1 = state->left->reg1;
 822         mono_bblock_add_inst (s->cbb, tree);
 823 }
 824
 825 freg: OP_FCALL {
 826         tree->dreg = state->reg1;
 827         mono_bblock_add_inst (s->cbb, tree);
 828 }
 829
 830 freg: OP_FCALL_REG (reg) {
 831         tree->sreg1 = state->left->reg1;
 832         tree->dreg = state->reg1;
 833         mono_bblock_add_inst (s->cbb, tree);
 834 }
 835
 836 stmt: OP_VCALL (reg) {
 837         mono_arch_emit_this_vret_args (s, (MonoCallInst*)tree, -1, -1, state->left->reg1);
 838         mono_bblock_add_inst (s->cbb, tree);
 839 }
 840
 841 stmt: OP_VCALL_REG (reg, reg) {
 842         mono_arch_emit_this_vret_args (s, (MonoCallInst*)tree, -1, -1, state->right->reg1);
 843
 844         tree->sreg1 = state->left->reg1;
 845         mono_bblock_add_inst (s->cbb, tree);
 846 }
 847
 848 stmt: OP_SAVE_LMF,
 849 stmt: OP_RESTORE_LMF {
 850         mono_bblock_add_inst (s->cbb, tree);
 851 }
 852
 853 #
 854 # Optimized call instructions
 855 #
 856
 857 reg: OP_CALL_REG (OP_ICONST),
 858 reg: OP_CALL_REG (OP_I8CONST) {
 859         tree->opcode = CEE_CALL;
 860         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 861         tree->dreg = state->reg1;
 862         mono_bblock_add_inst (s->cbb, tree);
 863 }
 864
 865 stmt: OP_VOIDCALL_REG (OP_ICONST),
 866 stmt: OP_VOIDCALL_REG (OP_I8CONST) {
 867         tree->opcode = OP_VOIDCALL;
 868         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 869         mono_bblock_add_inst (s->cbb, tree);
 870 }
 871
 872 freg: OP_FCALL_REG (OP_ICONST),
 873 freg: OP_FCALL_REG (OP_I8CONST) {
 874         tree->opcode = OP_FCALL;
 875         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 876         tree->dreg = state->reg1;
 877         mono_bblock_add_inst (s->cbb, tree);
 878 }
 879
 880 stmt: CEE_RET "0" {
 881         mono_bblock_add_inst (s->cbb, tree);
 882 }
 883
 884 stmt: CEE_POP (reg)
 885
 886 # remove some common pops without side effects
 887 stmt: CEE_POP (OP_ICONST)
 888 stmt: CEE_POP (CEE_LDIND_I1 (base))
 889 stmt: CEE_POP (CEE_LDIND_U1 (base))
 890 stmt: CEE_POP (CEE_LDIND_I2 (base))
 891 stmt: CEE_POP (CEE_LDIND_U2 (base))
 892 stmt: CEE_POP (CEE_LDIND_I4 (base))
 893 stmt: CEE_POP (CEE_LDIND_U4 (base))
 894 stmt: CEE_POP (CEE_LDIND_I (base))
 895 stmt: CEE_POP (CEE_LDIND_REF (base))
 896 stmt: CEE_POP (CEE_LDIND_I1 (OP_REGVAR))
 897 stmt: CEE_POP (CEE_LDIND_U1 (OP_REGVAR))
 898 stmt: CEE_POP (CEE_LDIND_I2 (OP_REGVAR))
 899 stmt: CEE_POP (CEE_LDIND_U2 (OP_REGVAR))
 900 stmt: CEE_POP (CEE_LDIND_I4 (OP_REGVAR))
 901 stmt: CEE_POP (CEE_LDIND_U4 (OP_REGVAR))
 902 stmt: CEE_POP (CEE_LDIND_I (OP_REGVAR))
 903 stmt: CEE_POP (CEE_LDIND_REF (OP_REGVAR))
 904
 905 stmt: CEE_JMP "0" {
 906         mono_bblock_add_inst (s->cbb, tree);
 907 }
 908
 909 # exception handling
 910
 911 stmt: CEE_THROW (reg) {
 912         MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->reg1);
 913 }
 914
 915 stmt: OP_RETHROW (reg) {
 916         MONO_EMIT_UNALU (s, tree, OP_RETHROW, -1, state->left->reg1);
 917 }
 918
 919 stmt: OP_THROW_OR_NULL (reg, reg) {
 920         MonoInst *dont_throw;
 921
 922         MONO_NEW_LABEL (s, dont_throw);
 923
 924         /*
 925          * Currently, we allways rethrow the abort exception, despite the fact
 926          * that this is not correct. See thread6.cs for an example. But propagating
 927          * the abort exception is more important than getting the sematics right.
 928          */
 929         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, 0);
 930         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, dont_throw);
 931         MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->reg1);
 932         mono_bblock_add_inst (s->cbb, dont_throw);
 933 }
 934
 935 stmt: CEE_THROW (CEE_LDIND_REF (OP_REGVAR)) {
 936         MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->left->tree->dreg);
 937 }
 938
 939 stmt: OP_CALL_HANDLER {
 940         mono_bblock_add_inst (s->cbb, tree);
 941 }
 942
 943 stmt: OP_START_HANDLER "2" {
 944         mono_bblock_add_inst (s->cbb, tree);
 945 }
 946
 947 stmt: CEE_ENDFINALLY "2" {
 948         mono_bblock_add_inst (s->cbb, tree);
 949 }
 950
 951 stmt: OP_ENDFILTER (reg) "2" {
 952         MONO_EMIT_UNALU (s, tree, OP_ENDFILTER, -1, state->left->reg1);
 953 }
 954
 955 stmt: OP_CHECK_THIS (reg) {
 956         tree->sreg1 = state->left->reg1;
 957         tree->dreg = state->reg1;
 958         mono_bblock_add_inst (s->cbb, tree);
 959 }
 960
 961 # object related opcodes
 962
 963 reg: CEE_ISINST (reg) {
 964         MonoClass *klass = tree->inst_newa_class;
 965         MonoInst *object_is_null, *end_label, *false_label;
 966         int obj_reg = state->left->reg1;
 967         int vtable_reg = mono_regstate_next_int (s->rs);
 968
 969         MONO_NEW_LABEL (s, object_is_null);
 970         MONO_NEW_LABEL (s, end_label);
 971         MONO_NEW_LABEL (s, false_label);
 972
 973         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0);
 974         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
 975
 976         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
 977                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
 978                 /* the object_is_null target simply copies the input register to the output */
 979                 mini_emit_isninst_iface_cast (s, vtable_reg, klass, false_label, object_is_null);
 980         } else {
 981                 int klass_reg = mono_regstate_next_int (s->rs);
 982
 983                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
 984
 985                 if (klass->rank) {
 986                         int rank_reg = mono_regstate_next_int (s->rs);
 987                         int eclass_reg = mono_regstate_next_int (s->rs);
 988
 989                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
 990                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
 991                         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label);
 992                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
 993                         MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
 994                         if (klass->cast_class == mono_defaults.object_class) {
 995                                 int parent_reg = mono_regstate_next_int (s->rs);
 996                                 int const_reg = -1;
 997                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
 998                                 if (s->compile_aot) {
 999                                         const_reg = mono_regstate_next_int (s->rs);
1000                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1001                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, parent_reg, const_reg);
1002                                 } else {
1003                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, parent_reg, mono_defaults.enum_class->parent);
1004                                 }
1005                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, object_is_null);
1006                                 if (s->compile_aot) {
1007                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1008                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1009                                 } else {
1010                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
1011                                 }
1012                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
1013                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label);
1014                         } else if (klass->cast_class == mono_defaults.enum_class->parent) {
1015                                 int const_reg = -1;
1016
1017                                 if (s->compile_aot) {
1018                                         const_reg = mono_regstate_next_int (s->rs);
1019                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1020                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1021                                 } else {
1022                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class->parent);
1023                                 }
1024                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
1025                                 if (s->compile_aot) {
1026                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1027                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1028                                 } else {
1029                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
1030                                 }
1031                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
1032                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label);
1033                         } else if (klass->cast_class == mono_defaults.enum_class) {
1034                                 if (s->compile_aot) {
1035                                         int const_reg = mono_regstate_next_int (s->rs);
1036                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1037                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1038                                 } else {
1039                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
1040                                 }
1041                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
1042                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label);
1043                         } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
1044                                 mini_emit_isninst_iface_class_cast (s, eclass_reg, klass->cast_class, false_label, object_is_null);
1045                         } else {
1046                                 if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
1047                                         /* Check that the object is a vector too */
1048                                         int bounds_reg = mono_regstate_next_int (s->rs);
1049                                         MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
1050                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, bounds_reg, 0);
1051                                         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label);
1052                                 }
1053
1054                                 /* the object_is_null target simply copies the input register to the output */
1055                                 mini_emit_isninst_cast (s, eclass_reg, klass->cast_class, false_label, object_is_null);
1056                         }
1057                 } else if (mono_class_is_nullable (klass)) {
1058                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1059                         /* the object_is_null target simply copies the input register to the output */
1060                         mini_emit_isninst_cast (s, klass_reg, klass->cast_class, false_label, object_is_null);
1061                 } else {
1062                         if (!s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
1063                                 /* the remoting code is broken, access the class for now */
1064                                 if (0) {
1065                                         MonoVTable *vt = mono_class_vtable (s->domain, klass);
1066                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, vt);
1067                                 } else {
1068                                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1069                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, klass);
1070                                 }
1071                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label);
1072                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, object_is_null);
1073                         } else {
1074                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1075                                 /* the object_is_null target simply copies the input register to the output */
1076                                 mini_emit_isninst_cast (s, klass_reg, klass, false_label, object_is_null);
1077                         }
1078                 }
1079         }
1080
1081         mono_bblock_add_inst (s->cbb, false_label);
1082         MONO_EMIT_NEW_ICONST (s, state->reg1, 0);
1083         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
1084         mono_bblock_add_inst (s->cbb, object_is_null);
1085         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
1086         mono_bblock_add_inst (s->cbb, end_label);
1087 }
1088
1089 reg: OP_CISINST (reg) {
1090         /* This opcode takes as input an object reference and a class, and returns:
1091         0) if the object is an instance of the class,
1092         1) if the object is not instance of the class,
1093         2) if the object is a proxy whose type cannot be determined */
1094
1095         MonoClass *klass = tree->inst_newa_class;
1096         MonoInst *end_label, *true_label, *false_label, *false2_label;
1097         MonoInst *no_proxy_label, *interface_fail_label;
1098         int obj_reg = state->left->reg1;
1099         int tmp_reg = mono_regstate_next_int (s->rs);
1100         int klass_reg = mono_regstate_next_int (s->rs);
1101
1102         MONO_NEW_LABEL (s, end_label);
1103         MONO_NEW_LABEL (s, true_label);
1104         MONO_NEW_LABEL (s, false_label);
1105         MONO_NEW_LABEL (s, false2_label);
1106
1107         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0);
1108         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, false_label);
1109
1110         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1111                 MONO_NEW_LABEL (s, interface_fail_label);
1112                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1113                 mini_emit_isninst_iface_cast (s, tmp_reg, klass, interface_fail_label, true_label);
1114
1115                 mono_bblock_add_inst (s->cbb, interface_fail_label);
1116                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1117
1118                 if (s->compile_aot) {
1119                         int tproxy_reg = mono_regstate_next_int (s->rs);
1120                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1121                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg);
1122                 } else {
1123                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class);
1124                 }
1125                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label);
1126
1127                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1128                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0);
1129                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false2_label);
1130
1131         } else {
1132                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1133                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1134
1135                 MONO_NEW_LABEL (s, no_proxy_label);
1136
1137                 if (s->compile_aot) {
1138                         int tproxy_reg = mono_regstate_next_int (s->rs);
1139                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1140                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg);
1141                 } else {
1142                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class);
1143                 }
1144                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, no_proxy_label);
1145                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1146                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1147
1148                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1149                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0);
1150                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, no_proxy_label);
1151
1152                 mini_emit_isninst_cast (s, klass_reg, klass, false2_label, true_label);
1153                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false2_label);
1154
1155                 mono_bblock_add_inst (s->cbb, no_proxy_label);
1156                 mini_emit_isninst_cast (s, klass_reg, klass, false_label, true_label);
1157         }
1158
1159         mono_bblock_add_inst (s->cbb, false_label);
1160         MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
1161         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
1162         mono_bblock_add_inst (s->cbb, false2_label);
1163         MONO_EMIT_NEW_ICONST (s, state->reg1, 2);
1164         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
1165         mono_bblock_add_inst (s->cbb, true_label);
1166         MONO_EMIT_NEW_ICONST (s, state->reg1, 0);
1167         mono_bblock_add_inst (s->cbb, end_label);
1168 }
1169
1170 reg: OP_UNBOXCAST (reg) {
1171         MonoClass *klass = tree->inst_newa_class;
1172         int obj_reg = state->left->reg1;
1173         int vtable_reg = mono_regstate_next_int (s->rs);
1174         int klass_reg = mono_regstate_next_int (s->rs);
1175         int eclass_reg = mono_regstate_next_int (s->rs);
1176         int rank_reg = mono_regstate_next_int (s->rs);
1177
1178         MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1179         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
1180
1181         /* FIXME: generics */
1182         g_assert (klass->rank == 0);
1183
1184         // Check rank == 0
1185         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, 0);
1186         MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1187
1188         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1189         MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
1190
1191         if (s->compile_aot) {
1192                 int const_reg = mono_regstate_next_int (s->rs);
1193                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass->element_class);
1194                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1195         } else {
1196                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, klass->element_class);
1197         }
1198
1199         MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1200         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
1201 }
1202
1203 reg: CEE_CASTCLASS (reg) {
1204         MonoClass *klass = tree->inst_newa_class;
1205         MonoInst *object_is_null;
1206         int obj_reg = state->left->reg1;
1207         int vtable_reg = mono_regstate_next_int (s->rs);
1208
1209         MONO_NEW_LABEL (s, object_is_null);
1210
1211         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0);
1212         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
1213
1214         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1215                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1216                 mini_emit_castclass_iface (s, vtable_reg, klass);
1217         } else {
1218                 int klass_reg = mono_regstate_next_int (s->rs);
1219
1220                 MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1221
1222                 if (klass->rank) {
1223                         int rank_reg = mono_regstate_next_int (s->rs);
1224                         int eclass_reg = mono_regstate_next_int (s->rs);
1225
1226                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
1227                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
1228                         MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1229                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1230                         MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
1231                         if (klass->cast_class == mono_defaults.object_class) {
1232                                 int parent_reg = mono_regstate_next_int (s->rs);
1233                                 int const_reg = -1;
1234                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
1235                                 if (s->compile_aot) {
1236                                         const_reg = mono_regstate_next_int (s->rs);
1237                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1238                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, parent_reg, const_reg);
1239                                 } else {
1240                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, parent_reg, mono_defaults.enum_class->parent);
1241                                 }
1242                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, object_is_null);
1243                                 if (s->compile_aot) {
1244                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1245                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1246                                 } else {
1247                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
1248                                 }
1249                                 MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1250                         } else if (klass->cast_class == mono_defaults.enum_class->parent) {
1251                                 int const_reg = mono_regstate_next_int (s->rs);
1252                                 if (s->compile_aot) {
1253                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent);
1254                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1255                                 } else {
1256                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class->parent);
1257                                 }
1258                                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
1259                                 if (s->compile_aot) {
1260                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1261                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1262                                 } else {
1263                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
1264                                 }
1265                                 MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1266                         } else if (klass->cast_class == mono_defaults.enum_class) {
1267                                 if (s->compile_aot) {
1268                                         int const_reg = mono_regstate_next_int (s->rs);
1269                                         MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
1270                                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
1271                                 } else {
1272                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
1273                                 }
1274                                 MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1275                         } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
1276                                 mini_emit_castclass_iface_class (s, eclass_reg, klass->cast_class);
1277                         } else {
1278                                 mini_emit_castclass (s, eclass_reg, klass->cast_class);
1279                         }
1280
1281                         if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) {
1282                                 /* Check that the object is a vector too */
1283                                 int bounds_reg = mono_regstate_next_int (s->rs);
1284                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
1285                                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, bounds_reg, 0);
1286                                 MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1287                         }
1288                 } else {
1289                         if (!s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
1290                                 /* the remoting code is broken, access the class for now */
1291                                 if (0) {
1292                                         MonoVTable *vt = mono_class_vtable (s->domain, klass);
1293                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, vt);
1294                                 } else {
1295                                         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1296                                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, klass);
1297                                 }
1298                                 MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1299                         } else {
1300                                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1301                                 mini_emit_castclass (s, klass_reg, klass);
1302                         }
1303                 }
1304         }
1305
1306         mono_bblock_add_inst (s->cbb, object_is_null);
1307         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
1308 }
1309
1310 reg: OP_CCASTCLASS (reg) {
1311         /* This opcode takes as input an object reference and a class, and returns:
1312         0) if the object is an instance of the class,
1313         1) if the object is a proxy whose type cannot be determined
1314         an InvalidCastException exception is thrown otherwhise*/
1315
1316         MonoClass *klass = tree->inst_newa_class;
1317         MonoInst *end_label, *fail_label, *no_proxy_label, *ok_result_label;
1318         int obj_reg = state->left->reg1;
1319         int tmp_reg = mono_regstate_next_int (s->rs);
1320         int klass_reg = mono_regstate_next_int (s->rs);
1321
1322         MONO_NEW_LABEL (s, end_label);
1323         MONO_NEW_LABEL (s, ok_result_label);
1324
1325         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0);
1326         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, ok_result_label);
1327
1328         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1329
1330                 MONO_NEW_LABEL (s, fail_label);
1331
1332                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1333                 mini_emit_isninst_iface_cast (s, tmp_reg, klass, fail_label, ok_result_label);
1334
1335                 mono_bblock_add_inst (s->cbb, fail_label);
1336                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1337
1338                 if (s->compile_aot) {
1339                         int tproxy_reg = mono_regstate_next_int (s->rs);
1340                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1341                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg);
1342                 } else {
1343                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class);
1344                 }
1345
1346                 MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1347
1348                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1349                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1350
1351                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1352                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0);
1353                 MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
1354
1355                 MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
1356                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
1357
1358         } else {
1359
1360                 MONO_NEW_LABEL (s, no_proxy_label);
1361                 MONO_NEW_LABEL (s, fail_label);
1362
1363                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1364                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1365
1366                 if (s->compile_aot) {
1367                         int tproxy_reg = mono_regstate_next_int (s->rs);
1368                         MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
1369                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg);
1370                 } else {
1371                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class);
1372                 }
1373                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, no_proxy_label);
1374
1375                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
1376                 MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
1377
1378                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
1379                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0);
1380                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, no_proxy_label);
1381
1382                 mini_emit_isninst_cast (s, klass_reg, klass, fail_label, ok_result_label);
1383                 mono_bblock_add_inst (s->cbb, fail_label);
1384                 MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
1385                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
1386
1387                 mono_bblock_add_inst (s->cbb, no_proxy_label);
1388                 mini_emit_castclass (s, klass_reg, klass);
1389         }
1390
1391         mono_bblock_add_inst (s->cbb, ok_result_label);
1392         MONO_EMIT_NEW_ICONST (s, state->reg1, 0);
1393         mono_bblock_add_inst (s->cbb, end_label);
1394 }
1395
1396 stmt: CEE_STELEM_REF (OP_GROUP (reg, reg), reg),
1397 reg: OP_GROUP (reg, reg),
1398 reg: CEE_NEWARR (reg),
1399 lreg: OP_LMUL (lreg, lreg),
1400 lreg: OP_LMUL_OVF (lreg, lreg),
1401 lreg: OP_LMUL_OVF_UN (lreg, lreg),
1402 lreg: OP_LDIV (lreg, lreg),
1403 lreg: OP_LDIV_UN (lreg, lreg),
1404 lreg: OP_LREM (lreg, lreg),
1405 lreg: OP_LREM_UN (lreg, lreg),
1406 lreg: OP_LSHL (lreg, reg),
1407 lreg: OP_LSHR (lreg, reg),
1408 lreg: OP_LSHR_UN (lreg, reg) {
1409         g_assert_not_reached ();
1410 }
1411
1412 #
1413 # string support
1414 #
1415 reg: OP_GETCHR (reg, reg) "4" {
1416         int mult_reg = mono_regstate_next_int (s->rs);
1417         int add_reg = mono_regstate_next_int (s->rs);
1418
1419         MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoString, length, state->right->reg1);
1420         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, mult_reg, state->right->reg1, 1);
1421         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1);
1422         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU2_MEMBASE, state->reg1,
1423                                    add_reg, G_STRUCT_OFFSET (MonoString, chars));
1424 }
1425
1426 reg: OP_GETCHR (reg, OP_ICONST) {
1427         int ind = 2 * state->right->tree->inst_c0 + G_STRUCT_OFFSET (MonoString, chars);
1428
1429         MONO_EMIT_BOUNDS_CHECK_IMM (s, state->left->reg1, MonoString, length, state->right->tree->inst_c0);
1430         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU2_MEMBASE, state->reg1, state->left->reg1, ind);
1431 }
1432
1433 reg: OP_STR_CHAR_ADDR (reg, reg) "4" {
1434         int mult_reg = mono_regstate_next_int (s->rs);
1435         int add_reg = mono_regstate_next_int (s->rs);
1436
1437         /*
1438          * The corlib functions check for oob already.
1439          * MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoString, length, state->right->reg1);
1440          */
1441         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, mult_reg, state->right->reg1, 1);
1442         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1);
1443         MONO_EMIT_BIALU_IMM (s, tree, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoString, chars));
1444 }
1445
1446 reg: OP_STRLEN (reg) {
1447         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->reg1,
1448                                    state->left->reg1, G_STRUCT_OFFSET (MonoString, length));
1449 }
1450
1451 reg: OP_GETTYPE (reg) {
1452         int vt_reg = mono_regstate_next_int (s->rs);
1453         MONO_EMIT_NEW_LOAD_MEMBASE (s, vt_reg, state->left->reg1, G_STRUCT_OFFSET (MonoObject, vtable));
1454         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOAD_MEMBASE, state->reg1, vt_reg, G_STRUCT_OFFSET (MonoVTable, type));
1455 }
1456
1457 reg: OP_GETHASHCODE (reg) {
1458         int t1 = mono_regstate_next_int (s->rs);
1459
1460         #define MONO_OBJECT_ALIGNMENT_SHIFT     3
1461
1462         /* return (GPOINTER_TO_UINT (this) >> MONO_OBJECT_ALIGNMENT_SHIFT) * 2654435761u; */
1463
1464         MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, t1, state->left->reg1, MONO_OBJECT_ALIGNMENT_SHIFT);
1465         MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, state->reg1, t1, 2654435761u);
1466 }
1467
1468 #
1469 # array support
1470 #
1471 reg: CEE_LDLEN (reg) {
1472         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->reg1,
1473                                    state->left->reg1, G_STRUCT_OFFSET (MonoArray, max_length));
1474 }
1475
1476 reg: OP_ARRAY_RANK (reg) {
1477         int vtable_reg = mono_regstate_next_int (s->rs);
1478         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, vtable_reg,
1479                                        state->left->reg1, G_STRUCT_OFFSET (MonoObject, vtable));
1480         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, state->reg1,
1481                                        vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
1482 }
1483
1484 reg: OP_CHECK_ARRAY_TYPE (reg) {
1485
1486         MonoClass* array_class = mono_array_class_get (tree->klass, 1);
1487
1488         int vtable_reg = mono_regstate_next_int (s->rs);
1489
1490         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, vtable_reg,
1491                                        state->left->reg1, G_STRUCT_OFFSET (MonoObject, vtable));
1492
1493         if (s->opt & MONO_OPT_SHARED) {
1494                 int class_reg = mono_regstate_next_int (s->rs);
1495                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, class_reg,
1496                                                vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
1497                 if (s->compile_aot) {
1498                         int klass_reg = mono_regstate_next_int (s->rs);
1499                         MONO_EMIT_NEW_CLASSCONST (s, klass_reg, array_class);
1500                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, class_reg, klass_reg);
1501                 } else {
1502                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, class_reg, array_class);
1503                 }
1504         } else {
1505                 if (s->compile_aot) {
1506                         int vt_reg = mono_regstate_next_int (s->rs);
1507                         MONO_EMIT_NEW_VTABLECONST (s, vt_reg, mono_class_vtable (s->domain, array_class));
1508                         MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, vtable_reg, vt_reg);
1509                 } else {
1510                         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, mono_class_vtable (s->domain, array_class));
1511                 }
1512         }
1513
1514         MONO_EMIT_NEW_COND_EXC (s, NE_UN, "ArrayTypeMismatchException");
1515         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
1516 }
1517
1518 reg: CEE_LDELEMA (reg, OP_ICONST) "15" {
1519         guint32 size = mono_class_array_element_size (tree->klass);
1520
1521         int ind = size * state->right->tree->inst_c0 + G_STRUCT_OFFSET (MonoArray, vector);
1522
1523         MONO_EMIT_BOUNDS_CHECK_IMM (s, state->left->reg1, MonoArray, max_length, state->right->tree->inst_c0);
1524         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->left->reg1, ind);
1525 }
1526
1527 reg: CEE_LDELEMA (reg, reg) "20" {
1528         int mult_reg = mono_regstate_next_int (s->rs);
1529         int add_reg = mono_regstate_next_int (s->rs);
1530         guint32 size = mono_class_array_element_size (tree->klass);
1531
1532         MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoArray, max_length, state->right->reg1);
1533         MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, mult_reg, state->right->reg1, size);
1534         MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1);
1535         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoArray, vector));
1536 }
1537
1538 reg: CEE_REFANYVAL (reg) {
1539         int klass_reg = mono_regstate_next_int (s->rs);
1540         MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass));
1541         if (s->compile_aot) {
1542                 int const_reg = mono_regstate_next_int (s->rs);
1543                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, tree->inst_newa_class);
1544                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, const_reg);
1545         } else {
1546                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, tree->inst_newa_class);
1547         }
1548         MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1549         MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, value));
1550 }
1551
1552 reg: OP_REFANYTYPE (reg) {
1553         MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, type));
1554 }
1555
1556 stmt: CEE_MKREFANY (OP_GROUP (reg, OP_ICONST), reg),
1557 stmt: CEE_MKREFANY (OP_GROUP (reg, OP_I8CONST), reg) {
1558         MonoClass *klass = (MonoClass*)(tree->inst_left->inst_right->inst_p0);
1559         if (s->compile_aot) {
1560                 int const_reg = mono_regstate_next_int (s->rs);
1561                 int type_reg = mono_regstate_next_int (s->rs);
1562                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
1563                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass), const_reg);
1564                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, type_reg, const_reg, G_STRUCT_OFFSET (MonoClass, byval_arg));
1565                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, type), type_reg);
1566         }
1567         else {
1568                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STOREP_MEMBASE_IMM, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, type), &klass->byval_arg);
1569                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STOREP_MEMBASE_IMM, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass), klass);
1570         }
1571         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, value), state->left->left->reg1);
1572 }
1573
1574 %%
1575
1576 static void mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpointer cons);
1577
1578 /*
1579  * Emit code which checks whenever the interface id of @klass is smaller than
1580  * than the value given by max_iid_reg.
1581 */
1582 static void
1583 mini_emit_max_iid_check (MonoCompile *s, int max_iid_reg, MonoClass *klass,
1584                                                  MonoInst *false_target)
1585 {
1586         if (s->compile_aot) {
1587                 int iid_reg = mono_regstate_next_int (s->rs);
1588                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
1589                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, max_iid_reg, iid_reg);
1590         } else {
1591                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, max_iid_reg, klass->interface_id);
1592         }
1593         if (false_target)
1594                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BLT_UN, false_target);
1595         else
1596                 MONO_EMIT_NEW_COND_EXC (s, LT_UN, "InvalidCastException");
1597 }
1598
1599 /* Same as above, but obtains max_iid from a vtable */
1600 static void
1601 mini_emit_max_iid_check_vtable (MonoCompile *s, int vtable_reg, MonoClass *klass,
1602                                                                  MonoInst *false_target)
1603 {
1604         int max_iid_reg = mono_regstate_next_int (s->rs);
1605
1606         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, max_iid_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, max_interface_id));
1607         mini_emit_max_iid_check (s, max_iid_reg, klass, false_target);
1608 }
1609
1610 /* Same as above, but obtains max_iid from a klass */
1611 static void
1612 mini_emit_max_iid_check_class (MonoCompile *s, int klass_reg, MonoClass *klass,
1613                                                                  MonoInst *false_target)
1614 {
1615         int max_iid_reg = mono_regstate_next_int (s->rs);
1616
1617         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, max_iid_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, max_interface_id));
1618         mini_emit_max_iid_check (s, max_iid_reg, klass, false_target);
1619 }
1620
1621 /* Emit code which loads interface_offsets [klass->interface_id]
1622  * The array is stored in memory before vtable.
1623  */
1624 static void
1625 mini_emit_load_intf_reg_vtable (MonoCompile *s, int intf_reg, int vtable_reg, MonoClass *klass)
1626 {
1627         if (s->compile_aot) {
1628                 int ioffset_reg = mono_regstate_next_int (s->rs);
1629                 int iid_reg = mono_regstate_next_int (s->rs);
1630                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_ADJUSTED_IID);
1631                 MONO_EMIT_NEW_BIALU (s, OP_PADD, ioffset_reg, iid_reg, vtable_reg);
1632                 MONO_EMIT_NEW_LOAD_MEMBASE (s, intf_reg, ioffset_reg, 0);
1633         } else {
1634                 MONO_EMIT_NEW_LOAD_MEMBASE (s, intf_reg, vtable_reg, -((klass->interface_id + 1) * SIZEOF_VOID_P));
1635         }
1636 }
1637
1638 /* Emit code which loads <klass_reg>->interface_offsets [klass->interface_id] */
1639 static void
1640 mini_emit_load_intf_reg_class (MonoCompile *s, int intf_reg, int klass_reg, MonoClass *klass)
1641 {
1642         int ioffset_reg = mono_regstate_next_int (s->rs);
1643
1644         MONO_EMIT_NEW_LOAD_MEMBASE (s, ioffset_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_offsets));
1645
1646         if (s->compile_aot) {
1647                 int iid_reg = mono_regstate_next_int (s->rs);
1648                 int shifted_iid_reg = mono_regstate_next_int (s->rs);
1649                 MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
1650                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, shifted_iid_reg, iid_reg, 2);
1651                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, ioffset_reg, ioffset_reg, shifted_iid_reg);
1652                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, intf_reg, ioffset_reg, 0);
1653         } else {
1654                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, intf_reg, ioffset_reg, klass->interface_id * sizeof (int));
1655         }
1656 }
1657
1658 static void
1659 mini_emit_virtual_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop, int virtop)
1660 {
1661         MonoMethod *method = ((MonoCallInst*)tree)->method;
1662         int vtable_reg, slot_reg, this_reg;
1663         MBState *state = st;
1664
1665         this_reg = state->left->reg1;
1666         mono_arch_emit_this_vret_args (cfg, (MonoCallInst*)tree, this_reg, state->left->tree->type, novirtop == OP_VCALL? state->right->reg1: -1);
1667
1668         if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
1669              ((method->flags & METHOD_ATTRIBUTE_FINAL) &&
1670              method->wrapper_type != MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)) {
1671                 /*
1672                  * the method is not virtual, we just need to ensure this is not null
1673                  * and then we can call the method directly.
1674                  */
1675                 if (method->klass->marshalbyref || method->klass == mono_defaults.object_class) {
1676                         method = ((MonoCallInst*)tree)->method = mono_marshal_get_remoting_invoke_with_check (method);
1677                 }
1678
1679                 if (!method->string_ctor)
1680                         MONO_EMIT_NEW_UNALU (cfg, OP_CHECK_THIS, -1, this_reg);
1681
1682                 tree->dreg = state->reg1;
1683                 tree->opcode = novirtop;
1684                 mono_bblock_add_inst (cfg->cbb, tree);
1685                 return;
1686         }
1687
1688         /* Initialize method->slot */
1689         mono_class_setup_vtable (method->klass);
1690
1691         vtable_reg = mono_regstate_next_int (cfg->rs);
1692         MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
1693         if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
1694                 slot_reg = mono_regstate_next_int (cfg->rs);
1695                 mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, method->klass);
1696                 tree->inst_offset = method->slot * SIZEOF_VOID_P;
1697         } else {
1698                 slot_reg = vtable_reg;
1699                 tree->inst_offset = G_STRUCT_OFFSET (MonoVTable, vtable) + (method->slot * SIZEOF_VOID_P);
1700         }
1701
1702         tree->dreg = state->reg1;
1703         tree->opcode = virtop;
1704         tree->sreg1 = slot_reg;
1705         ((MonoCallInst*)tree)->virtual = TRUE;
1706         mono_bblock_add_inst (cfg->cbb, tree);
1707 }
1708
1709 static void
1710 mini_emit_isninst_cast (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target)
1711 {
1712         int idepth_reg = mono_regstate_next_int (s->rs);
1713         int stypes_reg = mono_regstate_next_int (s->rs);
1714         int stype = mono_regstate_next_int (s->rs);
1715
1716         if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1717                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1718                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
1719                 MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BLT_UN, false_target);
1720         }
1721         MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1722         MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1723         if (s->compile_aot) {
1724                 int const_reg = mono_regstate_next_int (s->rs);
1725                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
1726                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, stype, const_reg);
1727         } else {
1728                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, stype, klass);
1729         }
1730         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, true_target);
1731 }
1732
1733 static void
1734 mini_emit_isninst_iface_cast (MonoCompile *s, int vtable_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target)
1735 {
1736         int intf_reg = mono_regstate_next_int (s->rs);
1737
1738         mini_emit_max_iid_check_vtable (s, vtable_reg, klass, false_target);
1739         mini_emit_load_intf_reg_vtable (s, intf_reg, vtable_reg, klass);
1740         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, 0);
1741         /* the object_is_null target simply copies the input register to the output */
1742         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, true_target);
1743 }
1744
1745 /*
1746  * Variant of the above that takes a register to the class, not the vtable.
1747  * Note that inside interfaces_offsets the empty value is -1, not NULL, in this case.
1748  */
1749 static void
1750 mini_emit_isninst_iface_class_cast (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target)
1751 {
1752         int intf_reg = mono_regstate_next_int (s->rs);
1753
1754         mini_emit_max_iid_check_class (s, klass_reg, klass, false_target);
1755         mini_emit_load_intf_reg_class (s, intf_reg, klass_reg, klass);
1756         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, -1);
1757         /* the object_is_null target simply copies the input register to the output */
1758         MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BGE, true_target);
1759 }
1760
1761 static void
1762 mini_emit_castclass (MonoCompile *s, int klass_reg, MonoClass *klass)
1763 {
1764         int idepth_reg = mono_regstate_next_int (s->rs);
1765         int stypes_reg = mono_regstate_next_int (s->rs);
1766         int stype = mono_regstate_next_int (s->rs);
1767
1768         if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
1769                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
1770                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
1771                 MONO_EMIT_NEW_COND_EXC (s, LT_UN, "InvalidCastException");
1772         }
1773         MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
1774         MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
1775         if (s->compile_aot) {
1776                 int const_reg = mono_regstate_next_int (s->rs);
1777                 MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
1778                 MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, stype, const_reg);
1779         } else {
1780                 MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, stype, klass);
1781         }
1782         MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
1783 }
1784
1785 static void
1786 mini_emit_castclass_iface (MonoCompile *s, int vtable_reg, MonoClass *klass)
1787 {
1788         int intf_reg = mono_regstate_next_int (s->rs);
1789
1790         mini_emit_max_iid_check_vtable (s, vtable_reg, klass, NULL);
1791         mini_emit_load_intf_reg_vtable (s, intf_reg, vtable_reg, klass);
1792         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, 0);
1793         MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
1794 }
1795
1796 /*
1797  * Variant of the aboce that takes a register to the class, not the vtable.
1798  * Note that inside interfaces_offsets the empty value is -1, not NULL, in this case.
1799  */
1800 static void
1801 mini_emit_castclass_iface_class (MonoCompile *s, int klass_reg, MonoClass *klass)
1802 {
1803         int intf_reg = mono_regstate_next_int (s->rs);
1804
1805         mini_emit_max_iid_check_class (s, klass_reg, klass, NULL);
1806         mini_emit_load_intf_reg_class (s, intf_reg, klass_reg, klass);
1807         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, -1);
1808         MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
1809 }
1810
1811 static void
1812 mini_emit_memcpy (MonoCompile *s, int destreg, int doffset, int srcreg, int soffset, int size, int align)
1813 {
1814         int cur_reg;
1815
1816         /* FIXME: consider alignment for archs that need it. */
1817 #if !NO_UNALIGNED_ACCESS
1818         if (sizeof (gpointer) == 8) {
1819                 while (size >= 8) {
1820                         cur_reg = mono_regstate_next_int (s->rs);
1821                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI8_MEMBASE, cur_reg, srcreg, soffset);
1822                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, destreg, doffset, cur_reg);
1823                         doffset += 8;
1824                         soffset += 8;
1825                         size -= 8;
1826                 }
1827         }
1828 #endif
1829
1830         while (size >= 4) {
1831                 cur_reg = mono_regstate_next_int (s->rs);
1832                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, cur_reg, srcreg, soffset);
1833                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, doffset, cur_reg);
1834                 doffset += 4;
1835                 soffset += 4;
1836                 size -= 4;
1837         }
1838         while (size >= 2) {
1839                 cur_reg = mono_regstate_next_int (s->rs);
1840                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, cur_reg, srcreg, soffset);
1841                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI2_MEMBASE_REG, destreg, doffset, cur_reg);
1842                 doffset += 2;
1843                 soffset += 2;
1844                 size -= 2;
1845         }
1846         while (size >= 1) {
1847                 cur_reg = mono_regstate_next_int (s->rs);
1848                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset);
1849                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg);
1850                 doffset += 1;
1851                 soffset += 1;
1852                 size -= 1;
1853         }
1854 }
1855
1856 static void
1857 mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, int align)
1858 {
1859         int val_reg = mono_regstate_next_int (s->rs);
1860
1861         if (sizeof (gpointer) == 8)
1862                 MONO_EMIT_NEW_I8CONST (s, val_reg, val);
1863         else
1864                 MONO_EMIT_NEW_ICONST (s, val_reg, val);
1865
1866         /* FIXME: consider alignment for archs that need it. */
1867 #if !NO_UNALIGNED_ACCESS
1868         if (sizeof (gpointer) == 8) {
1869                 if (offset % 8) {
1870                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
1871                         offset += 4;
1872                         size -= 4;
1873                 }
1874                 while (size >= 8) {
1875                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, destreg, offset, val_reg);
1876                         offset += 8;
1877                         size -= 8;
1878                 }
1879         }
1880 #endif
1881
1882         while (size >= 4) {
1883                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
1884                 offset += 4;
1885                 size -= 4;
1886         }
1887         while (size >= 2) {
1888                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI2_MEMBASE_REG, destreg, offset, val_reg);
1889                 offset += 2;
1890                 size -= 2;
1891         }
1892         while (size >= 1) {
1893                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg);
1894                 offset += 1;
1895                 size -= 1;
1896         }
1897 }
1898
1899 /* This is similar to NEW_AOTCONST in mini.c, but generates linear IL */
1900 static void
1901 mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpointer cons)
1902 {
1903         MonoInst *dest, *pinfo;
1904         int got_var_reg;
1905
1906         dest = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
1907         dest->opcode = OP_GOT_ENTRY;
1908
1909         g_assert (cfg->got_var);
1910
1911         pinfo = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst));
1912         pinfo->opcode = OP_PATCH_INFO;
1913         pinfo->inst_left = cons;
1914         pinfo->inst_right = (gpointer)(patch_type);
1915
1916         if (cfg->got_var->opcode == OP_REGOFFSET) {
1917                 got_var_reg = mono_regstate_next_int (cfg->rs);
1918                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, got_var_reg, cfg->got_var->inst_basereg, cfg->got_var->inst_offset);
1919         } else {
1920                 g_assert (cfg->got_var->opcode == OP_REGVAR);
1921                 got_var_reg = cfg->got_var->dreg;
1922         }
1923
1924         dest = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst));
1925         dest->opcode = OP_GOT_ENTRY;
1926         dest->inst_left = cfg->got_var; /* not used */
1927         dest->inst_right = pinfo;
1928
1929         dest->inst_basereg = got_var_reg;
1930         dest->dreg = dreg;
1931         mono_bblock_add_inst (cfg->cbb, dest);
1932 }
1933
1934 static int
1935 ldind_to_load_membase (int opcode)
1936 {
1937         switch (opcode) {
1938         case CEE_LDIND_I1:
1939                 return OP_LOADI1_MEMBASE;
1940         case CEE_LDIND_U1:
1941                 return OP_LOADU1_MEMBASE;
1942         case CEE_LDIND_I2:
1943                 return OP_LOADI2_MEMBASE;
1944         case CEE_LDIND_U2:
1945                 return OP_LOADU2_MEMBASE;
1946         case CEE_LDIND_I4:
1947                 return OP_LOADI4_MEMBASE;
1948         case CEE_LDIND_U4:
1949                 return OP_LOADU4_MEMBASE;
1950         case CEE_LDIND_I:
1951                 return OP_LOAD_MEMBASE;
1952         case CEE_LDIND_REF:
1953                 return OP_LOAD_MEMBASE;
1954         case CEE_LDIND_I8:
1955                 return OP_LOADI8_MEMBASE;
1956         default:
1957                 g_assert_not_reached ();
1958         }
1959
1960         return -1;
1961 }
1962