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