[jit] Use mini_emit_memory_load for ldind, ldobj and ldfld

diff --git a/mono/mini/method-to-ir.c b/mono/mini/method-to-ir.c
index 066b05b972f35613e9a8bceae9d19f848d1becf4..50eef9e6cfbbc0d0493f343bbd7c87cc90141e36 100644 (file)
--- a/mono/mini/method-to-ir.c
+++ b/mono/mini/method-to-ir.c
@@ -1161,10 +1161,24 @@ type_from_op (MonoCompile *cfg, MonoInst *ins, MonoInst *src1, MonoInst *src2)
                ins->klass = mono_defaults.object_class;
 }
 
-static const char 
-ldind_type [] = {
-       STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I4, STACK_I8, STACK_PTR, STACK_R8, STACK_R8, STACK_OBJ
-};
+static MonoClass*
+ldind_to_type (int op)
+{
+       switch (op) {
+       case CEE_LDIND_I1: return mono_defaults.sbyte_class;
+       case CEE_LDIND_U1: return mono_defaults.byte_class;
+       case CEE_LDIND_I2: return mono_defaults.int16_class;
+       case CEE_LDIND_U2: return mono_defaults.uint16_class;
+       case CEE_LDIND_I4: return mono_defaults.int32_class;
+       case CEE_LDIND_U4: return mono_defaults.uint32_class;
+       case CEE_LDIND_I8: return mono_defaults.int64_class;
+       case CEE_LDIND_I: return mono_defaults.int_class;
+       case CEE_LDIND_R4: return mono_defaults.single_class;
+       case CEE_LDIND_R8: return mono_defaults.double_class;
+       case CEE_LDIND_REF:return mono_defaults.object_class; //FIXME we should try to return a more specific type
+       default: g_error ("Unknown ldind type %d", op);
+       }
+}
 
 #if 0
 
@@ -9618,32 +9632,8 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
                        CHECK_STACK (1);
                        --sp;
 
-                       switch (*ip) {
-                       case CEE_LDIND_R4:
-                       case CEE_LDIND_R8:
-                               dreg = alloc_freg (cfg);
-                               break;
-                       case CEE_LDIND_I8:
-                               dreg = alloc_lreg (cfg);
-                               break;
-                       case CEE_LDIND_REF:
-                               dreg = alloc_ireg_ref (cfg);
-                               break;
-                       default:
-                               dreg = alloc_preg (cfg);
-                       }
-
-                       NEW_LOAD_MEMBASE (cfg, ins, ldind_to_load_membase (*ip), dreg, sp [0]->dreg, 0);
-                       ins->type = ldind_type [*ip - CEE_LDIND_I1];
-                       if (*ip == CEE_LDIND_R4)
-                               ins->type = cfg->r4_stack_type;
-                       ins->flags |= ins_flag;
-                       MONO_ADD_INS (cfg->cbb, ins);
+                       ins = mini_emit_memory_load (cfg, &ldind_to_type (*ip)->byval_arg, sp [0], 0, ins_flag);
                        *sp++ = ins;
-                       if (ins_flag & MONO_INST_VOLATILE) {
-                               /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
-                               mini_emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_ACQ);
-                       }
                        ins_flag = 0;
                        ++ip;
                        break;
@@ -9939,15 +9929,9 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
                                break;
                        }
 
-                       EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, ins, &klass->byval_arg, sp [0]->dreg, 0);
-                       ins->flags |= ins_flag;
+                       ins = mini_emit_memory_load (cfg, &klass->byval_arg, sp [0], 0, ins_flag);
                        *sp++ = ins;
 
-                       if (ins_flag & MONO_INST_VOLATILE) {
-                               /* Volatile loads have acquire semantics, see 12.6.7 in Ecma 335 */
-                               mini_emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_ACQ);
-                       }
-
                        ip += 5;
                        ins_flag = 0;
                        inline_costs += 1;
@@ -10705,19 +10689,19 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
                                                }
                                        }
 
+                                       MonoInst *field_add_inst = sp [0];
                                        if (mini_is_gsharedvt_klass (klass)) {
                                                MonoInst *offset_ins;
 
                                                offset_ins = emit_get_gsharedvt_info (cfg, field, MONO_RGCTX_INFO_FIELD_OFFSET);
                                                /* The value is offset by 1 */
                                                EMIT_NEW_BIALU_IMM (cfg, ins, OP_PSUB_IMM, offset_ins->dreg, offset_ins->dreg, 1);
-                                               dreg = alloc_ireg_mp (cfg);
-                                               EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, sp [0]->dreg, offset_ins->dreg);
-                                               EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, dreg, 0);
-                                       } else {
-                                               EMIT_NEW_LOAD_MEMBASE_TYPE (cfg, load, field->type, sp [0]->dreg, foffset);
+                                               EMIT_NEW_BIALU (cfg, field_add_inst, OP_PADD, alloc_ireg_mp (cfg), sp [0]->dreg, offset_ins->dreg);
+                                               foffset = 0;
                                        }
-                                       load->flags |= ins_flag;
+
+                                       load = mini_emit_memory_load (cfg, field->type, field_add_inst, foffset, ins_flag);
+
                                        if (sp [0]->opcode != OP_LDADDR)
                                                load->flags |= MONO_INST_FAULT;
                                        *sp++ = load;