imported delegate patches from Daniel, new GetHashCode icalls

svn path=/trunk/mono/; revision=3060

mono/interpreter/ChangeLog

@@ -1,3 +1,6 @@
+2002-03-11  Dietmar Maurer  <dietmar@ximian.com>
+
+	* interp.c (ves_runtime_method): set method_info field
 
 Mon Mar 11 14:48:07 CET 2002 Paolo Molaro <lupus@ximian.com>
 

mono/interpreter/interp.c

@@ -533,27 +533,34 @@ ves_runtime_method (MonoInvocation *frame)
 {
 	const char *name = frame->method->name;
 	MonoObject *obj = (MonoObject*)frame->obj;
-	MonoDelegate *delegate = (MonoDelegate*)frame->obj;
+	MonoMulticastDelegate *delegate = (MonoMulticastDelegate*)frame->obj;
 	MonoInvocation call;
 
-	mono_class_init (mono_defaults.delegate_class);
+	mono_class_init (mono_defaults.multicastdelegate_class);
 
 	if (*name == '.' && (strcmp (name, ".ctor") == 0) && obj &&
-			mono_object_isinst (obj, mono_defaults.delegate_class)) {
-		delegate->target = frame->stack_args[0].data.p;
-		delegate->method_ptr = frame->stack_args[1].data.p;
+			mono_object_isinst (obj, mono_defaults.multicastdelegate_class)) {
+		delegate->delegate.target = frame->stack_args[0].data.p;
+		delegate->delegate.method_ptr = frame->stack_args[1].data.p;
+		if (!delegate->delegate.target) {
+			MonoDomain *domain = mono_domain_get ();
+			MonoMethod *m = mono_method_pointer_get (delegate->delegate.method_ptr);
+			delegate->delegate.method_info = mono_method_get_object (domain, m);
+		}
 		return;
 	}
 	if (*name == 'I' && (strcmp (name, "Invoke") == 0) && obj &&
-			mono_object_isinst (obj, mono_defaults.delegate_class)) {
-		MonoPIFunc func;
+			mono_object_isinst (obj, mono_defaults.multicastdelegate_class)) {
 		guchar *code;
 		MonoMethod *method;
 
-		code = (guchar*)delegate->method_ptr;
+		// FIXME: support multicast delegates 
+		g_assert (!delegate->prev);
+
+		code = (guchar*)delegate->delegate.method_ptr;
 		method = mono_method_pointer_get (code);
 		/* FIXME: check for NULL method */
-		INIT_FRAME(&call,frame,delegate->target,frame->stack_args,frame->retval,method);
+		INIT_FRAME(&call,frame,delegate->delegate.target,frame->stack_args,frame->retval,method);
 		ves_exec_method (&call);
 #if 0
 		if (!method->addr)
@@ -3702,7 +3709,7 @@ output_profile (GList *funcs)
 		g_snprintf (buf, sizeof (buf), "%s.%s::%s(%d)",
 			p->u.method->klass->name_space, p->u.method->klass->name,
 			p->u.method->name, p->u.method->signature->param_count);
-		printf ("%-52s %7d %7ld %7d\n", buf,
+		printf ("%-52s %7d %7llu %7d\n", buf,
 			(gint)(p->total*1000), p->count, (gint)((p->total*1000)/p->count));
 	}
 }

mono/jit/ChangeLog

@@ -1,4 +1,9 @@
+2002-03-11  Dietmar Maurer  <dietmar@ximian.com>
 
+	* emit-x86.c (mono_delegate_ctor): use C impl. instead of x86_*
+	macros, included new delegate code from Daniel Stodden. 
+
+
 Mon Mar 11 14:47:21 CET 2002 Paolo Molaro <lupus@ximian.com>
 
 	* jit.c: verify that corlib and runtime are in sync.

mono/jit/emit-x86.c

@@ -876,6 +876,27 @@ match_debug_method (MonoMethod* method)
 	return 0;
 }
 
