#include "jit-icalls.h"
#include <mono/metadata/gc-internal.h>
+#include <mono/metadata/abi-details.h>
#ifndef DISABLE_JIT
/* FIXME: This conflicts with the definition in mini.c, so it cannot be moved to mini.h */
-MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
+MONO_API MonoInst* mono_emit_native_call (MonoCompile *cfg, gconstpointer func, MonoMethodSignature *sig, MonoInst **args);
void mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native);
void mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass);
-/* Decompose complex long opcodes on 64 bit machines or when using LLVM */
+/*
+ * Decompose complex long opcodes on 64 bit machines.
+ * This is also used on 32 bit machines when using LLVM, so it needs to handle I/U correctly.
+ */
static gboolean
decompose_long_opcode (MonoCompile *cfg, MonoInst *ins, MonoInst **repl_ins)
{
ins->opcode = OP_SEXT_I4;
break;
case OP_LCONV_TO_I8:
- case OP_LCONV_TO_I:
case OP_LCONV_TO_U8:
+ if (SIZEOF_VOID_P == 4)
+ ins->opcode = OP_LMOVE;
+ else
+ ins->opcode = OP_MOVE;
+ break;
+ case OP_LCONV_TO_I:
+ if (SIZEOF_VOID_P == 4)
+ /* OP_LCONV_TO_I4 */
+ ins->opcode = OP_SEXT_I4;
+ else
+ ins->opcode = OP_MOVE;
+ break;
case OP_LCONV_TO_U:
- ins->opcode = OP_MOVE;
+ if (SIZEOF_VOID_P == 4) {
+ /* OP_LCONV_TO_U4 */
+ MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHR_UN_IMM, ins->dreg, ins->sreg1, 0);
+ NULLIFY_INS (ins);
+ } else {
+ ins->opcode = OP_MOVE;
+ }
break;
case OP_ICONV_TO_I8:
ins->opcode = OP_SEXT_I4;
MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ISHR_UN_IMM, ins->dreg, ins->sreg1, 0);
NULLIFY_INS (ins);
break;
- case OP_LADD_OVF:
+ case OP_LADD_OVF: {
+ int opcode;
+
if (COMPILE_LLVM (cfg))
break;
- {
- int opcode;
-#if defined(__mono_ilp32__) && SIZEOF_REGISTER == 8
+ if (MONO_IS_ILP32 && SIZEOF_REGISTER == 8)
opcode = OP_LADDCC;
-#else
+ else
opcode = OP_ADDCC;
-#endif
- EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
- }
+ EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
MONO_EMIT_NEW_COND_EXC (cfg, OV, "OverflowException");
NULLIFY_INS (ins);
break;
- case OP_LADD_OVF_UN:
+ }
+ case OP_LADD_OVF_UN: {
+ int opcode;
+
if (COMPILE_LLVM (cfg))
break;
- {
- int opcode;
-#if defined(__mono_ilp32__) && SIZEOF_REGISTER == 8
+ if (MONO_IS_ILP32 && SIZEOF_REGISTER == 8)
opcode = OP_LADDCC;
-#else
+ else
opcode = OP_ADDCC;
-#endif
- EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
- }
+ EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
MONO_EMIT_NEW_COND_EXC (cfg, C, "OverflowException");
NULLIFY_INS (ins);
break;
+ }
#ifndef __mono_ppc64__
- case OP_LSUB_OVF:
+ case OP_LSUB_OVF: {
+ int opcode;
+
if (COMPILE_LLVM (cfg))
break;
- {
- int opcode;
-#if defined(__mono_ilp32__) && SIZEOF_REGISTER == 8
+ if (MONO_IS_ILP32 && SIZEOF_REGISTER == 8)
opcode = OP_LSUBCC;
-#else
+ else
opcode = OP_SUBCC;
-#endif
- EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
- }
+ EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
MONO_EMIT_NEW_COND_EXC (cfg, OV, "OverflowException");
NULLIFY_INS (ins);
break;
- case OP_LSUB_OVF_UN:
+ }
+ case OP_LSUB_OVF_UN: {
+ int opcode;
+
if (COMPILE_LLVM (cfg))
break;
- {
- int opcode;
-#if defined(__mono_ilp32__) && SIZEOF_REGISTER == 8
+ if (MONO_IS_ILP32 && SIZEOF_REGISTER == 8)
opcode = OP_LSUBCC;
-#else
+ else
opcode = OP_SUBCC;
-#endif
- EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
- }
+ EMIT_NEW_BIALU (cfg, repl, opcode, ins->dreg, ins->sreg1, ins->sreg2);
MONO_EMIT_NEW_COND_EXC (cfg, C, "OverflowException");
NULLIFY_INS (ins);
break;
+ }
#endif
case OP_ICONV_TO_OVF_I8:
NULLIFY_INS (ins);
break;
case OP_LCONV_TO_OVF_I4:
+#if SIZEOF_VOID_P == 4
+ case OP_LCONV_TO_OVF_I:
+#endif
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0x7fffffff);
MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
/* The int cast is needed for the VS compiler. See Compiler Warning (level 2) C4146. */
NULLIFY_INS (ins);
break;
case OP_LCONV_TO_OVF_I4_UN:
+#if SIZEOF_VOID_P == 4
+ case OP_LCONV_TO_OVF_I_UN:
+#endif
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0x7fffffff);
MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
NULLIFY_INS (ins);
break;
case OP_LCONV_TO_OVF_U4:
+#if SIZEOF_VOID_P == 4
+ case OP_LCONV_TO_OVF_U:
+#endif
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0xffffffffUL);
MONO_EMIT_NEW_COND_EXC (cfg, GT, "OverflowException");
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0);
NULLIFY_INS (ins);
break;
case OP_LCONV_TO_OVF_U4_UN:
+#if SIZEOF_VOID_P == 4
+ case OP_LCONV_TO_OVF_U_UN:
+#endif
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0xffffffff);
MONO_EMIT_NEW_COND_EXC (cfg, GT_UN, "OverflowException");
MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
NULLIFY_INS (ins);
break;
+#if SIZEOF_VOID_P == 8
case OP_LCONV_TO_OVF_I:
case OP_LCONV_TO_OVF_U_UN:
+#endif
case OP_LCONV_TO_OVF_U8_UN:
case OP_LCONV_TO_OVF_I8:
ins->opcode = OP_MOVE;
break;
+#if SIZEOF_VOID_P == 8
case OP_LCONV_TO_OVF_I_UN:
+#endif
case OP_LCONV_TO_OVF_I8_UN:
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0);
MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
NULLIFY_INS (ins);
break;
case OP_LCONV_TO_OVF_U8:
+#if SIZEOF_VOID_P == 8
case OP_LCONV_TO_OVF_U:
+#endif
MONO_EMIT_NEW_LCOMPARE_IMM (cfg, ins->sreg1, 0);
MONO_EMIT_NEW_COND_EXC (cfg, LT, "OverflowException");
MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, ins->dreg, ins->sreg1);
break;
#endif
+#if SIZEOF_REGISTER == 8
+ case OP_LREM_IMM:
+#endif
+ case OP_IREM_IMM: {
+ int power = mono_is_power_of_two (ins->inst_imm);
+ if (ins->inst_imm == 1) {
+ ins->opcode = OP_ICONST;
+ MONO_INST_NULLIFY_SREGS (ins);
+ ins->inst_c0 = 0;
+ } else if ((ins->inst_imm > 0) && (ins->inst_imm < (1LL << 32)) && (power != -1)) {
+ gboolean is_long = ins->opcode == OP_LREM_IMM;
+ int compensator_reg = alloc_ireg (cfg);
+ int intermediate_reg;
+
+ /* Based on gcc code */
+
+ /* Add compensation for negative numerators */
+
+ if (power > 1) {
+ intermediate_reg = compensator_reg;
+ MONO_EMIT_NEW_BIALU_IMM (cfg, is_long ? OP_LSHR_IMM : OP_SHR_IMM, intermediate_reg, ins->sreg1, is_long ? 63 : 31);
+ } else {
+ intermediate_reg = ins->sreg1;
+ }
+
+ MONO_EMIT_NEW_BIALU_IMM (cfg, is_long ? OP_LSHR_UN_IMM : OP_SHR_UN_IMM, compensator_reg, intermediate_reg, (is_long ? 64 : 32) - power);
+ MONO_EMIT_NEW_BIALU (cfg, is_long ? OP_LADD : OP_IADD, ins->dreg, ins->sreg1, compensator_reg);
+ /* Compute remainder */
+ MONO_EMIT_NEW_BIALU_IMM (cfg, is_long ? OP_LAND_IMM : OP_AND_IMM, ins->dreg, ins->dreg, (1 << power) - 1);
+ /* Remove compensation */
+ MONO_EMIT_NEW_BIALU (cfg, is_long ? OP_LSUB : OP_ISUB, ins->dreg, ins->dreg, compensator_reg);
+
+ NULLIFY_INS (ins);
+ }
+ break;
+ }
+
default:
emulate = TRUE;
break;
MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 1, tree->inst_ls_word);
MONO_EMIT_NEW_ICONST (cfg, tree->dreg + 2, tree->inst_ms_word);
break;
+ case OP_DUMMY_I8CONST:
+ MONO_EMIT_NEW_DUMMY_INIT (cfg, tree->dreg + 1, OP_DUMMY_ICONST);
+ MONO_EMIT_NEW_DUMMY_INIT (cfg, tree->dreg + 2, OP_DUMMY_ICONST);
+ break;
case OP_LMOVE:
case OP_LCONV_TO_U8:
case OP_LCONV_TO_I8:
MONO_ADD_INS (cfg->cbb, tmp);
}
break;
+ case OP_DUMMY_VZERO:
+ NULLIFY_INS (ins);
+ break;
case OP_STOREV_MEMBASE: {
src_var = get_vreg_to_inst (cfg, ins->sreg1);
}
}
+void
+mono_decompose_vtype_opts_llvm (MonoCompile *cfg)
+{
+ MonoBasicBlock *bb, *first_bb;
+
+ /* Decompose only the OP_STOREV_MEMBASE opcodes, which need write barriers */
+
+ cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
+ first_bb = cfg->cbb;
+
+ for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
+ MonoInst *ins;
+ MonoInst *prev = NULL;
+ MonoInst *src_var, *src, *dest;
+ gboolean restart;
+ int dreg;
+
+ if (cfg->verbose_level > 2) mono_print_bb (bb, "BEFORE LOWER-VTYPE-OPTS(LLVM) ");
+
+ cfg->cbb->code = cfg->cbb->last_ins = NULL;
+ restart = TRUE;
+
+ while (restart) {
+ restart = FALSE;
+
+ for (ins = bb->code; ins; ins = ins->next) {
+ switch (ins->opcode) {
+ case OP_STOREV_MEMBASE: {
+ src_var = get_vreg_to_inst (cfg, ins->sreg1);
+
+ if (!src_var) {
+ g_assert (ins->klass);
+ src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->sreg1);
+ }
+
+ EMIT_NEW_VARLOADA_VREG ((cfg), (src), ins->sreg1, &ins->klass->byval_arg);
+
+ dreg = alloc_preg (cfg);
+ EMIT_NEW_BIALU_IMM (cfg, dest, OP_ADD_IMM, dreg, ins->inst_destbasereg, ins->inst_offset);
+ mini_emit_stobj (cfg, dest, src, src_var->klass, src_var->backend.is_pinvoke);
+ break;
+ }
+ default:
+ break;
+ }
+
+ g_assert (cfg->cbb == first_bb);
+
+ if (cfg->cbb->code || (cfg->cbb != first_bb)) {
+ /* Replace the original instruction with the new code sequence */
+
+ mono_replace_ins (cfg, bb, ins, &prev, first_bb, cfg->cbb);
+ first_bb->code = first_bb->last_ins = NULL;
+ first_bb->in_count = first_bb->out_count = 0;
+ cfg->cbb = first_bb;
+ }
+ else
+ prev = ins;
+ }
+ }
+
+ if (cfg->verbose_level > 2) mono_print_bb (bb, "AFTER LOWER-VTYPE-OPTS(LLVM) ");
+ }
+}
+
inline static MonoInst *
mono_get_domainvar (MonoCompile *cfg)
{
switch (ins->opcode) {
case OP_LDLEN:
NEW_LOAD_MEMBASE_FLAGS (cfg, dest, OP_LOADI4_MEMBASE, ins->dreg, ins->sreg1,
- G_STRUCT_OFFSET (MonoArray, max_length), ins->flags | MONO_INST_CONSTANT_LOAD);
+ MONO_STRUCT_OFFSET (MonoArray, max_length), ins->flags | MONO_INST_INVARIANT_LOAD);
MONO_ADD_INS (cfg->cbb, dest);
break;
case OP_BOUNDS_CHECK:
break;
case OP_STRLEN:
MONO_EMIT_NEW_LOAD_MEMBASE_OP_FLAGS (cfg, OP_LOADI4_MEMBASE, ins->dreg,
- ins->sreg1, G_STRUCT_OFFSET (MonoString, length), ins->flags | MONO_INST_CONSTANT_LOAD);
+ ins->sreg1, MONO_STRUCT_OFFSET (MonoString, length), ins->flags | MONO_INST_INVARIANT_LOAD);
break;
default:
break;
projects / mono.git / blobdiff