X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fdecompose.c;h=1c3060f162477cc8db01fbc0c64c6eb2c6f3ebbb;hb=3e6c4f526499a339783cbe427e9916bbd99d7a0e;hp=10a5bdfd5b40a943f3a0b627cd4cb91265ff7121;hpb=69f207ee9e4f440e66e98bf5f685807f6527c39d;p=mono.git diff --git a/mono/mini/decompose.c b/mono/mini/decompose.c index 10a5bdfd5b4..1c3060f1624 100644 --- a/mono/mini/decompose.c +++ b/mono/mini/decompose.c @@ -1,5 +1,6 @@ -/* - * decompose.c: Functions to decompose complex IR instructions into simpler ones. +/** + * \file + * Functions to decompose complex IR instructions into simpler ones. * * Author: * Zoltan Varga (vargaz@gmail.com) @@ -15,14 +16,10 @@ #include #include +#include #ifndef DISABLE_JIT -/* FIXME: This conflicts with the definition in mini.c, so it cannot be moved to mini.h */ -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. * This is also used on 32 bit machines when using LLVM, so it needs to handle I/U correctly. @@ -933,6 +930,8 @@ mono_decompose_long_opts (MonoCompile *cfg) MONO_EMIT_NEW_BIALU_IMM (cfg, OP_XOR_IMM, MONO_LVREG_LS (tree->dreg), MONO_LVREG_LS (tree->sreg1), tree->inst_ls_word); MONO_EMIT_NEW_BIALU_IMM (cfg, OP_XOR_IMM, MONO_LVREG_MS (tree->dreg), MONO_LVREG_MS (tree->sreg1), tree->inst_ms_word); break; +#ifdef TARGET_POWERPC +/* FIXME This is normally handled in cprop. Proper fix or remove if no longer needed. */ case OP_LSHR_UN_IMM: if (tree->inst_c1 == 32) { @@ -941,20 +940,12 @@ mono_decompose_long_opts (MonoCompile *cfg) * later apply the speedup to the left shift as well * See BUG# 57957. */ - /* FIXME: Move this to the strength reduction pass */ /* just move the upper half to the lower and zero the high word */ MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, MONO_LVREG_LS (tree->dreg), MONO_LVREG_MS (tree->sreg1)); MONO_EMIT_NEW_ICONST (cfg, MONO_LVREG_MS (tree->dreg), 0); } break; - case OP_LSHL_IMM: - if (tree->inst_c1 == 32) { - /* just move the lower half to the upper and zero the lower word */ - MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, MONO_LVREG_MS (tree->dreg), MONO_LVREG_LS (tree->sreg1)); - MONO_EMIT_NEW_ICONST (cfg, MONO_LVREG_LS (tree->dreg), 0); - } - break; - +#endif case OP_LCOMPARE: { MonoInst *next = mono_inst_next (tree, FILTER_IL_SEQ_POINT); @@ -1270,6 +1261,9 @@ mono_decompose_vtype_opts (MonoCompile *cfg) case OP_STOREV_MEMBASE: { src_var = get_vreg_to_inst (cfg, ins->sreg1); + if (COMPILE_LLVM (cfg) && !mini_is_gsharedvt_klass (ins->klass) && !cfg->gen_write_barriers) + break; + if (!src_var) { g_assert (ins->klass); src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->sreg1); @@ -1514,10 +1508,13 @@ mono_decompose_array_access_opts (MonoCompile *cfg) break; case OP_BOUNDS_CHECK: MONO_EMIT_NULL_CHECK (cfg, ins->sreg1); - if (COMPILE_LLVM (cfg)) - MONO_EMIT_DEFAULT_BOUNDS_CHECK (cfg, ins->sreg1, ins->inst_imm, ins->sreg2, ins->flags & MONO_INST_FAULT); - else + if (COMPILE_LLVM (cfg)) { + int index2_reg = alloc_preg (cfg); + MONO_EMIT_NEW_UNALU (cfg, OP_SEXT_I4, index2_reg, ins->sreg2); + MONO_EMIT_DEFAULT_BOUNDS_CHECK (cfg, ins->sreg1, ins->inst_imm, index2_reg, ins->flags & MONO_INST_FAULT); + } else { MONO_ARCH_EMIT_BOUNDS_CHECK (cfg, ins->sreg1, ins->inst_imm, ins->sreg2); + } break; case OP_NEWARR: if (cfg->opt & MONO_OPT_SHARED) { @@ -1526,7 +1523,7 @@ mono_decompose_array_access_opts (MonoCompile *cfg) MONO_INST_NEW (cfg, iargs [2], OP_MOVE); iargs [2]->dreg = ins->sreg1; - dest = mono_emit_jit_icall (cfg, mono_array_new, iargs); + dest = mono_emit_jit_icall (cfg, ves_icall_array_new, iargs); dest->dreg = ins->dreg; } else { MonoClass *array_class = mono_array_class_get (ins->inst_newa_class, 1); @@ -1892,6 +1889,13 @@ mono_local_emulate_ops (MonoCompile *cfg) int op_noimm = mono_op_imm_to_op (ins->opcode); MonoJitICallInfo *info; + /* + * These opcodes don't have logical equivalence to the emulating native + * function. They are decomposed in specific fashion in mono_decompose_soft_float. + */ + if (MONO_HAS_CUSTOM_EMULATION (ins)) + continue; + /* * Emulation can't handle _IMM ops. If this is an imm opcode we need * to check whether its non-imm counterpart is emulated and, if so, @@ -1928,9 +1932,9 @@ mono_local_emulate_ops (MonoCompile *cfg) /* We emit the call on a separate dummy basic block */ cfg->cbb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock)); - first_bb = cfg->cbb; + first_bb = cfg->cbb; - call = mono_emit_jit_icall_by_info (cfg, info, args); + call = mono_emit_jit_icall_by_info (cfg, bb->real_offset, info, args); call->dreg = ins->dreg; /* Replace ins with the emitted code and do the necessary bb linking */ @@ -1964,4 +1968,8 @@ mono_local_emulate_ops (MonoCompile *cfg) } } -#endif /* DISABLE_JIT */ +#else /* !DISABLE_JIT */ + +MONO_EMPTY_SOURCE_FILE (decompose); + +#endif /* !DISABLE_JIT */