X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Finssel.brg;h=3b7b094c4ee76451ad2d1b49c8ca688f3d7e888c;hb=72bb61054d706a82a178dc16a4b8a550e62e034f;hp=3357a2ec6dd88fb9fba892d7cc9eb77f20a3dc53;hpb=b5cfba1835f2ba823796f825410e0062b7e4c9a3;p=mono.git diff --git a/mono/mini/inssel.brg b/mono/mini/inssel.brg index 3357a2ec6dd..3b7b094c4ee 100644 --- a/mono/mini/inssel.brg +++ b/mono/mini/inssel.brg @@ -35,8 +35,7 @@ #define MONO_EMIT_NEW_UNALU(cfg,op,dr,sr1) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->dreg = dr; \ inst->sreg1 = sr1; \ mono_bblock_add_inst (cfg->cbb, inst); \ @@ -52,8 +51,7 @@ #define MONO_EMIT_NEW_BIALU(cfg,op,dr,sr1,sr2) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->dreg = dr; \ inst->sreg1 = sr1; \ inst->sreg2 = sr2; \ @@ -70,8 +68,7 @@ #define MONO_EMIT_NEW_BIALU_IMM(cfg,op,dr,sr,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->dreg = dr; \ inst->sreg1 = sr; \ inst->inst_p1 = (gpointer)(gssize)(imm); \ @@ -105,8 +102,7 @@ #define MONO_EMIT_NEW_LOAD_MEM(cfg,dr,addr) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_LOADU4_MEM; \ + MONO_INST_NEW ((cfg), inst, OP_LOADU4_MEM); \ inst->dreg = dr; \ inst->inst_p0 = addr; \ mono_bblock_add_inst (cfg->cbb, inst); \ @@ -114,8 +110,7 @@ #define MONO_EMIT_NEW_LOAD_MEMBASE(cfg,dr,base,offset) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_LOAD_MEMBASE; \ + MONO_INST_NEW ((cfg), inst, OP_LOAD_MEMBASE); \ inst->dreg = dr; \ inst->inst_basereg = base; \ inst->inst_offset = offset; \ @@ -124,8 +119,7 @@ #define MONO_EMIT_NEW_LOAD_MEMBASE_OP(cfg,op,dr,base,offset) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->dreg = dr; \ inst->inst_basereg = base; \ inst->inst_offset = offset; \ @@ -142,8 +136,7 @@ #define MONO_EMIT_NEW_STORE_MEMBASE(cfg,op,base,offset,sr) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->sreg1 = sr; \ inst->inst_destbasereg = base; \ inst->inst_offset = offset; \ @@ -160,8 +153,7 @@ #define MONO_EMIT_NEW_STORE_MEMBASE_IMM(cfg,op,base,offset,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->inst_destbasereg = base; \ inst->inst_offset = offset; \ inst->inst_p1 = (gpointer)imm; \ @@ -170,8 +162,7 @@ #define MONO_EMIT_NEW_COMPARE_IMM(cfg,sr1,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_COMPARE_IMM; \ + MONO_INST_NEW ((cfg), inst, OP_COMPARE_IMM); \ inst->sreg1 = sr1; \ inst->inst_p1 = (gpointer)imm; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -179,8 +170,7 @@ #define MONO_EMIT_NEW_ICOMPARE_IMM(cfg,sr1,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = sizeof (void*) == 8 ? OP_ICOMPARE_IMM : OP_COMPARE_IMM; \ + MONO_INST_NEW ((cfg), inst, sizeof (void*) == 8 ? OP_ICOMPARE_IMM : OP_COMPARE_IMM); \ inst->sreg1 = sr1; \ inst->inst_p1 = (gpointer)imm; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -188,7 +178,7 @@ #define MONO_EMIT_NEW_COND_EXC(cfg,cond,name) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ + MONO_INST_NEW ((cfg), inst, OP_NOP); \ inst->opcode = OP_COND_EXC_##cond; \ inst->inst_p1 = (char*)name; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -196,8 +186,7 @@ #define MONO_EMIT_NEW_ICONST(cfg,dr,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_ICONST; \ + MONO_INST_NEW ((cfg), inst, OP_ICONST); \ inst->dreg = dr; \ inst->inst_c0 = imm; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -205,8 +194,7 @@ #define MONO_EMIT_NEW_I8CONST(cfg,dr,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_I8CONST; \ + MONO_INST_NEW ((cfg), inst, OP_I8CONST); \ inst->dreg = dr; \ inst->inst_l = imm; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -214,8 +202,7 @@ #define MONO_EMIT_NEW_PCONST(cfg,dr,imm) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_ICONST; \ + MONO_INST_NEW ((cfg), inst, OP_ICONST); \ inst->dreg = dr; \ inst->inst_p0 = (gpointer) imm; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -232,8 +219,7 @@ #define MONO_EMIT_NEW_AOTCONST(cfg,dr,imm,type) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = OP_AOTCONST; \ + MONO_INST_NEW ((cfg), inst, OP_AOTCONST); \ inst->dreg = dr; \ inst->inst_p0 = imm; \ inst->inst_c1 = type; \ @@ -250,11 +236,10 @@ MonoInst *target_label; \ target_label = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ target_label->opcode = OP_LABEL; \ - target_label->next = (targetbb)->code; \ + target_label->next = (targetbb)->code; \ + (targetbb)->code = target_label; \ target_label->inst_c0 = (targetbb)->native_offset; \ - (targetbb)->code = target_label; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->inst_i0 = target_label; \ inst->flags = MONO_INST_BRLABEL; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -262,8 +247,7 @@ #define MONO_EMIT_NEW_BRANCH_LABEL(cfg,op,label) do { \ MonoInst *inst; \ - inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \ - inst->opcode = op; \ + MONO_INST_NEW ((cfg), inst, op); \ inst->inst_i0 = label; \ inst->flags = MONO_INST_BRLABEL; \ mono_bblock_add_inst ((cfg)->cbb, inst); \ @@ -278,8 +262,7 @@ if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \ int _length_reg = mono_regstate_next_int (cfg->rs); \ MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \ - MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, _length_reg, index_reg); \ - MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \ + MONO_EMIT_NEW_COMPARE_EXC (cfg, LE_UN, _length_reg, index_reg, "IndexOutOfRangeException"); \ } \ } while (0) @@ -287,11 +270,91 @@ if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \ int _length_reg = mono_regstate_next_int (cfg->rs); \ MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \ - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, _length_reg, index_imm); \ - MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \ + MONO_EMIT_NEW_COMPARE_IMM_EXC (cfg, LE_UN, _length_reg, index_imm, "IndexOutOfRangeException"); \ } \ } while (0) +#ifndef MONO_EMIT_NEW_COMPARE_EXC +#define MONO_EMIT_NEW_COMPARE_EXC(cfg, cmp_op, sreg1, sreg2, exc) do { \ + MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, sreg1, sreg2); \ + MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_IMM_EXC +#define MONO_EMIT_NEW_COMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \ + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, sreg1, imm); \ + MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_ICOMPARE_IMM_EXC +#define MONO_EMIT_NEW_ICOMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \ + MONO_EMIT_NEW_ICOMPARE_IMM(cfg, sreg1, imm); \ + MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_BRANCH_LABEL +#define MONO_EMIT_NEW_COMPARE_BRANCH_LABEL(cfg, cmp_op, sreg1, sreg2, label) \ + do { \ + MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, (sreg1), (sreg2)); \ + MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_BRANCH_LABEL_CHAINED +#define MONO_EMIT_NEW_COMPARE_BRANCH_LABEL_CHAINED(cfg, cmp_op, sreg1, sreg2, label) \ + do { \ + MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \ +} while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL +#define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL(cfg, cmp_op, sreg1, imm, label) \ + do { \ + MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, (sreg1), (imm)); \ + MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL_CHAINED +#define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL_CHAINED(cfg, cmp_op, sreg1, imm, label) \ + do { \ + MONO_EMIT_NEW_BRANCH_LABEL (s, (cmp_op), (label)); \ +} while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK +#define MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK(cfg, cmp_op, sreg1, sreg2, block) \ + do { \ + MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, (sreg1), (sreg2)); \ + MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK_CHAINED +#define MONO_EMIT_NEW_COMPARE_BRANCH_BLOCK_CHAINED(cfg, cmp_op, sreg1, sreg2, block) \ + do { \ + MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \ +} while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK +#define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK(cfg, cmp_op, sreg1, imm, block) \ + do { \ + MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, (sreg1), (imm)); \ + MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \ + } while (0) +#endif + +#ifndef MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK_CHAINED +#define MONO_EMIT_NEW_COMPARE_IMM_BRANCH_BLOCK_CHAINED(cfg, cmp_op, sreg1, imm, block) \ + do { \ + MONO_EMIT_NEW_BRANCH_BLOCK (s, (cmp_op), (block)); \ +} while (0) +#endif + %% %termprefix OP_ CEE_ @@ -308,8 +371,7 @@ base: reg "0" { * normal rules. */ MonoInst *inst; - inst = mono_mempool_alloc0 (s->mempool, sizeof (MonoInst)); - inst->opcode = OP_ICONST; /* doesn't matter */ + MONO_INST_NEW (s, inst, OP_NOP); /* The opcode doesn't matter */ inst->inst_basereg = state->reg1; inst->inst_offset = 0; state->tree = inst; @@ -349,6 +411,7 @@ base: CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST) "0" { # reg: OP_ICONST { + tree->dreg = state->reg1; MONO_EMIT_NEW_ICONST (s, state->reg1, tree->inst_c0); } @@ -557,16 +620,18 @@ stmt: CEE_STIND_I (OP_REGVAR, reg) { } stmt: OP_MEMCPY (base, base) { - int size = tree->backend.size; + int size = tree->backend.memcpy_args->size; + int align = tree->backend.memcpy_args->align; if (size > 0) mini_emit_memcpy (s, state->left->tree->inst_basereg, state->left->tree->inst_offset, - state->right->tree->inst_basereg, state->right->tree->inst_offset, size, 0); + state->right->tree->inst_basereg, state->right->tree->inst_offset, size, align); } stmt: OP_MEMSET (base) { - int size = tree->backend.size; + int size = tree->backend.memcpy_args->size; + int align = tree->backend.memcpy_args->align; if (size > 0) - mini_emit_memset (s, state->left->tree->inst_basereg, state->left->tree->inst_offset, size, tree->inst_imm, 0); + mini_emit_memset (s, state->left->tree->inst_basereg, state->left->tree->inst_offset, size, tree->inst_imm, align); } reg: OP_LDELEMA2D (reg, OP_GROUP (reg, reg)) "20" { @@ -596,16 +661,14 @@ reg: OP_LDELEMA2D (reg, OP_GROUP (reg, reg)) "20" { MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx1_reg, index1, low1_reg); MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high1_reg, bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, length)); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, high1_reg, realidx1_reg); - MONO_EMIT_NEW_COND_EXC (s, LE_UN, "IndexOutOfRangeException"); + MONO_EMIT_NEW_COMPARE_EXC (s, LE_UN, high1_reg, realidx1_reg, "IndexOutOfRangeException"); MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, low2_reg, bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, lower_bound)); MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx2_reg, index2, low2_reg); MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high2_reg, bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, length)); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, high2_reg, realidx2_reg); - MONO_EMIT_NEW_COND_EXC (s, LE_UN, "IndexOutOfRangeException"); + MONO_EMIT_NEW_COMPARE_EXC (s, LE_UN, high2_reg, realidx2_reg, "IndexOutOfRangeException"); MONO_EMIT_NEW_BIALU (s, CEE_MUL, mult_reg, high2_reg, realidx1_reg); MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, mult_reg, realidx2_reg); @@ -650,56 +713,47 @@ reg: CEE_CONV_OVF_I4_UN (reg) { if (sizeof (void *) == 8) { MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1); } else { - MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0); - MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException"); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT, state->left->reg1, 0, "OverflowException"); MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1); } } reg: CEE_CONV_OVF_I1 (reg) { - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 127); - MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException"); - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, -128); - MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT, state->left->reg1, 127, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, LT, state->left->reg1, -128, "OverflowException"); MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1); } reg: CEE_CONV_OVF_I1_UN (reg) { /* probe values between 0 to 127 */ - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 127); - MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 127, "OverflowException"); MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1); } reg: CEE_CONV_OVF_U1 (reg), reg: CEE_CONV_OVF_U1_UN (reg) { /* probe value to be within 0 to 255 */ - MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 255); - MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException"); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 255, "OverflowException"); MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff); } reg: CEE_CONV_OVF_I2 (reg) { /* Probe value to be within -32768 and 32767 */ - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 32767); - MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException"); - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, -32768); - MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT, state->left->reg1, 32767, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, LT, state->left->reg1, -32768, "OverflowException"); MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1); } reg: CEE_CONV_OVF_I2_UN (reg) { /* Convert uint value into short, value within 0 and 32767 */ - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 32767); - MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 32767, "OverflowException"); MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1); } reg: CEE_CONV_OVF_U2 (reg), reg: CEE_CONV_OVF_U2_UN (reg) { /* Probe value to be within 0 and 65535 */ - MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 0xffff); - MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException"); + MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 0xffff, "OverflowException"); MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff); } @@ -711,7 +765,7 @@ reg: OP_CEQ (cflags), reg: OP_CLT (cflags), reg: OP_CLT_UN (cflags), reg: OP_CGT (cflags), -reg: OP_CGT_UN (cflags) { +reg: OP_CGT_UN (cflags) "2" { tree->dreg = state->reg1; mono_bblock_add_inst (s->cbb, tree); } @@ -724,10 +778,10 @@ stmt: OP_LABEL { mono_bblock_add_inst (s->cbb, tree); } -stmt: CEE_NOP "0" { +stmt: OP_NOP "0" { } -stmt: CEE_BREAK "0" { +stmt: OP_BREAK "0" { mono_bblock_add_inst (s->cbb, tree); } @@ -736,7 +790,7 @@ reg: OP_TLS_GET { mono_bblock_add_inst (s->cbb, tree); } -stmt: CEE_SWITCH (reg) "2" { +stmt: OP_SWITCH (reg) "2" { MonoInst *label; int offset_reg = mono_regstate_next_int (s->rs); int target_reg = mono_regstate_next_int (s->rs); @@ -744,12 +798,17 @@ stmt: CEE_SWITCH (reg) "2" { MONO_NEW_LABEL (s, label); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n); - MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]); - if (sizeof (gpointer) == 8) + if (sizeof (gpointer) == 8) { + MONO_EMIT_NEW_BIALU_IMM (s, OP_ICOMPARE_IMM, -1, state->left->reg1, n); + MONO_EMIT_NEW_BRANCH_BLOCK (s, OP_IBGE_UN, tree->inst_many_bb [n]); MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 3); - else + /* The upper word might not be zero, and we add it to a 64 bit address later */ + MONO_EMIT_NEW_UNALU (s, CEE_CONV_U8, offset_reg, offset_reg); + } else { + MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n); + MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]); MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 2); + } mono_bblock_add_inst (s->cbb, label); if (s->compile_aot) { int table_reg = mono_regstate_next_int (s->rs); @@ -770,14 +829,14 @@ stmt: CEE_SWITCH (reg) "2" { /* the backend must patch the address. we use 0xf0f0f0f0 to avoid the usage * of special (short) opcodes on x86 */ if (sizeof (gpointer) == 8) - MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, (long)0xf0f0f0f0f0f0f0f1LL); + MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, (gint64)0xf0f0f0f0f0f0f0f1LL); else MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, offset_reg, 0xf0f0f0f0); } MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg); } -stmt: CEE_BR "0" { +stmt: OP_BR "0" { mono_bblock_add_inst (s->cbb, tree); } @@ -786,13 +845,13 @@ stmt: OP_ARGLIST (reg) { mono_bblock_add_inst (s->cbb, tree); } -reg: CEE_CALL { +reg: OP_CALL { tree->dreg = state->reg1; mono_bblock_add_inst (s->cbb, tree); } -reg: CEE_CALLVIRT (reg) { - mini_emit_virtual_call (s, state, tree, CEE_CALL, OP_CALL_MEMBASE); +reg: OP_CALLVIRT (reg) { + mini_emit_virtual_call (s, state, tree, OP_CALL, OP_CALL_MEMBASE); } stmt: OP_VOIDCALLVIRT (reg) { @@ -807,6 +866,29 @@ stmt: OP_VCALLVIRT (reg, reg) { mini_emit_virtual_call (s, state, tree, OP_VCALL, OP_VCALL_MEMBASE); } +reg: OP_CALLVIRT_IMT (reg, reg) { + tree->opcode = OP_CALLVIRT; + mini_emit_virtual_imt_call (s, state, tree, OP_CALL, OP_CALL_MEMBASE, state->right->reg1); +} + +stmt: OP_VOIDCALLVIRT_IMT (reg, reg) { + tree->opcode = OP_VOIDCALLVIRT; + mini_emit_virtual_imt_call (s, state, tree, OP_VOIDCALL, OP_VOIDCALL_MEMBASE, state->right->reg1); +} + +freg: OP_FCALLVIRT_IMT (reg, reg) { + tree->opcode = OP_FCALLVIRT; + mini_emit_virtual_imt_call (s, state, tree, OP_FCALL, OP_FCALL_MEMBASE, state->right->reg1); +} + +stmt: OP_VCALLVIRT_IMT (OP_GROUP (reg, reg), reg) { + int imt_reg = state->left->right->reg1; + tree->opcode = OP_VCALLVIRT; + tree->inst_left = tree->inst_left->inst_left; + state->left = state->left->left; + mini_emit_virtual_imt_call (s, state, tree, OP_VCALL, OP_VCALL_MEMBASE, imt_reg); +} + reg: OP_CALL_REG (reg) { tree->sreg1 = state->left->reg1; tree->dreg = state->reg1; @@ -845,6 +927,85 @@ stmt: OP_VCALL_REG (reg, reg) { mono_bblock_add_inst (s->cbb, tree); } +stmt: OP_TRAMPCALL_VTABLE (reg) { + #ifdef MONO_ARCH_VTABLE_REG + MonoCallInst *call = (MonoCallInst*)tree; + int vtable_reg = mono_regstate_next_int (s->rs); + + MONO_EMIT_NEW_UNALU (s, OP_MOVE, vtable_reg, state->left->reg1); + + call->inst.opcode = OP_VOIDCALL; + + mono_call_inst_add_outarg_reg (s, call, vtable_reg, MONO_ARCH_VTABLE_REG, FALSE); + + mono_bblock_add_inst (s->cbb, &call->inst); + #else + g_assert_not_reached (); + #endif +} + +reg: OP_CALL_RGCTX (reg) { + emit_rgctx_argument (s, tree, state->left->reg1, OP_CALL); + + tree->dreg = state->reg1; + mono_bblock_add_inst (s->cbb, tree); +} + +freg: OP_FCALL_RGCTX (reg) { + emit_rgctx_argument (s, tree, state->left->reg1, OP_FCALL); + + tree->dreg = state->reg1; + mono_bblock_add_inst (s->cbb, tree); +} + +stmt: OP_VOIDCALL_RGCTX (reg) { + emit_rgctx_argument (s, tree, state->left->reg1, OP_VOIDCALL); + + mono_bblock_add_inst (s->cbb, tree); +} + +stmt: OP_VCALL_RGCTX (reg, reg) { + emit_rgctx_argument (s, tree, state->right->reg1, OP_VCALL); + + mono_arch_emit_this_vret_args (s, (MonoCallInst*)tree, -1, -1, state->left->reg1); + mono_bblock_add_inst (s->cbb, tree); +} + +reg: OP_CALL_REG_RGCTX (reg, reg) { + emit_rgctx_argument (s, tree, state->right->reg1, OP_CALL_REG); + + tree->sreg1 = state->left->reg1; + tree->dreg = state->reg1; + mono_bblock_add_inst (s->cbb, tree); +} + +freg: OP_FCALL_REG_RGCTX (reg, reg) { + emit_rgctx_argument (s, tree, state->right->reg1, OP_FCALL_REG); + + tree->sreg1 = state->left->reg1; + tree->dreg = state->reg1; + mono_bblock_add_inst (s->cbb, tree); +} + +stmt: OP_VOIDCALL_REG_RGCTX (reg, reg) { + emit_rgctx_argument (s, tree, state->right->reg1, OP_VOIDCALL_REG); + + tree->sreg1 = state->left->reg1; + mono_bblock_add_inst (s->cbb, tree); +} + +stmt: OP_VCALL_REG_RGCTX (OP_GROUP (reg, reg), reg) { + emit_rgctx_argument (s, tree, state->left->right->reg1, OP_VCALL_REG); + + tree->inst_left = tree->inst_left->inst_left; + state->left = state->left->left; + + mono_arch_emit_this_vret_args (s, (MonoCallInst*)tree, -1, -1, state->right->reg1); + + tree->sreg1 = state->left->reg1; + mono_bblock_add_inst (s->cbb, tree); +} + stmt: OP_SAVE_LMF, stmt: OP_RESTORE_LMF { mono_bblock_add_inst (s->cbb, tree); @@ -856,7 +1017,7 @@ stmt: OP_RESTORE_LMF { reg: OP_CALL_REG (OP_ICONST), reg: OP_CALL_REG (OP_I8CONST) { - tree->opcode = CEE_CALL; + tree->opcode = OP_CALL; ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0; tree->dreg = state->reg1; mono_bblock_add_inst (s->cbb, tree); @@ -877,10 +1038,6 @@ freg: OP_FCALL_REG (OP_I8CONST) { mono_bblock_add_inst (s->cbb, tree); } -stmt: CEE_RET "0" { - mono_bblock_add_inst (s->cbb, tree); -} - stmt: CEE_POP (reg) # remove some common pops without side effects @@ -902,14 +1059,14 @@ stmt: CEE_POP (CEE_LDIND_U4 (OP_REGVAR)) stmt: CEE_POP (CEE_LDIND_I (OP_REGVAR)) stmt: CEE_POP (CEE_LDIND_REF (OP_REGVAR)) -stmt: CEE_JMP "0" { +stmt: OP_JMP "0" { mono_bblock_add_inst (s->cbb, tree); } # exception handling -stmt: CEE_THROW (reg) { - MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->reg1); +stmt: OP_THROW (reg) { + MONO_EMIT_UNALU (s, tree, OP_THROW, -1, state->left->reg1); } stmt: OP_RETHROW (reg) { @@ -926,14 +1083,13 @@ stmt: OP_THROW_OR_NULL (reg, reg) { * that this is not correct. See thread6.cs for an example. But propagating * the abort exception is more important than getting the sematics right. */ - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, dont_throw); - MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->reg1); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, state->left->reg1, 0, dont_throw); + MONO_EMIT_UNALU (s, tree, OP_THROW, -1, state->left->reg1); mono_bblock_add_inst (s->cbb, dont_throw); } -stmt: CEE_THROW (CEE_LDIND_REF (OP_REGVAR)) { - MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->left->tree->dreg); +stmt: OP_THROW (CEE_LDIND_REF (OP_REGVAR)) { + MONO_EMIT_UNALU (s, tree, OP_THROW, -1, state->left->left->tree->dreg); } stmt: OP_CALL_HANDLER { @@ -944,7 +1100,7 @@ stmt: OP_START_HANDLER "2" { mono_bblock_add_inst (s->cbb, tree); } -stmt: CEE_ENDFINALLY "2" { +stmt: OP_ENDFINALLY "2" { mono_bblock_add_inst (s->cbb, tree); } @@ -958,6 +1114,16 @@ stmt: OP_CHECK_THIS (reg) { mono_bblock_add_inst (s->cbb, tree); } +reg: OP_CHECK_THIS_PASSTHROUGH (reg) { + MonoInst *check; + + MONO_INST_NEW (s, check, OP_CHECK_THIS); + check->sreg1 = state->left->reg1; + mono_bblock_add_inst (s->cbb, check); + + MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1); +} + # object related opcodes reg: CEE_ISINST (reg) { @@ -970,13 +1136,12 @@ reg: CEE_ISINST (reg) { MONO_NEW_LABEL (s, end_label); MONO_NEW_LABEL (s, false_label); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, object_is_null); if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) { MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); /* the object_is_null target simply copies the input register to the output */ - mini_emit_isninst_iface_cast (s, vtable_reg, klass, false_label, object_is_null); + mini_emit_isinst_iface (s, vtable_reg, klass, false_label, object_is_null); } else { int klass_reg = mono_regstate_next_int (s->rs); @@ -987,8 +1152,7 @@ reg: CEE_ISINST (reg) { int eclass_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, klass->rank); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, rank_reg, klass->rank, false_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class)); if (klass->cast_class == mono_defaults.object_class) { @@ -998,89 +1162,88 @@ reg: CEE_ISINST (reg) { if (s->compile_aot) { const_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, parent_reg, const_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg, + const_reg, object_is_null); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, parent_reg, mono_defaults.enum_class->parent); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg, + mono_defaults.enum_class->parent, object_is_null); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, object_is_null); if (s->compile_aot) { MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, + mono_defaults.enum_class, object_is_null); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false_label); } else if (klass->cast_class == mono_defaults.enum_class->parent) { int const_reg = -1; if (s->compile_aot) { const_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class->parent); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, + mono_defaults.enum_class->parent, object_is_null); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); if (s->compile_aot) { MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, + mono_defaults.enum_class, object_is_null); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false_label); } else if (klass->cast_class == mono_defaults.enum_class) { if (s->compile_aot) { int const_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, + mono_defaults.enum_class, object_is_null); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false_label); } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) { - mini_emit_isninst_iface_class_cast (s, eclass_reg, klass->cast_class, false_label, object_is_null); + mini_emit_isinst_iface_class (s, eclass_reg, klass->cast_class, false_label, object_is_null); } else { if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) { /* Check that the object is a vector too */ int bounds_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, bounds_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, bounds_reg, 0, false_label); } /* the object_is_null target simply copies the input register to the output */ - mini_emit_isninst_cast (s, eclass_reg, klass->cast_class, false_label, object_is_null); + mini_emit_isinst (s, eclass_reg, klass->cast_class, false_label, object_is_null); } } else if (mono_class_is_nullable (klass)) { MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); /* the object_is_null target simply copies the input register to the output */ - mini_emit_isninst_cast (s, klass_reg, klass->cast_class, false_label, object_is_null); + mini_emit_isinst (s, klass_reg, klass->cast_class, false_label, object_is_null); } else { if (!s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) { /* the remoting code is broken, access the class for now */ if (0) { MonoVTable *vt = mono_class_vtable (s->domain, klass); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, vt); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, vtable_reg, vt, false_label); } else { MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, klass); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, klass, false_label); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, object_is_null); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, object_is_null); } else { MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); /* the object_is_null target simply copies the input register to the output */ - mini_emit_isninst_cast (s, klass_reg, klass, false_label, object_is_null); + mini_emit_isinst (s, klass_reg, klass, false_label, object_is_null); } } } mono_bblock_add_inst (s->cbb, false_label); MONO_EMIT_NEW_ICONST (s, state->reg1, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label); mono_bblock_add_inst (s->cbb, object_is_null); MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg); mono_bblock_add_inst (s->cbb, end_label); @@ -1104,13 +1267,12 @@ reg: OP_CISINST (reg) { MONO_NEW_LABEL (s, false_label); MONO_NEW_LABEL (s, false2_label); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, false_label); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, false_label); if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) { MONO_NEW_LABEL (s, interface_fail_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); - mini_emit_isninst_iface_cast (s, tmp_reg, klass, interface_fail_label, true_label); + mini_emit_isinst_iface (s, tmp_reg, klass, interface_fail_label, true_label); mono_bblock_add_inst (s->cbb, interface_fail_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass)); @@ -1118,15 +1280,14 @@ reg: OP_CISINST (reg) { if (s->compile_aot) { int tproxy_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, tproxy_reg, false_label); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, + mono_defaults.transparent_proxy_class, false_label); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, false2_label); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, tmp_reg, 0, false2_label); } else { MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); @@ -1137,31 +1298,30 @@ reg: OP_CISINST (reg) { if (s->compile_aot) { int tproxy_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, tproxy_reg, no_proxy_label); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, + mono_defaults.transparent_proxy_class, no_proxy_label); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, no_proxy_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class)); MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class)); MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, no_proxy_label); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, tmp_reg, 0, no_proxy_label); - mini_emit_isninst_cast (s, klass_reg, klass, false2_label, true_label); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false2_label); + mini_emit_isinst (s, klass_reg, klass, false2_label, true_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, false2_label); mono_bblock_add_inst (s->cbb, no_proxy_label); - mini_emit_isninst_cast (s, klass_reg, klass, false_label, true_label); + mini_emit_isinst (s, klass_reg, klass, false_label, true_label); } mono_bblock_add_inst (s->cbb, false_label); MONO_EMIT_NEW_ICONST (s, state->reg1, 1); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label); mono_bblock_add_inst (s->cbb, false2_label); MONO_EMIT_NEW_ICONST (s, state->reg1, 2); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label); mono_bblock_add_inst (s->cbb, true_label); MONO_EMIT_NEW_ICONST (s, state->reg1, 0); mono_bblock_add_inst (s->cbb, end_label); @@ -1182,8 +1342,7 @@ reg: OP_UNBOXCAST (reg) { g_assert (klass->rank == 0); // Check rank == 0 - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, 0); - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, 0, "InvalidCastException"); MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class)); @@ -1191,12 +1350,33 @@ reg: OP_UNBOXCAST (reg) { if (s->compile_aot) { int const_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass->element_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException"); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, klass->element_class); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, klass->element_class, "InvalidCastException"); } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); + MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg); +} + +reg: OP_UNBOXCAST_REG (reg, reg) { + int obj_reg = state->left->reg1; + int element_klass_reg = state->right->reg1; + int vtable_reg = mono_regstate_next_int (s->rs); + int klass_reg = mono_regstate_next_int (s->rs); + int eclass_reg = mono_regstate_next_int (s->rs); + int rank_reg = mono_regstate_next_int (s->rs); + + MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank)); + + // Check rank == 0 + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, 0, "InvalidCastException"); + + MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); + MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class)); + + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, element_klass_reg, "InvalidCastException"); + MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg); } @@ -1208,8 +1388,26 @@ reg: CEE_CASTCLASS (reg) { MONO_NEW_LABEL (s, object_is_null); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, object_is_null); + + if (tree->backend.record_cast_details) { + int to_klass_reg = mono_regstate_next_int (s->rs); + int klass_reg = mono_regstate_next_int (s->rs); + MonoInst *tls_get = mono_get_jit_tls_intrinsic (s); + + if (!tls_get) { + fprintf (stderr, "error: --debug=casts not supported on this platform.\n."); + exit (1); + } + + MONO_ADD_INS (s->cbb, tls_get); + MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); + MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); + + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), klass_reg); + MONO_EMIT_NEW_PCONST (s, to_klass_reg, klass); + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_to), to_klass_reg); + } if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) { MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); @@ -1219,91 +1417,32 @@ reg: CEE_CASTCLASS (reg) { MONO_EMIT_NEW_LOAD_MEMBASE (s, vtable_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); - if (klass->rank) { - int rank_reg = mono_regstate_next_int (s->rs); - int eclass_reg = mono_regstate_next_int (s->rs); - - MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, klass->rank); - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); - MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class)); - if (klass->cast_class == mono_defaults.object_class) { - int parent_reg = mono_regstate_next_int (s->rs); - int const_reg = -1; - MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent)); - if (s->compile_aot) { - const_reg = mono_regstate_next_int (s->rs); - MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, parent_reg, const_reg); - } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, parent_reg, mono_defaults.enum_class->parent); - } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, object_is_null); - if (s->compile_aot) { - MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); - } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class); - } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); - } else if (klass->cast_class == mono_defaults.enum_class->parent) { - int const_reg = mono_regstate_next_int (s->rs); - if (s->compile_aot) { - MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); - } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class->parent); - } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null); - if (s->compile_aot) { - MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); - } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class); - } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); - } else if (klass->cast_class == mono_defaults.enum_class) { - if (s->compile_aot) { - int const_reg = mono_regstate_next_int (s->rs); - MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg); - } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class); - } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); - } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) { - mini_emit_castclass_iface_class (s, eclass_reg, klass->cast_class); - } else { - mini_emit_castclass (s, eclass_reg, klass->cast_class); - } - - if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) { - /* Check that the object is a vector too */ - int bounds_reg = mono_regstate_next_int (s->rs); - MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, bounds_reg, 0); - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); - } - } else { - if (!s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) { - /* the remoting code is broken, access the class for now */ - if (0) { - MonoVTable *vt = mono_class_vtable (s->domain, klass); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, vt); - } else { - MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, klass); - } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); + if (!klass->rank && !s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) { + /* the remoting code is broken, access the class for now */ + if (0) { + MonoVTable *vt = mono_class_vtable (s->domain, klass); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, vtable_reg, vt, "InvalidCastException"); } else { MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); - mini_emit_castclass (s, klass_reg, klass); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, klass, "InvalidCastException"); } + } else { + MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); + mini_emit_castclass (s, obj_reg, klass_reg, klass, object_is_null); } } mono_bblock_add_inst (s->cbb, object_is_null); + + /* Reset the variables holding the cast details */ + if (tree->backend.record_cast_details) { + MonoInst *tls_get = mono_get_jit_tls_intrinsic (s); + + MONO_ADD_INS (s->cbb, tls_get); + /* It is enough to reset the from field */ + MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, tls_get->dreg, G_STRUCT_OFFSET (MonoJitTlsData, class_cast_from), 0); + } + MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg); } @@ -1317,20 +1456,21 @@ reg: OP_CCASTCLASS (reg) { MonoInst *end_label, *fail_label, *no_proxy_label, *ok_result_label; int obj_reg = state->left->reg1; int tmp_reg = mono_regstate_next_int (s->rs); + int tmp2_reg = mono_regstate_next_int (s->rs); int klass_reg = mono_regstate_next_int (s->rs); MONO_NEW_LABEL (s, end_label); MONO_NEW_LABEL (s, ok_result_label); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, obj_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, ok_result_label); + /* Return 0 if the object is null */ + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, obj_reg, 0, ok_result_label); if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) { MONO_NEW_LABEL (s, fail_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoObject, vtable)); - mini_emit_isninst_iface_cast (s, tmp_reg, klass, fail_label, ok_result_label); + mini_emit_isinst_iface (s, tmp_reg, klass, fail_label, ok_result_label); mono_bblock_add_inst (s->cbb, fail_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoVTable, klass)); @@ -1338,22 +1478,16 @@ reg: OP_CCASTCLASS (reg) { if (s->compile_aot) { int tproxy_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, tproxy_reg, "InvalidCastException"); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, mono_defaults.transparent_proxy_class, "InvalidCastException"); } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); - - MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class)); - MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class)); - - MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0); - MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException"); + MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp2_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info)); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, tmp2_reg, 0, "InvalidCastException"); MONO_EMIT_NEW_ICONST (s, state->reg1, 1); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label); } else { @@ -1366,26 +1500,26 @@ reg: OP_CCASTCLASS (reg) { if (s->compile_aot) { int tproxy_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, tproxy_reg, no_proxy_label); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, klass_reg, + mono_defaults.transparent_proxy_class, no_proxy_label); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, no_proxy_label); MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class)); MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class)); - MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, no_proxy_label); + MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp2_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info)); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, tmp2_reg, 0, no_proxy_label); - mini_emit_isninst_cast (s, klass_reg, klass, fail_label, ok_result_label); + mini_emit_isinst (s, klass_reg, klass, fail_label, ok_result_label); mono_bblock_add_inst (s->cbb, fail_label); MONO_EMIT_NEW_ICONST (s, state->reg1, 1); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label); + MONO_EMIT_NEW_BRANCH_LABEL (s, OP_BR, end_label); mono_bblock_add_inst (s->cbb, no_proxy_label); - mini_emit_castclass (s, klass_reg, klass); + /* Again, use ok_result_label as "object_is_null" */ + mini_emit_castclass (s, obj_reg, klass_reg, klass, ok_result_label); } mono_bblock_add_inst (s->cbb, ok_result_label); @@ -1413,11 +1547,20 @@ lreg: OP_LSHR_UN (lreg, reg) { # string support # reg: OP_GETCHR (reg, reg) "4" { + int index_reg; int mult_reg = mono_regstate_next_int (s->rs); int add_reg = mono_regstate_next_int (s->rs); - MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoString, length, state->right->reg1); - MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, mult_reg, state->right->reg1, 1); + if (sizeof (gpointer) == 8) { + /* The array reg is 64 bits but the index reg is only 32 */ + index_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_UNALU (s, OP_SEXT_I4, index_reg, state->right->reg1); + } else { + index_reg = state->right->reg1; + } + + MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoString, length, index_reg); + MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, mult_reg, index_reg, 1); MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1); MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU2_MEMBASE, state->reg1, add_reg, G_STRUCT_OFFSET (MonoString, chars)); @@ -1483,7 +1626,7 @@ reg: OP_ARRAY_RANK (reg) { reg: OP_CHECK_ARRAY_TYPE (reg) { - MonoClass* array_class = mono_array_class_get (tree->klass, 1); + MonoClass* array_class = tree->klass; int vtable_reg = mono_regstate_next_int (s->rs); @@ -1497,21 +1640,20 @@ reg: OP_CHECK_ARRAY_TYPE (reg) { if (s->compile_aot) { int klass_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, klass_reg, array_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, class_reg, klass_reg); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, class_reg, klass_reg, "ArrayTypeMismatchException"); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, class_reg, array_class); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, class_reg, array_class, "ArrayTypeMismatchException"); } } else { if (s->compile_aot) { int vt_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_VTABLECONST (s, vt_reg, mono_class_vtable (s->domain, array_class)); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, vtable_reg, vt_reg); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, vtable_reg, vt_reg, "ArrayTypeMismatchException"); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, mono_class_vtable (s->domain, array_class)); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, vtable_reg, mono_class_vtable (s->domain, array_class), "ArrayTypeMismatchException"); } } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "ArrayTypeMismatchException"); MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1); } @@ -1525,12 +1667,21 @@ reg: CEE_LDELEMA (reg, OP_ICONST) "15" { } reg: CEE_LDELEMA (reg, reg) "20" { + int index_reg; int mult_reg = mono_regstate_next_int (s->rs); int add_reg = mono_regstate_next_int (s->rs); guint32 size = mono_class_array_element_size (tree->klass); - MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoArray, max_length, state->right->reg1); - MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, mult_reg, state->right->reg1, size); + if (sizeof (gpointer) == 8) { + /* The array reg is 64 bits but the index reg is only 32 */ + index_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_UNALU (s, OP_SEXT_I4, index_reg, state->right->reg1); + } else { + index_reg = state->right->reg1; + } + + MONO_EMIT_BOUNDS_CHECK (s, state->left->reg1, MonoArray, max_length, index_reg); + MONO_EMIT_NEW_BIALU_IMM (s, OP_MUL_IMM, mult_reg, index_reg, size); MONO_EMIT_NEW_BIALU (s, CEE_ADD, add_reg, mult_reg, state->left->reg1); MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, add_reg, G_STRUCT_OFFSET (MonoArray, vector)); } @@ -1541,11 +1692,18 @@ reg: CEE_REFANYVAL (reg) { if (s->compile_aot) { int const_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, const_reg, tree->inst_newa_class); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, const_reg); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, const_reg, "InvalidCastException"); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, tree->inst_newa_class); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, tree->inst_newa_class, "InvalidCastException"); } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); + MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, value)); +} + +reg: OP_REFANYVAL_REG (reg, reg) { + int klass_reg = mono_regstate_next_int (s->rs); + g_assert (!s->compile_aot); + MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass)); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, state->right->reg1, "InvalidCastException"); MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, value)); } @@ -1571,10 +1729,24 @@ stmt: CEE_MKREFANY (OP_GROUP (reg, OP_I8CONST), reg) { MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, state->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, value), state->left->left->reg1); } +stmt: OP_MKREFANY_REGS (OP_GROUP (reg, reg), OP_GROUP (reg, reg)) { + g_assert (!s->compile_aot); + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, + state->right->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, type), state->left->left->reg1); + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, + state->right->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, klass), state->left->right->reg1); + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREP_MEMBASE_REG, + state->right->right->reg1, G_STRUCT_OFFSET (MonoTypedRef, value), state->right->left->reg1); +} + %% +#ifdef MONO_ARCH_NEED_GOT_VAR + static void mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpointer cons); +#endif + /* * Emit code which checks whenever the interface id of @klass is smaller than * than the value given by max_iid_reg. @@ -1586,14 +1758,16 @@ mini_emit_max_iid_check (MonoCompile *s, int max_iid_reg, MonoClass *klass, if (s->compile_aot) { int iid_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, max_iid_reg, iid_reg); + if (false_target) + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BLT_UN, max_iid_reg, iid_reg, false_target); + else + MONO_EMIT_NEW_COMPARE_EXC (s, LT_UN, max_iid_reg, iid_reg, "InvalidCastException"); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, max_iid_reg, klass->interface_id); + if (false_target) + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BLT_UN, max_iid_reg, klass->interface_id, false_target); + else + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT_UN, max_iid_reg, klass->interface_id, "InvalidCastException"); } - if (false_target) - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BLT_UN, false_target); - else - MONO_EMIT_NEW_COND_EXC (s, LT_UN, "InvalidCastException"); } /* Same as above, but obtains max_iid from a vtable */ @@ -1635,32 +1809,107 @@ mini_emit_load_intf_reg_vtable (MonoCompile *s, int intf_reg, int vtable_reg, Mo } } -/* Emit code which loads ->interface_offsets [klass->interface_id] */ +/* + * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoClass + * stored in "klass_reg" implements the interface "klass". + */ +static void +mini_emit_load_intf_bit_reg_class (MonoCompile *s, int intf_bit_reg, int klass_reg, MonoClass *klass) +{ + int ibitmap_reg = mono_regstate_next_int (s->rs); + int ibitmap_byte_reg = mono_regstate_next_int (s->rs); + + MONO_EMIT_NEW_LOAD_MEMBASE (s, ibitmap_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_bitmap)); + + if (s->compile_aot) { + int iid_reg = mono_regstate_next_int (s->rs); + int shifted_iid_reg = mono_regstate_next_int (s->rs); + int ibitmap_byte_address_reg = mono_regstate_next_int (s->rs); + int masked_iid_reg = mono_regstate_next_int (s->rs); + int iid_one_bit_reg = mono_regstate_next_int (s->rs); + int iid_bit_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID); + MONO_EMIT_NEW_BIALU_IMM (s, OP_SHR_IMM, shifted_iid_reg, iid_reg, 3); + MONO_EMIT_NEW_BIALU (s, CEE_ADD, ibitmap_byte_address_reg, ibitmap_reg, shifted_iid_reg); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0); + MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, masked_iid_reg, iid_reg, 7); + MONO_EMIT_NEW_ICONST (s, iid_one_bit_reg, 1); + MONO_EMIT_NEW_BIALU (s, CEE_SHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg); + MONO_EMIT_NEW_BIALU (s, CEE_AND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg); + } else { + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3); + MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7)); + } +} +/* + * Emit code which loads into "intf_bit_reg" a nonzero value if the MonoVTable + * stored in "vtable_reg" implements the interface "klass". + */ static void -mini_emit_load_intf_reg_class (MonoCompile *s, int intf_reg, int klass_reg, MonoClass *klass) +mini_emit_load_intf_bit_reg_vtable (MonoCompile *s, int intf_bit_reg, int vtable_reg, MonoClass *klass) { - int ioffset_reg = mono_regstate_next_int (s->rs); + int ibitmap_reg = mono_regstate_next_int (s->rs); + int ibitmap_byte_reg = mono_regstate_next_int (s->rs); - MONO_EMIT_NEW_LOAD_MEMBASE (s, ioffset_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_offsets)); + MONO_EMIT_NEW_LOAD_MEMBASE (s, ibitmap_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, interface_bitmap)); if (s->compile_aot) { int iid_reg = mono_regstate_next_int (s->rs); int shifted_iid_reg = mono_regstate_next_int (s->rs); + int ibitmap_byte_address_reg = mono_regstate_next_int (s->rs); + int masked_iid_reg = mono_regstate_next_int (s->rs); + int iid_one_bit_reg = mono_regstate_next_int (s->rs); + int iid_bit_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID); - MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, shifted_iid_reg, iid_reg, 2); - MONO_EMIT_NEW_BIALU (s, CEE_ADD, ioffset_reg, ioffset_reg, shifted_iid_reg); - MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, intf_reg, ioffset_reg, 0); + MONO_EMIT_NEW_BIALU_IMM (s, OP_SHR_IMM, shifted_iid_reg, iid_reg, 3); + MONO_EMIT_NEW_BIALU (s, CEE_ADD, ibitmap_byte_address_reg, ibitmap_reg, shifted_iid_reg); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, ibitmap_byte_reg, ibitmap_byte_address_reg, 0); + MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, masked_iid_reg, iid_reg, 7); + MONO_EMIT_NEW_ICONST (s, iid_one_bit_reg, 1); + MONO_EMIT_NEW_BIALU (s, CEE_SHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg); + MONO_EMIT_NEW_BIALU (s, CEE_AND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg); } else { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, intf_reg, ioffset_reg, klass->interface_id * sizeof (int)); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3); + MONO_EMIT_NEW_BIALU_IMM (s, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7)); } } +#ifdef MONO_ARCH_HAVE_IMT +static void +emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, gboolean have_imt_arg, int imt_reg) { +#ifdef MONO_ARCH_IMT_REG + int method_reg = mono_regstate_next_int (cfg->rs); + + if (cfg->compile_aot) { + g_assert (!have_imt_arg); + MONO_EMIT_NEW_AOTCONST (cfg, method_reg, call->method, MONO_PATCH_INFO_METHODCONST); + } else { + if (have_imt_arg) { + MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, method_reg, imt_reg); + } else { + MonoInst *inst; + MONO_INST_NEW (cfg, inst, OP_PCONST); + inst->inst_p0 = call->method; + inst->dreg = method_reg; + mono_bblock_add_inst (cfg->cbb, inst); + } + } + + mono_call_inst_add_outarg_reg (cfg, call, method_reg, MONO_ARCH_IMT_REG, FALSE); +#else + mono_arch_emit_imt_argument (cfg, call, NULL); +#endif +} +#endif + static void -mini_emit_virtual_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop, int virtop) +mini_emit_virtual_call_internal (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop, int virtop, + gboolean have_imt_arg, int imt_reg) { MonoMethod *method = ((MonoCallInst*)tree)->method; int vtable_reg, slot_reg, this_reg; MBState *state = st; + int slot; this_reg = state->left->reg1; mono_arch_emit_this_vret_args (cfg, (MonoCallInst*)tree, this_reg, state->left->tree->type, novirtop == OP_VCALL? state->right->reg1: -1); @@ -1685,18 +1934,67 @@ mini_emit_virtual_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop return; } - /* Initialize method->slot */ - mono_class_setup_vtable (method->klass); +#ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE + if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) { + /* Make a call to delegate->invoke_impl */ + tree->dreg = state->reg1; + tree->opcode = virtop; + tree->inst_basereg = this_reg; + tree->inst_offset = G_STRUCT_OFFSET (MonoDelegate, invoke_impl); + mono_bblock_add_inst (cfg->cbb, tree); + return; + } +#endif + + if ((method->flags & METHOD_ATTRIBUTE_VIRTUAL) && + ((method->flags & METHOD_ATTRIBUTE_FINAL) || + (method->klass && method->klass->flags & TYPE_ATTRIBUTE_SEALED))) { + /* + * the method is virtual, but we can statically dispatch since either + * it's class or the method itself are sealed. + * But first we need to ensure it's not a null reference. + */ + MONO_EMIT_NEW_UNALU (cfg, OP_CHECK_THIS, -1, this_reg); + + tree->dreg = state->reg1; + tree->opcode = novirtop; + mono_bblock_add_inst (cfg->cbb, tree); + return; + } + + if (method->klass->generic_class && !method->klass->vtable) { + MonoMethod *gmethod = mono_method_get_declaring_generic_method (method); + mono_class_setup_vtable (gmethod->klass); + + slot = gmethod->slot; + g_assert (slot != -1); + } else { + /* Initialize method->slot */ + mono_class_setup_vtable (method->klass); + slot = method->slot; + } vtable_reg = mono_regstate_next_int (cfg->rs); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable)); if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) { - slot_reg = mono_regstate_next_int (cfg->rs); - mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, method->klass); - tree->inst_offset = method->slot * SIZEOF_VOID_P; + slot_reg = -1; +#ifdef MONO_ARCH_HAVE_IMT + if (mono_use_imt) { + guint32 imt_slot = mono_method_get_imt_slot (method); + emit_imt_argument (cfg, (MonoCallInst*)tree, have_imt_arg, imt_reg); + slot_reg = vtable_reg; + tree->inst_offset = ((gint32)imt_slot - MONO_IMT_SIZE) * SIZEOF_VOID_P; + } +#endif + if (slot_reg == -1) { + g_assert (!have_imt_arg); + slot_reg = mono_regstate_next_int (cfg->rs); + mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, method->klass); + tree->inst_offset = slot * SIZEOF_VOID_P; + } } else { slot_reg = vtable_reg; - tree->inst_offset = G_STRUCT_OFFSET (MonoVTable, vtable) + (method->slot * SIZEOF_VOID_P); + tree->inst_offset = G_STRUCT_OFFSET (MonoVTable, vtable) + (slot * SIZEOF_VOID_P); } tree->dreg = state->reg1; @@ -1706,8 +2004,40 @@ mini_emit_virtual_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop mono_bblock_add_inst (cfg->cbb, tree); } +static void +mini_emit_virtual_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop, int virtop) +{ + mini_emit_virtual_call_internal (cfg, st, tree, novirtop, virtop, FALSE, -1); +} + +static void +mini_emit_virtual_imt_call (MonoCompile *cfg, void *st, MonoInst *tree, int novirtop, int virtop, int imt_reg) +{ + mini_emit_virtual_call_internal (cfg, st, tree, novirtop, virtop, TRUE, imt_reg); +} + +static void +emit_rgctx_argument (MonoCompile *s, MonoInst *tree, int reg, int new_opcode) +{ +#ifdef MONO_ARCH_RGCTX_REG + MonoCallInst *call = (MonoCallInst*)tree; + int rgctx_reg = mono_regstate_next_int (s->rs); + + MONO_EMIT_NEW_UNALU (s, OP_MOVE, rgctx_reg, reg); + + call->inst.opcode = new_opcode; + + mono_call_inst_add_outarg_reg (s, call, rgctx_reg, MONO_ARCH_RGCTX_REG, FALSE); +#else + g_assert_not_reached (); +#endif +} + +/* + * Emit code for ISINST/CASTCLASS + */ static void -mini_emit_isninst_cast (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target) +mini_emit_isinst (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target) { int idepth_reg = mono_regstate_next_int (s->rs); int stypes_reg = mono_regstate_next_int (s->rs); @@ -1715,97 +2045,149 @@ mini_emit_isninst_cast (MonoCompile *s, int klass_reg, MonoClass *klass, MonoIns if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) { MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth); - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BLT_UN, false_target); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BLT_UN, idepth_reg, klass->idepth, false_target); } MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes)); MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P)); if (s->compile_aot) { int const_reg = mono_regstate_next_int (s->rs); MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, stype, const_reg); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, stype, const_reg, true_target); } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, stype, klass); + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, stype, klass, true_target); } - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, true_target); } +/* + * Emit code for ISINST/CASTCLASS for interfaces + */ static void -mini_emit_isninst_iface_cast (MonoCompile *s, int vtable_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target) +mini_emit_isinst_iface (MonoCompile *s, int vtable_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target) { int intf_reg = mono_regstate_next_int (s->rs); mini_emit_max_iid_check_vtable (s, vtable_reg, klass, false_target); - mini_emit_load_intf_reg_vtable (s, intf_reg, vtable_reg, klass); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, 0); - /* the object_is_null target simply copies the input register to the output */ - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, true_target); + mini_emit_load_intf_bit_reg_vtable (s, intf_reg, vtable_reg, klass); + if (true_target) + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, intf_reg, 0, true_target); + else + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, intf_reg, 0, "InvalidCastException"); } /* * Variant of the above that takes a register to the class, not the vtable. - * Note that inside interfaces_offsets the empty value is -1, not NULL, in this case. */ static void -mini_emit_isninst_iface_class_cast (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target) +mini_emit_isinst_iface_class (MonoCompile *s, int klass_reg, MonoClass *klass, MonoInst *false_target, MonoInst *true_target) { - int intf_reg = mono_regstate_next_int (s->rs); + int intf_bit_reg = mono_regstate_next_int (s->rs); mini_emit_max_iid_check_class (s, klass_reg, klass, false_target); - mini_emit_load_intf_reg_class (s, intf_reg, klass_reg, klass); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, -1); - /* the object_is_null target simply copies the input register to the output */ - MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BGE, true_target); -} - -static void -mini_emit_castclass (MonoCompile *s, int klass_reg, MonoClass *klass) -{ - int idepth_reg = mono_regstate_next_int (s->rs); - int stypes_reg = mono_regstate_next_int (s->rs); - int stype = mono_regstate_next_int (s->rs); - - if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth)); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth); - MONO_EMIT_NEW_COND_EXC (s, LT_UN, "InvalidCastException"); - } - MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes)); - MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P)); - if (s->compile_aot) { - int const_reg = mono_regstate_next_int (s->rs); - MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass); - MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, stype, const_reg); - } else { - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, stype, klass); - } - MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException"); + mini_emit_load_intf_bit_reg_class (s, intf_bit_reg, klass_reg, klass); + if (true_target) + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, intf_bit_reg, 0, true_target); + else + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, intf_bit_reg, 0, "InvalidCastException"); } static void mini_emit_castclass_iface (MonoCompile *s, int vtable_reg, MonoClass *klass) { - int intf_reg = mono_regstate_next_int (s->rs); - - mini_emit_max_iid_check_vtable (s, vtable_reg, klass, NULL); - mini_emit_load_intf_reg_vtable (s, intf_reg, vtable_reg, klass); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, 0); - MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException"); + mini_emit_isinst_iface (s, vtable_reg, klass, NULL, NULL); } /* * Variant of the aboce that takes a register to the class, not the vtable. - * Note that inside interfaces_offsets the empty value is -1, not NULL, in this case. */ static void mini_emit_castclass_iface_class (MonoCompile *s, int klass_reg, MonoClass *klass) { - int intf_reg = mono_regstate_next_int (s->rs); + mini_emit_isinst_iface_class (s, klass_reg, klass, NULL, NULL); +} + +static void +mini_emit_castclass (MonoCompile *s, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *object_is_null) +{ + if (klass->rank) { + int rank_reg = mono_regstate_next_int (s->rs); + int eclass_reg = mono_regstate_next_int (s->rs); + + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, rank)); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, klass->rank, "InvalidCastException"); +// MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass)); + MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class)); + if (klass->cast_class == mono_defaults.object_class) { + int parent_reg = mono_regstate_next_int (s->rs); + int const_reg = -1; + MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent)); + if (s->compile_aot) { + const_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg, const_reg, object_is_null); + } else { + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BNE_UN, parent_reg, + mono_defaults.enum_class->parent, object_is_null); + } + if (s->compile_aot) { + MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException"); + } else { + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException"); + } + } else if (klass->cast_class == mono_defaults.enum_class->parent) { + int const_reg = mono_regstate_next_int (s->rs); + if (s->compile_aot) { + MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class->parent); + MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, const_reg, object_is_null); + } else { + MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BEQ, eclass_reg, + mono_defaults.enum_class->parent, object_is_null); + } + if (s->compile_aot) { + MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException"); + } else { + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException"); + } + } else if (klass->cast_class == mono_defaults.enum_class) { + if (s->compile_aot) { + int const_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException"); + } else { + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException"); + } + } else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) { + mini_emit_castclass_iface_class (s, eclass_reg, klass->cast_class); + } else { + mini_emit_castclass (s, obj_reg, eclass_reg, klass->cast_class, object_is_null); + } - mini_emit_max_iid_check_class (s, klass_reg, klass, NULL); - mini_emit_load_intf_reg_class (s, intf_reg, klass_reg, klass); - MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, -1); - MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException"); + if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) { + /* Check that the object is a vector too */ + int bounds_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds)); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, bounds_reg, 0, "InvalidCastException"); + } + } else { + int idepth_reg = mono_regstate_next_int (s->rs); + int stypes_reg = mono_regstate_next_int (s->rs); + int stype = mono_regstate_next_int (s->rs); + + if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) { + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth)); + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT_UN, idepth_reg, klass->idepth, "InvalidCastException"); + } + MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes)); + MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P)); + if (s->compile_aot) { + int const_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass); + MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, stype, const_reg, "InvalidCastException"); + } else { + MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, stype, klass, "InvalidCastException"); + } + } } static void @@ -1813,6 +2195,18 @@ mini_emit_memcpy (MonoCompile *s, int destreg, int doffset, int srcreg, int soff { int cur_reg; + if (align < 4) { + /* This could be optimized further if neccesary */ + while (size >= 1) { + cur_reg = mono_regstate_next_int (s->rs); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, cur_reg, srcreg, soffset); + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, doffset, cur_reg); + doffset += 1; + soffset += 1; + size -= 1; + } + } + /* FIXME: consider alignment for archs that need it. */ #if !NO_UNALIGNED_ACCESS if (sizeof (gpointer) == 8) { @@ -1863,6 +2257,16 @@ mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, in else MONO_EMIT_NEW_ICONST (s, val_reg, val); + if (align < 4) { + /* This could be optimized further if neccesary */ + while (size >= 1) { + MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI1_MEMBASE_REG, destreg, offset, val_reg); + offset += 1; + size -= 1; + } + return; + } + /* FIXME: consider alignment for archs that need it. */ #if !NO_UNALIGNED_ACCESS if (sizeof (gpointer) == 8) { @@ -1896,6 +2300,8 @@ mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, in } } +#ifdef MONO_ARCH_NEED_GOT_VAR + /* This is similar to NEW_AOTCONST in mini.c, but generates linear IL */ static void mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpointer cons) @@ -1903,9 +2309,6 @@ mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpo MonoInst *dest, *pinfo; int got_var_reg; - dest = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst)); - dest->opcode = OP_GOT_ENTRY; - g_assert (cfg->got_var); pinfo = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); @@ -1921,8 +2324,7 @@ mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpo got_var_reg = cfg->got_var->dreg; } - dest = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); - dest->opcode = OP_GOT_ENTRY; + MONO_INST_NEW ((cfg), dest, OP_GOT_ENTRY); dest->inst_left = cfg->got_var; /* not used */ dest->inst_right = pinfo; @@ -1931,6 +2333,8 @@ mini_emit_aotconst (MonoCompile *cfg, int dreg, MonoJumpInfoType patch_type, gpo mono_bblock_add_inst (cfg->cbb, dest); } +#endif + static int ldind_to_load_membase (int opcode) {