+static void
+mono_delegate_ctor (MonoDelegate *this, MonoObject *target, 
+		    gpointer addr)
+{
+	MonoDomain *domain = mono_domain_get ();
+	MonoClass *class;
+	MonoJitInfo *ji;
+
+	g_assert (this);
+	g_assert (addr);
+
+	class = this->object.vtable->klass;
+
+	if (!target && (ji = mono_jit_info_table_find (mono_jit_info_table, addr)))
+		this->method_info = mono_method_get_object (domain, ji->method);
+
+	this->target = target;
+	this->method_ptr = addr;
+
+}
+
 /**
  * arch_compile_method:
  * @method: pointer to the method info
@@ -916,51 +937,26 @@ arch_compile_method (MonoMethod *method)
 	}
 
 	if (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) {
-		MonoClassField *field;
 		const char *name = method->name;
-		static guint target_offset = 0;
-		static guint method_offset = 0;
 		guint8 *code;
 		gboolean delegate = FALSE;
 
-		if (method->klass->parent && 
-		    method->klass->parent->parent == mono_defaults.delegate_class)
+		if (method->klass->parent == mono_defaults.multicastdelegate_class)
 			delegate = TRUE;
 
-		if (!target_offset) {
-			mono_class_init (mono_defaults.delegate_class);
-
-			field = mono_class_get_field_from_name (mono_defaults.delegate_class, "m_target");
-			target_offset = field->offset;
-			field = mono_class_get_field_from_name (mono_defaults.delegate_class, "method_ptr");
-			method_offset = field->offset;
-		}
-
 		if (delegate && *name == '.' && (strcmp (name, ".ctor") == 0)) {
-			addr = code = g_malloc (32);
-			x86_push_reg (code, X86_EBP);
-			x86_mov_reg_reg (code, X86_EBP, X86_ESP, 4);
-
-			/* load the this pointer */
-			x86_mov_reg_membase (code, X86_EAX, X86_EBP, 8, 4); 
-			/* load m_target arg */
-			x86_mov_reg_membase (code, X86_EDX, X86_EBP, 12, 4);
-			/* store mtarget */
-			x86_mov_membase_reg (code, X86_EAX, target_offset, X86_EDX, 4); 
-			/* load method_ptr arg */
-			x86_mov_reg_membase (code, X86_EDX, X86_EBP, 16, 4);
-			/* store method_ptr */
-			x86_mov_membase_reg (code, X86_EAX, method_offset, X86_EDX, 4); 
-
-			x86_leave (code);
-			x86_ret (code);
-
-			g_assert ((code - (guint8*)addr) < 32);
-
+			addr = (gpointer)mono_delegate_ctor;
 		} else if (delegate && *name == 'I' && (strcmp (name, "Invoke") == 0)) {
+			/*
+			 *	Invoke( args .. ) {
+			 *		if ( prev )
+			 *			prev.Invoke();
+			 *		return this.<m_target>( args );
+			 *	}
+			 */
 			MonoMethodSignature *csig = method->signature;
-			int i, arg_size, target, this_pos = 4;
-			guint8 *source;
+			guint8 *br[2], *pos[2];
+			int i, arg_size, this_pos = 4;
 
 			if (csig->ret->type == MONO_TYPE_VALUETYPE) {
 				g_assert (!csig->ret->byref);
@@ -979,50 +975,89 @@ arch_compile_method (MonoMethod *method)
 
 			addr = g_malloc (64 + arg_size);
 
-			for (i = 0; i < 2; i ++) {
-				int j;
-
-				code = addr;
-				/* load the this pointer */
-				x86_mov_reg_membase (code, X86_EAX, X86_ESP, this_pos, 4);
-				/* load mtarget */
-				x86_mov_reg_membase (code, X86_EDX, X86_EAX, target_offset, 4); 
-				/* check if zero (static method call without this pointer) */
-				x86_alu_reg_imm (code, X86_CMP, X86_EDX, 0);
-				x86_branch32 (code, X86_CC_EQ, target, TRUE); 
-				source = code;
-
-				/* virtual delegate methods: we have to replace the this pointer 
-				 * withe the actual target */
-				x86_mov_membase_reg (code, X86_ESP, this_pos, X86_EDX, 4); 
-				/* jump to method_ptr() */
-				x86_jump_membase (code, X86_EAX, method_offset);
-
-				/* static delegate methods: we have to remove the this pointer 
-				 * from the activation frame - I do this do creating a new 
-				 * stack frame an copy all arguments except the this pointer */
-
-				target = code - source;
-				g_assert ((arg_size & 3) == 0);
-				for (j = 0; j < (arg_size>>2); j++) {
-					x86_push_membase (code, X86_ESP, (arg_size + this_pos));
-				}
+			code = addr;
+			/* load the this pointer */
+			x86_mov_reg_membase (code, X86_EAX, X86_ESP, this_pos, 4);
+
+			/* load prev */
+			x86_mov_reg_membase (code, X86_EDX, X86_EAX, G_STRUCT_OFFSET (MonoMulticastDelegate, prev), 4);
+
+			/* prev == 0 ? */
+			x86_alu_reg_imm (code, X86_CMP, X86_EDX, 0);
+			br[0] = code; x86_branch32 (code, X86_CC_EQ, 0, TRUE );
+			pos[0] = code;
+
+			x86_push_reg( code, X86_EAX );
+			/* push args */
+			for ( i = 0; i < (arg_size>>2); i++ )
+				x86_push_membase( code, X86_ESP, (arg_size + this_pos + 4) );
+			/* push next */
+			x86_push_reg( code, X86_EDX );
+			if (this_pos == 8)
+				x86_push_membase (code, X86_ESP, (arg_size + 8));
+			/* recurse */
+			br[1] = code; x86_call_imm( code, 0 );
+			pos[1] = code; x86_call_imm( br[1], addr - pos[1] );
+
+			if (this_pos == 8)
+				x86_alu_reg_imm (code, X86_ADD, X86_ESP, arg_size + 8);
+			else
+				x86_alu_reg_imm (code, X86_ADD, X86_ESP, arg_size + 4);
+			x86_pop_reg( code, X86_EAX );
+
+			/* prev == 0 */ 
+			x86_branch32( br[0], X86_CC_EQ, code - pos[0], TRUE );
+
+			/* load mtarget */
+			x86_mov_reg_membase (code, X86_EDX, X86_EAX, G_STRUCT_OFFSET (MonoDelegate, target), 4); 
+			/* mtarget == 0 ? */
+			x86_alu_reg_imm (code, X86_CMP, X86_EDX, 0);
+			br[0] = code; x86_branch32 (code, X86_CC_EQ, 0, TRUE);
+			pos[0] = code;
+
+			/* 
+			 * virtual delegate methods: we have to
+			 * replace the this pointer with the actual
+			 * target
+			 */
+			x86_mov_membase_reg (code, X86_ESP, this_pos, X86_EDX, 4); 
+			/* jump to method_ptr() */
+			x86_jump_membase (code, X86_EAX, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
+
+			/* mtarget != 0 */ 
+			x86_branch32( br[0], X86_CC_EQ, code - pos[0], TRUE);
+			/* 
+			 * static delegate methods: we have to remove
+			 * the this pointer from the activation frame
+			 * - I do this creating a new stack frame anx
+			 * copy all arguments except the this pointer
+			 */
+			g_assert ((arg_size & 3) == 0);
+			for (i = 0; i < (arg_size>>2); i++) {
+				x86_push_membase (code, X86_ESP, (arg_size + this_pos));
+			}
 
-				if (this_pos == 8) 
-					x86_push_membase (code, X86_ESP, (arg_size + 4));
-
-				x86_call_membase (code, X86_EAX, method_offset);
+			if (this_pos == 8)
+				x86_push_membase (code, X86_ESP, (arg_size + 4));
+
+			x86_call_membase (code, X86_EAX, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
+			if (arg_size) {
 				if (this_pos == 8) 
 					x86_alu_reg_imm (code, X86_ADD, X86_ESP, arg_size + 4);
 				else
 					x86_alu_reg_imm (code, X86_ADD, X86_ESP, arg_size);
-
-				x86_ret (code);
-
 			}
 
+			x86_ret (code);
+
 			g_assert ((code - (guint8*)addr) < (64 + arg_size));
 
+			if (mono_jit_dump_asm) {
+				char *id = g_strdup_printf ("%s.%s_%s", method->klass->name_space,
+							    method->klass->name, method->name);
+				mono_disassemble_code( addr, code - (guint8*)addr, id );
+				g_free (id);
+			}
 		} else {
 			if (mono_debug_handle) 
 				return NULL;
@@ -1190,7 +1225,6 @@ arch_get_restore_context ()
 
 	/* get return address, stored in EDX */
 	x86_mov_reg_membase (code, X86_EDX, X86_EAX,  G_STRUCT_OFFSET (struct sigcontext, eip), 4);
-
 	/* restore EBX */
 	x86_mov_reg_membase (code, X86_EBX, X86_EAX,  G_STRUCT_OFFSET (struct sigcontext, ebx), 4);
 	/* restore EDI */

mono/metadata/ChangeLog

@@ -1,3 +1,10 @@
+2002-03-12  Dietmar Maurer  <dietmar@ximian.com>
+
+	* icall.c (ves_icall_System_Object_GetHashCode): impl.
+
+2002-03-11  Dietmar Maurer  <dietmar@ximian.com>
+
+	* icall.c (ves_icall_System_ValueType_GetHashCode): impl.
 
 Mon Mar 11 14:45:42 CET 2002 Paolo Molaro <lupus@ximian.com>
 

mono/metadata/appdomain.c

@@ -199,9 +199,9 @@ mono_init (const char *filename)
                 mono_defaults.corlib, "System", "Array");
 	g_assert (mono_defaults.array_class != 0);
 
-	mono_defaults.delegate_class = mono_class_from_name (
-                mono_defaults.corlib, "System", "Delegate");
-	g_assert (mono_defaults.delegate_class != 0);
+	mono_defaults.multicastdelegate_class = mono_class_from_name (
+		mono_defaults.corlib, "System", "MulticastDelegate");
+	g_assert (mono_defaults.multicastdelegate_class != 0 );
 
 	mono_defaults.typehandle_class = mono_class_from_name (
                 mono_defaults.corlib, "System", "RuntimeTypeHandle");

mono/metadata/class.c

@@ -327,6 +327,7 @@ mono_class_init (MonoClass *class)
 	MonoClass *k, *ic;
 	MonoMethod **vtable = class->vtable;
 	int i, max_iid, cur_slot = 0;
+	static MonoMethod *default_ghc = NULL;
 
 	g_assert (class);
 
@@ -624,6 +625,22 @@ mono_class_init (MonoClass *class)
 			}
 		}
 	}
+
+#define GHC_SLOT 2
+
+	if (!default_ghc) {
+		if (class == mono_defaults.object_class) { 
+			default_ghc = vtable [GHC_SLOT];
+			g_assert (!strcmp (default_ghc->name, "GetHashCode"));
+		}
+	}
+
+	class->ghcimpl = 1;
+	if (class != mono_defaults.object_class) { 
+		if (vtable [GHC_SLOT] == default_ghc) {
+			class->ghcimpl = 0;
+		}
+	}
 }
 
 /**

mono/metadata/class.h

@@ -41,6 +41,7 @@ struct _MonoClass {
 	guint inited          : 1;
 	guint valuetype       : 1; /* derives from System.ValueType */
 	guint enumtype        : 1; /* derives from System.Enum */
+	guint ghcimpl         : 1; /* class has its own GetHashCode impl */ 
 	guint min_align       : 4;
 
 	MonoClass  *parent;