[jit] Get rid of the intermediate OP_..CALLVIRT opcodes, use the _MEMBASE opcodes...

diff --git a/mono/mini/cpu-mips.md b/mono/mini/cpu-mips.md
index 41c1b5840c2fbac384d03e8b5360888cb1ae1571..0fd87c8973fe25fbe5fb5339bb198131affb60db 100644 (file)
--- a/mono/mini/cpu-mips.md
+++ b/mono/mini/cpu-mips.md
@@ -61,7 +61,6 @@ br: len:16
 switch: src1:i len:40
 seq_point: len:24
 
-callvirt: dest:v clob:c len:20
 int_conv_to_r_un: dest:f src1:i len:32
 throw: src1:i len:24
 rethrow: src1:i len:24

diff --git a/mono/mini/graph.c b/mono/mini/graph.c
index 09917f93e4b9b8e39a157fc5c540da1bf0ae0d88..d9b0adec2f1341ec9f7a076d8c2231d5bef07b97 100644 (file)
--- a/mono/mini/graph.c
+++ b/mono/mini/graph.c
@@ -195,15 +195,15 @@ mono_print_label (FILE *fp, MonoInst *tree) {
                mono_print_label (fp, tree->inst_newa_len);
                break;
        case OP_CALL:
-       case OP_CALLVIRT:
+       case OP_CALL_MEMBASE:
        case OP_FCALL:
-       case OP_FCALLVIRT:
+       case OP_FCALL_MEMBASE:
        case OP_LCALL:
-       case OP_LCALLVIRT:
+       case OP_LCALL_MEMBASE:
        case OP_VCALL:
-       case OP_VCALLVIRT:
+       case OP_VCALL_MEMBASE:
        case OP_VOIDCALL:
-       case OP_VOIDCALLVIRT: {
+       case OP_VOIDCALL_MEMBASE: {
                MonoCallInst *call = (MonoCallInst*)tree;
                if (call->method) {
                        if (mono_method_signature (call->method)->hasthis && tree->inst_left) {

diff --git a/mono/mini/method-to-ir.c b/mono/mini/method-to-ir.c
index 599138e6500585f8aa52ccf92d8e27613cc29aa5..20ee063a8737065419ec80839e4adcaede4da8bb 100644 (file)
--- a/mono/mini/method-to-ir.c
+++ b/mono/mini/method-to-ir.c
@@ -1984,13 +1984,13 @@ static int
 ret_type_to_call_opcode (MonoType *type, int calli, int virt, MonoGenericSharingContext *gsctx)
 {
        if (type->byref)
-               return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
+               return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
 
 handle_enum:
        type = mini_get_basic_type_from_generic (gsctx, type);
        switch (type->type) {
        case MONO_TYPE_VOID:
-               return calli? OP_VOIDCALL_REG: virt? OP_VOIDCALLVIRT: OP_VOIDCALL;
+               return calli? OP_VOIDCALL_REG: virt? OP_VOIDCALL_MEMBASE: OP_VOIDCALL;
        case MONO_TYPE_I1:
        case MONO_TYPE_U1:
        case MONO_TYPE_BOOLEAN:
@@ -1999,39 +1999,39 @@ handle_enum:
        case MONO_TYPE_CHAR:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
-               return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
+               return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
        case MONO_TYPE_I:
        case MONO_TYPE_U:
        case MONO_TYPE_PTR:
        case MONO_TYPE_FNPTR:
-               return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
+               return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
        case MONO_TYPE_CLASS:
        case MONO_TYPE_STRING:
        case MONO_TYPE_OBJECT:
        case MONO_TYPE_SZARRAY:
        case MONO_TYPE_ARRAY:    
-               return calli? OP_CALL_REG: virt? OP_CALLVIRT: OP_CALL;
+               return calli? OP_CALL_REG: virt? OP_CALL_MEMBASE: OP_CALL;
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
-               return calli? OP_LCALL_REG: virt? OP_LCALLVIRT: OP_LCALL;
+               return calli? OP_LCALL_REG: virt? OP_LCALL_MEMBASE: OP_LCALL;
        case MONO_TYPE_R4:
        case MONO_TYPE_R8:
-               return calli? OP_FCALL_REG: virt? OP_FCALLVIRT: OP_FCALL;
+               return calli? OP_FCALL_REG: virt? OP_FCALL_MEMBASE: OP_FCALL;
        case MONO_TYPE_VALUETYPE:
                if (type->data.klass->enumtype) {
                        type = mono_class_enum_basetype (type->data.klass);
                        goto handle_enum;
                } else
-                       return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
+                       return calli? OP_VCALL_REG: virt? OP_VCALL_MEMBASE: OP_VCALL;
        case MONO_TYPE_TYPEDBYREF:
-               return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
+               return calli? OP_VCALL_REG: virt? OP_VCALL_MEMBASE: OP_VCALL;
        case MONO_TYPE_GENERICINST:
                type = &type->data.generic_class->container_class->byval_arg;
                goto handle_enum;
        case MONO_TYPE_VAR:
        case MONO_TYPE_MVAR:
                /* gsharedvt */
-               return calli? OP_VCALL_REG: virt? OP_VCALLVIRT: OP_VCALL;
+               return calli? OP_VCALL_REG: virt? OP_VCALL_MEMBASE: OP_VCALL;
        default:
                g_error ("unknown type 0x%02x in ret_type_to_call_opcode", type->type);
        }
@@ -2260,15 +2260,15 @@ static int
 callvirt_to_call (int opcode)
 {
        switch (opcode) {
-       case OP_CALLVIRT:
+       case OP_CALL_MEMBASE:
                return OP_CALL;
-       case OP_VOIDCALLVIRT:
+       case OP_VOIDCALL_MEMBASE:
                return OP_VOIDCALL;
-       case OP_FCALLVIRT:
+       case OP_FCALL_MEMBASE:
                return OP_FCALL;
-       case OP_VCALLVIRT:
+       case OP_VCALL_MEMBASE:
                return OP_VCALL;
-       case OP_LCALLVIRT:
+       case OP_LCALL_MEMBASE:
                return OP_LCALL;
        default:
                g_assert_not_reached ();
@@ -2277,27 +2277,6 @@ callvirt_to_call (int opcode)
        return -1;
 }
 
-static int
-callvirt_to_call_membase (int opcode)
-{
-       switch (opcode) {
-       case OP_CALLVIRT:
-               return OP_CALL_MEMBASE;
-       case OP_VOIDCALLVIRT:
-               return OP_VOIDCALL_MEMBASE;
-       case OP_FCALLVIRT:
-               return OP_FCALL_MEMBASE;
-       case OP_LCALLVIRT:
-               return OP_LCALL_MEMBASE;
-       case OP_VCALLVIRT:
-               return OP_VCALL_MEMBASE;
-       default:
-               g_assert_not_reached ();
-       }
-
-       return -1;
-}
-
 #ifdef MONO_ARCH_HAVE_IMT
 /* Either METHOD or IMT_ARG needs to be set */
 static void
@@ -2670,7 +2649,6 @@ mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSign
                        MONO_EMIT_NULL_CHECK (cfg, this_reg);
 
                        /* Make a call to delegate->invoke_impl */
-                       call->inst.opcode = callvirt_to_call_membase (call->inst.opcode);
                        call->inst.inst_basereg = this_reg;
                        call->inst.inst_offset = G_STRUCT_OFFSET (MonoDelegate, invoke_impl);
                        MONO_ADD_INS (cfg->cbb, (MonoInst*)call);
@@ -2725,8 +2703,6 @@ mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSign
 
                        call->inst.opcode = callvirt_to_call (call->inst.opcode);
                } else {
-                       call->inst.opcode = callvirt_to_call_membase (call->inst.opcode);
-
                        vtable_reg = alloc_preg (cfg);
                        MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vtable_reg, this_reg, G_STRUCT_OFFSET (MonoObject, vtable));
                        if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {

diff --git a/mono/mini/mini-codegen.c b/mono/mini/mini-codegen.c
index e82c07974ef469948bd4ee8cf9df501da79a5db1..7c0a3c66ccf2549461cc75c5fa021be2a19d365a 100644 (file)
--- a/mono/mini/mini-codegen.c
+++ b/mono/mini/mini-codegen.c
@@ -584,11 +584,8 @@ mono_print_ins_index (int i, MonoInst *ins)
        case OP_CALL_MEMBASE:
        case OP_CALL_REG:
        case OP_FCALL:
-       case OP_FCALLVIRT:
        case OP_LCALL:
-       case OP_LCALLVIRT:
        case OP_VCALL:
-       case OP_VCALLVIRT:
        case OP_VCALL_REG:
        case OP_VCALL_MEMBASE:
        case OP_VCALL2:
@@ -596,7 +593,6 @@ mono_print_ins_index (int i, MonoInst *ins)
        case OP_VCALL2_MEMBASE:
        case OP_VOIDCALL:
        case OP_VOIDCALL_MEMBASE:
-       case OP_VOIDCALLVIRT:
        case OP_TAILCALL: {
                MonoCallInst *call = (MonoCallInst*)ins;
                GSList *list;

diff --git a/mono/mini/mini-ops.h b/mono/mini/mini-ops.h
index 7d1e64d6b0f2200197bfff18f1e978c588fa3cab..512c1bc46f836a86a2278facd5e9cb6fd4114685 100644 (file)
--- a/mono/mini/mini-ops.h
+++ b/mono/mini/mini-ops.h
@@ -40,23 +40,18 @@ MINI_OP(OP_SEQ_POINT, "seq_point", NONE, NONE, NONE)
 MINI_OP(OP_IMPLICIT_EXCEPTION, "implicit_exception", NONE, NONE, NONE)
 
 MINI_OP(OP_VOIDCALL,   "voidcall", NONE, NONE, NONE)
-MINI_OP(OP_VOIDCALLVIRT,       "voidcallvirt", NONE, NONE, NONE)
 MINI_OP(OP_VOIDCALL_REG,       "voidcall_reg", NONE, IREG, NONE)
 MINI_OP(OP_VOIDCALL_MEMBASE,   "voidcall_membase", NONE, IREG, NONE)
 MINI_OP(OP_CALL,        "call", IREG, NONE, NONE)
 MINI_OP(OP_CALL_REG,   "call_reg", IREG, IREG, NONE)
 MINI_OP(OP_CALL_MEMBASE,       "call_membase", IREG, IREG, NONE)
-MINI_OP(OP_CALLVIRT, "callvirt", IREG, NONE, NONE)
 MINI_OP(OP_FCALL,      "fcall", FREG, NONE, NONE)
-MINI_OP(OP_FCALLVIRT,  "fcallvirt", FREG, NONE, NONE)
 MINI_OP(OP_FCALL_REG,  "fcall_reg", FREG, IREG, NONE)
 MINI_OP(OP_FCALL_MEMBASE,      "fcall_membase", FREG, IREG, NONE)
 MINI_OP(OP_LCALL,      "lcall", LREG, NONE, NONE)
-MINI_OP(OP_LCALLVIRT,  "lcallvirt", LREG, NONE, NONE)
 MINI_OP(OP_LCALL_REG,  "lcall_reg", LREG, IREG, NONE)
 MINI_OP(OP_LCALL_MEMBASE,      "lcall_membase", LREG, IREG, NONE)
 MINI_OP(OP_VCALL,      "vcall", VREG, NONE, NONE)
-MINI_OP(OP_VCALLVIRT,  "vcallvirt", VREG, NONE, NONE)
 MINI_OP(OP_VCALL_REG,  "vcall_reg", VREG, IREG, NONE)
 MINI_OP(OP_VCALL_MEMBASE,      "vcall_membase", VREG, IREG, NONE)
 /* Represents the decomposed vcall which doesn't return a vtype no more */