[mono/mono] c508278e: [jit] Get rid of the intermediate OP_..CALLVIRT opcodes, use the _MEMBASE opcodes instead.

   Branch: refs/heads/master
     Home: https://github.com/mono/mono
  Compare: https://github.com/mono/mono/compare/c574de067d18...c508278e9c9f

   Commit: c508278e9c9f53fefabfc805825a937ab1f5ecc0
   Author: Zoltan Varga <[email protected]> (vargaz)
     Date: 2013-11-03 20:54:57 GMT
      URL: https://github.com/mono/mono/commit/c508278e9c9f53fefabfc805825a937ab1f5ecc0

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

Changed paths:
  M mono/mini/cpu-mips.md
  M mono/mini/graph.c
  M mono/mini/method-to-ir.c
  M mono/mini/mini-codegen.c
  M mono/mini/mini-ops.h

Modified: 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

Modified: mono/mini/graph.c
===================================================================
@@ -195,15 +195,15 @@
 		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) {

Modified: mono/mini/method-to-ir.c
===================================================================
@@ -1984,13 +1984,13 @@
 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 @@
 	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 @@
 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 @@
 	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_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 @@
 
 			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) {

Modified: mono/mini/mini-codegen.c
===================================================================
@@ -584,11 +584,8 @@ static inline int translate_bank (MonoRegState *rs, int bank, int hreg) {
 	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 @@ static inline int translate_bank (MonoRegState *rs, int bank, int hreg) {
 	case OP_VCALL2_MEMBASE:
 	case OP_VOIDCALL:
 	case OP_VOIDCALL_MEMBASE:
-	case OP_VOIDCALLVIRT:
 	case OP_TAILCALL: {
 		MonoCallInst *call = (MonoCallInst*)ins;
 		GSList *list;

Modified: mono/mini/mini-ops.h
===================================================================
@@ -40,23 +40,18 @@
 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 */


_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches