From 5d39eba2c8d9a057ae1612f0af82c13a838c040d Mon Sep 17 00:00:00 2001 From: Ben Maurer Date: Sun, 30 Jan 2005 03:06:32 +0000 Subject: [PATCH] In mono/metadata: 2005-01-29 Ben Maurer * loader.c (mono_method_signature): Make this method lazy (mono_get_method_from_token): Don't computate the signature here. Doing this saves quite a bit of memory. I got 90 kb on starting up monodoc. It should also save some disk reads on startup. * *: MonoMethod->signature might be NULL now. You *MUST* use mono_method_signature. In mono/mini: 2005-01-29 Ben Maurer * *: MonoMethod->signature might be NULL now. You *MUST* use mono_method_signature. In mono/interpreter: 2005-01-29 Ben Maurer * *: MonoMethod->signature might be NULL now. You *MUST* use mono_method_signature. svn path=/trunk/mono/; revision=39776 --- mono/interpreter/ChangeLog | 5 ++ mono/interpreter/interp.c | 21 +++--- mono/interpreter/transform.c | 36 +++++----- mono/metadata/ChangeLog | 11 +++ mono/metadata/class.c | 20 +++--- mono/metadata/debug-helpers.c | 8 +-- mono/metadata/icall.c | 26 +++---- mono/metadata/loader.c | 136 ++++++++++++++++++++++-------------- mono/metadata/marshal.c | 70 +++++++++---------- mono/metadata/mono-debug-debugger.c | 44 ++++++------ mono/metadata/monodiet.c | 4 +- mono/metadata/object.c | 28 ++++---- mono/metadata/profiler.c | 2 +- mono/metadata/reflection.c | 63 +++++++++-------- mono/metadata/verify.c | 10 +-- mono/mini/ChangeLog | 5 ++ mono/mini/debug-mini.c | 14 ++-- mono/mini/exceptions-amd64.c | 4 +- mono/mini/exceptions-x86.c | 4 +- mono/mini/graph.c | 2 +- mono/mini/inssel-amd64.brg | 2 +- mono/mini/inssel-s390.brg | 2 +- mono/mini/inssel-s390x.brg | 2 +- mono/mini/jit-icalls.c | 2 +- mono/mini/mini-amd64.c | 10 +-- mono/mini/mini-ppc.c | 6 +- mono/mini/mini-s390.c | 16 ++--- mono/mini/mini-s390x.c | 18 ++--- mono/mini/mini-sparc.c | 16 ++--- mono/mini/mini-x86.c | 11 ++- mono/mini/mini.c | 63 +++++++++-------- mono/mini/trace.c | 16 ++--- mono/mini/tramp-amd64.c | 2 +- mono/mini/tramp-ppc.c | 2 +- mono/mini/tramp-s390.c | 4 +- mono/mini/tramp-s390x.c | 4 +- mono/mini/tramp-sparc.c | 2 +- mono/mini/tramp-x86.c | 2 +- 38 files changed, 377 insertions(+), 316 deletions(-) diff --git a/mono/interpreter/ChangeLog b/mono/interpreter/ChangeLog index ed1e85ef34f..091be8e03d7 100644 --- a/mono/interpreter/ChangeLog +++ b/mono/interpreter/ChangeLog @@ -1,3 +1,8 @@ +2005-01-29 Ben Maurer + + * *: MonoMethod->signature might be NULL now. You *MUST* use + mono_method_signature. + 2005-01-20 Bernie Solomon * interp.c: mono_init_icall got renamed diff --git a/mono/interpreter/interp.c b/mono/interpreter/interp.c index ec9609f5950..214b1b14f61 100644 --- a/mono/interpreter/interp.c +++ b/mono/interpreter/interp.c @@ -270,8 +270,8 @@ mono_interp_get_runtime_method (MonoMethod *method) rtm = mono_mempool_alloc (domain->mp, sizeof (RuntimeMethod)); memset (rtm, 0, sizeof (*rtm)); rtm->method = method; - rtm->param_count = method->signature->param_count; - rtm->hasthis = method->signature->hasthis; + rtm->param_count = mono_method_signature (method)->param_count; + rtm->hasthis = mono_method_signature (method)->hasthis; rtm->valuetype = method->klass->valuetype; g_hash_table_insert (domain->jit_code_hash, method, rtm); LeaveCriticalSection (&runtime_method_lookup_section); @@ -578,7 +578,7 @@ ves_array_set (MonoInvocation *frame) esize = mono_array_element_size (ac); ea = mono_array_addr_with_size (ao, esize, pos); - mt = frame->runtime_method->method->signature->params [ac->rank]; + mt = mono_method_signature (frame->runtime_method->method)->params [ac->rank]; stackval_to_data (mt, &sp [ac->rank], ea, FALSE); } @@ -622,7 +622,7 @@ ves_array_get (MonoInvocation *frame) esize = mono_array_element_size (ac); ea = mono_array_addr_with_size (ao, esize, pos); - mt = frame->runtime_method->method->signature->ret; + mt = mono_method_signature (frame->runtime_method->method)->ret; stackval_from_data (mt, frame->retval, ea, FALSE); } @@ -886,7 +886,7 @@ dump_args (MonoInvocation *inv) { GString *str = g_string_new (""); int i; - MonoMethodSignature *signature = inv->runtime_method->method->signature; + MonoMethodSignature *signature = mono_method_signature (inv->runtime_method->method); if (signature->param_count == 0) return g_string_free (str, FALSE); @@ -904,7 +904,7 @@ static char* dump_retval (MonoInvocation *inv) { GString *str = g_string_new (""); - MonoType *ret = inv->runtime_method->method->signature->ret; + MonoType *ret = mono_method_signature (inv->runtime_method->method)->ret; if (ret->type != MONO_TYPE_VOID) dump_stackval (str, inv->retval, ret); @@ -1071,7 +1071,7 @@ interp_mono_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoOb MonoInvocation frame; ThreadContext * volatile context = TlsGetValue (thread_context_id); MonoObject *retval = NULL; - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); MonoClass *klass = mono_class_from_mono_type (sig->ret); int i, type, isobject = 0; void *ret = NULL; @@ -1863,7 +1863,7 @@ ves_exec_method_with_context (MonoInvocation *frame, ThreadContext *context) MINT_IN_BREAK; } MINT_IN_CASE(MINT_CALLINT) - ves_pinvoke_method (frame, frame->runtime_method->method->signature, ((MonoMethodPInvoke*) frame->runtime_method->method)->addr, + ves_pinvoke_method (frame, mono_method_signature (frame->runtime_method->method), ((MonoMethodPInvoke*) frame->runtime_method->method)->addr, frame->runtime_method->method->string_ctor, context); if (frame->ex) { rtm = NULL; @@ -2577,7 +2577,7 @@ ves_exec_method_with_context (MonoInvocation *frame, ThreadContext *context) ip += 2; child_frame.runtime_method = rtm->data_items [token]; - csig = child_frame.runtime_method->method->signature; + csig = mono_method_signature (child_frame.runtime_method->method); newobj_class = child_frame.runtime_method->method->klass; /*if (profiling_classes) { guint count = GPOINTER_TO_UINT (g_hash_table_lookup (profiling_classes, newobj_class)); @@ -3525,7 +3525,8 @@ array_constructed: MINT_IN_CASE(MINT_MONO_RETOBJ) ++ip; sp--; - stackval_from_data (frame->runtime_method->method->signature->ret, frame->retval, sp->data.p, frame->runtime_method->method->signature->pinvoke); + stackval_from_data (mono_method_signature frame->runtime_method->method)->ret, frame->retval, sp->data.p, + mono_method_signature (frame->runtime_method->method)->pinvoke); if (sp > frame->stack) g_warning ("retobj: more values on stack: %d", sp-frame->stack); goto exit_frame; diff --git a/mono/interpreter/transform.c b/mono/interpreter/transform.c index 9630a24e5d5..1cf57bcabdb 100644 --- a/mono/interpreter/transform.c +++ b/mono/interpreter/transform.c @@ -436,7 +436,7 @@ load_arg(TransformData *td, int n) { int mt; MonoClass *klass = NULL; - if (n == 0 && td->method->signature->hasthis) { + if (n == 0 && mono_method_signature (td->method)->hasthis) { if (td->method->klass->valuetype) mt = MINT_TYPE_P; else { @@ -446,12 +446,12 @@ load_arg(TransformData *td, int n) ADD_CODE(td, MINT_LDTHIS); } else { MonoType *type; - n -= td->method->signature->hasthis; - type = td->method->signature->params [n]; + n -= mono_method_signature (td->method)->hasthis; + type = mono_method_signature (td->method)->params [n]; mt = mint_type (type); if (mt == MINT_TYPE_VT) { gint32 size; - if (td->method->signature->pinvoke) + if (mono_method_signature (td->method)->pinvoke) size = mono_class_native_size (type->data.klass, NULL); else size = mono_class_value_size (type->data.klass, NULL); @@ -475,16 +475,16 @@ store_arg(TransformData *td, int n) { int mt; CHECK_STACK (td, 1); - if (n == 0 && td->method->signature->hasthis) + if (n == 0 && mono_method_signature (td->method)->hasthis) ADD_CODE(td, MINT_STTHIS); else { MonoType *type; - n -= td->method->signature->hasthis; - type = td->method->signature->params [n]; + n -= mono_method_signature (td->method)->hasthis; + type = mono_method_signature (td->method)->params [n]; mt = mint_type (type); if (mt == MINT_TYPE_VT) { gint32 size; - if (td->method->signature->pinvoke) + if (mono_method_signature (td->method)->pinvoke) size = mono_class_native_size (type->data.klass, NULL); else size = mono_class_value_size (type->data.klass, NULL); @@ -504,11 +504,11 @@ store_arg(TransformData *td, int n) static void store_inarg(TransformData *td, int n) { - MonoType *type = td->method->signature->params [n]; + MonoType *type = mono_method_signature (td->method)->params [n]; int mt = mint_type (type); if (mt == MINT_TYPE_VT) { gint32 size; - if (td->method->signature->pinvoke) + if (mono_method_signature (td->method)->pinvoke) size = mono_class_native_size (type->data.klass, NULL); else size = mono_class_value_size (type->data.klass, NULL); @@ -612,7 +612,7 @@ static void generate(MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start) { MonoMethodHeader *header = mono_method_get_header (method); - MonoMethodSignature *signature = method->signature; + MonoMethodSignature *signature = mono_method_signature (method); MonoImage *image = method->klass->image; MonoDomain *domain = mono_domain_get (); MonoGenericContext *generic_context = NULL; @@ -629,7 +629,7 @@ generate(MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start) TransformData td; int generating_code = 1; - if (method->signature->is_inflated) + if (mono_method_signature (method)->is_inflated) generic_context = ((MonoMethodInflated *) method)->context; memset(&td, 0, sizeof(td)); @@ -971,7 +971,7 @@ generate(MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start) m = mono_get_method_full (image, token, NULL, generic_context); else m = (MonoMethod *)mono_method_get_wrapper_data (method, token); - csignature = m->signature; + csignature = mono_method_signature (m); if (m->klass == mono_defaults.string_class) { if (m->name [0] == 'g') { if (strcmp (m->name, "get_Chars") == 0) @@ -1718,7 +1718,7 @@ generate(MonoMethod *method, RuntimeMethod *rtm, unsigned char *is_bb_start) else m = mono_get_method_full (image, token, NULL, generic_context); - csignature = m->signature; + csignature = mono_method_signature (m); klass = m->klass; td.sp -= csignature->param_count; ADD_CODE(&td, MINT_NEWOBJ); @@ -2805,7 +2805,7 @@ mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *cont MonoMethod *method = runtime_method->method; MonoImage *image = method->klass->image; MonoMethodHeader *header = mono_method_get_header (method); - MonoMethodSignature *signature = method->signature; + MonoMethodSignature *signature = mono_method_signature (method); register const unsigned char *ip, *end; const MonoOpcode *opcode; MonoMethod *m; @@ -2839,7 +2839,7 @@ mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *cont mono_profiler_method_jit (method); /* sort of... */ - if (method->signature->is_inflated) + if (mono_method_signature (method)->is_inflated) generic_context = ((MonoMethodInflated *) method)->context; if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) { @@ -2853,12 +2853,12 @@ mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *cont /* assumes all internal calls with an array this are built in... */ if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL && - (!method->signature->hasthis || method->klass->rank == 0)) { + (! mono_method_signature (method)->hasthis || method->klass->rank == 0)) { runtime_method->code = g_malloc(sizeof(short)); runtime_method->code[0] = MINT_CALLINT; if (((MonoMethodPInvoke*) method)->addr == NULL) ((MonoMethodPInvoke*) method)->addr = mono_lookup_internal_call (method); - runtime_method->func = mono_arch_create_trampoline (method->signature, method->string_ctor); + runtime_method->func = mono_arch_create_trampoline (mono_method_signature (method), method->string_ctor); } else { const char *name = method->name; if (method->klass->parent == mono_defaults.multicastdelegate_class) { diff --git a/mono/metadata/ChangeLog b/mono/metadata/ChangeLog index fb580dbdecd..e36c7a9cfe2 100644 --- a/mono/metadata/ChangeLog +++ b/mono/metadata/ChangeLog @@ -1,3 +1,14 @@ +2005-01-29 Ben Maurer + + * loader.c (mono_method_signature): Make this method lazy + (mono_get_method_from_token): Don't computate the signature here. + + Doing this saves quite a bit of memory. I got 90 kb on starting up + monodoc. It should also save some disk reads on startup. + + * *: MonoMethod->signature might be NULL now. You *MUST* use + mono_method_signature. + 2005-01-29 Zoltan Varga * object.c (mono_runtime_get_main_args): Return an array from the diff --git a/mono/metadata/class.c b/mono/metadata/class.c index ccbc1e886fb..60e39467ed5 100644 --- a/mono/metadata/class.c +++ b/mono/metadata/class.c @@ -439,7 +439,7 @@ mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *conte (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) return method; - if (method->is_inflated || method->signature->is_inflated) { + if (method->is_inflated || mono_method_signature (method)->is_inflated) { MonoMethodInflated *imethod = (MonoMethodInflated *) method; context = inflate_generic_context (imethod->context, context); @@ -491,7 +491,7 @@ mono_get_inflated_method (MonoMethod *method) rklass = res->nmethod.method.klass = mono_class_from_mono_type (dtype); res->nmethod.method.signature = mono_class_inflate_generic_signature ( - method->klass->image, method->signature, imethod->context); + method->klass->image, mono_method_signature (method), imethod->context); return (MonoMethod *) res; } @@ -1102,7 +1102,7 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum) !(cm->flags & METHOD_ATTRIBUTE_NEW_SLOT)) continue; if (!strcmp(cm->name, im->name) && - mono_metadata_signature_equal (cm->signature, im->signature)) { + mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) { g_assert (io + l <= max_vtsize); vtable [io + l] = cm; } @@ -1132,7 +1132,7 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum) continue; if (!strcmp(cm->name, im->name) && - mono_metadata_signature_equal (cm->signature, im->signature)) { + mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) { g_assert (io + l <= max_vtsize); vtable [io + l] = cm; break; @@ -1176,7 +1176,7 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum) continue; if (((fqname && !strcmp (cm->name, fqname)) || !strcmp (cm->name, qname)) && - mono_metadata_signature_equal (cm->signature, im->signature)) { + mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (im))) { g_assert (io + l <= max_vtsize); vtable [io + l] = cm; break; @@ -1215,13 +1215,13 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum) g_print (" at slot %d: %s (%d) overrides %s (%d)\n", io+l, overrides [j*2+1]->name, overrides [j*2+1]->slot, overrides [j*2]->name, overrides [j*2]->slot); } - msig = mono_signature_get_desc (im->signature, FALSE); + msig = mono_signature_get_desc (mono_method_signature (im), FALSE); printf ("no implementation for interface method %s.%s::%s(%s) in class %s.%s\n", ic->name_space, ic->name, im->name, msig, class->name_space, class->name); g_free (msig); for (j = 0; j < class->method.count; ++j) { MonoMethod *cm = class->methods [j]; - msig = mono_signature_get_desc (cm->signature, FALSE); + msig = mono_signature_get_desc (mono_method_signature (cm), FALSE); printf ("METHOD %s(%s)\n", cm->name, msig); g_free (msig); @@ -1273,7 +1273,7 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum) if (!(m1->flags & METHOD_ATTRIBUTE_VIRTUAL)) continue; if (!strcmp(cm->name, m1->name) && - mono_metadata_signature_equal (cm->signature, m1->signature)) { + mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (m1))) { slot = k->methods [j]->slot; g_assert (cm->slot < max_vtsize); if (!override_map) @@ -1292,7 +1292,7 @@ mono_class_setup_vtable (MonoClass *class, MonoMethod **overrides, int onum) if (cm->slot < 0) cm->slot = cur_slot++; - if (!(cm->flags & METHOD_ATTRIBUTE_ABSTRACT) && !cm->signature->generic_param_count) + if (!(cm->flags & METHOD_ATTRIBUTE_ABSTRACT) && ! mono_method_signature (cm)->generic_param_count) vtable [cm->slot] = cm; } @@ -3901,7 +3901,7 @@ mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_c for (i = 0; i < klass->method.count; ++i) { if (klass->methods [i]->name[0] == name [0] && !strcmp (name, klass->methods [i]->name) && - (param_count == -1 || klass->methods [i]->signature->param_count == param_count)) { + (param_count == -1 || mono_method_signature (klass->methods [i])->param_count == param_count)) { res = klass->methods [i]; break; } diff --git a/mono/metadata/debug-helpers.c b/mono/metadata/debug-helpers.c index 2867e36c307..79e6a998b1b 100644 --- a/mono/metadata/debug-helpers.c +++ b/mono/metadata/debug-helpers.c @@ -261,9 +261,9 @@ mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method) return FALSE; if (!desc->args) return TRUE; - if (desc->num_args != method->signature->param_count) + if (desc->num_args != mono_method_signature (method)->param_count) return FALSE; - sig = mono_signature_get_desc (method->signature, desc->include_namespace); + sig = mono_signature_get_desc (mono_method_signature (method), desc->include_namespace); if (strcmp (sig, desc->args)) { g_free (sig); return FALSE; @@ -509,7 +509,7 @@ mono_method_full_name (MonoMethod *method, gboolean signature) const char *nspace = method->klass->name_space; if (signature) { - char *tmpsig = mono_signature_get_desc (method->signature, TRUE); + char *tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE); if (method->wrapper_type != MONO_WRAPPER_NONE) sprintf (wrapper, "(wrapper %s) ", wrapper_type_to_str (method->wrapper_type)); @@ -540,7 +540,7 @@ mono_find_method_by_name (MonoClass *klass, const char *name, int param_count) for (i = 0; i < klass->method.count; ++i) { if (klass->methods [i]->name[0] == name [0] && !strcmp (name, klass->methods [i]->name) && - klass->methods [i]->signature->param_count == param_count) { + mono_method_signature (klass->methods [i])->param_count == param_count) { res = klass->methods [i]; break; } diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index 82cffebe7dc..e7a331cf66c 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -1234,25 +1234,27 @@ static void ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info) { MonoDomain *domain = mono_domain_get (); - + MonoMethodSignature* sig; MONO_ARCH_SAVE_REGS; if (method->is_inflated) method = mono_get_inflated_method (method); + sig = mono_method_signature (method); + info->parent = mono_type_get_object (domain, &method->klass->byval_arg); - info->ret = mono_type_get_object (domain, method->signature->ret); + info->ret = mono_type_get_object (domain, sig->ret); info->attrs = method->flags; info->implattrs = method->iflags; - if (method->signature->call_convention == MONO_CALL_DEFAULT) + if (sig->call_convention == MONO_CALL_DEFAULT) info->callconv = 1; else { - if (method->signature->call_convention == MONO_CALL_VARARG) + if (sig->call_convention == MONO_CALL_VARARG) info->callconv = 2; else info->callconv = 0; } - info->callconv |= (method->signature->hasthis << 5) | (method->signature->explicit_this << 6); + info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6); } static MonoArray* @@ -2212,7 +2214,7 @@ ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method) MONO_ARCH_SAVE_REGS; if (!method->method->is_inflated) { - if (method->method->signature->generic_param_count) + if (mono_method_signature (method->method)->generic_param_count) return method; return NULL; @@ -2235,7 +2237,7 @@ ves_icall_MonoMethod_get_HasGenericParameters (MonoReflectionMethod *method) (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) return FALSE; - return method->method->signature->generic_param_count != 0; + return mono_method_signature (method->method)->generic_param_count != 0; } static gboolean @@ -2259,7 +2261,7 @@ ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) return FALSE; - return method->method->signature->generic_param_count != 0; + return mono_method_signature (method->method)->generic_param_count != 0; } static MonoArray* @@ -2296,7 +2298,7 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method) } mn = (MonoMethodNormal *) method->method; - count = method->method->signature->generic_param_count; + count = mono_method_signature (method->method)->generic_param_count; res = mono_array_new (domain, mono_defaults.monotype_class, count); for (i = 0; i < count; i++) { @@ -2335,7 +2337,7 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoAr mono_raise_exception (mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetException")); pcount = params? mono_array_length (params): 0; - if (pcount != m->signature->param_count) + if (pcount != mono_method_signature (m)->param_count) mono_raise_exception (mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException")); if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor")) @@ -2370,7 +2372,7 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoA { MonoDomain *domain = mono_object_domain (method); MonoMethod *m = method->method; - MonoMethodSignature *sig = m->signature; + MonoMethodSignature *sig = mono_method_signature (m); MonoArray *out_args; MonoObject *result; int i, j, outarg_count = 0; @@ -6727,7 +6729,7 @@ mono_lookup_internal_call (MonoMethod *method) sigstart = mname + typelen + 2 + mlen; *sigstart = 0; - tmpsig = mono_signature_get_desc (method->signature, TRUE); + tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE); siglen = strlen (tmpsig); if (typelen + mlen + siglen + 6 > sizeof (mname)) return NULL; diff --git a/mono/metadata/loader.c b/mono/metadata/loader.c index ed8f02675df..4119e5e5c69 100644 --- a/mono/metadata/loader.c +++ b/mono/metadata/loader.c @@ -207,10 +207,10 @@ find_method (MonoClass *klass, MonoClass *ic, const char* name, MonoMethodSignat continue; if (sig->call_convention == MONO_CALL_VARARG) { - if (mono_metadata_signature_vararg_match (sig, m->signature)) + if (mono_metadata_signature_vararg_match (sig, mono_method_signature (m))) return m; } else { - if (mono_metadata_signature_equal (sig, m->signature)) + if (mono_metadata_signature_equal (sig, mono_method_signature (m))) return m; } } @@ -238,23 +238,23 @@ mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 to /* !table is for wrappers: we should really assign their own token to them */ if (!table || table == MONO_TABLE_METHOD) - return method->signature; + return mono_method_signature (method); if (table == MONO_TABLE_METHODSPEC) { g_assert (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) && !(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && - method->signature); + mono_method_signature (method)); g_assert (method->is_inflated); - return method->signature; + return mono_method_signature (method); } if (method->klass->generic_class) - return method->signature; + return mono_method_signature (method); if (image->dynamic) /* FIXME: This might be incorrect for vararg methods */ - return method->signature; + return mono_method_signature (method); if (!(sig = g_hash_table_lookup (image->memberref_signatures, GUINT_TO_POINTER (token)))) { mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE); @@ -769,12 +769,12 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char /* Try the stdcall mangled name */ if (!piinfo->addr) { /* FIX: Compute this correctly */ - mangled_name = g_strdup_printf ("%s@%d", import, method->signature->param_count * sizeof (gpointer)); + mangled_name = g_strdup_printf ("%s@%d", import, mono_method_signature (method)->param_count * sizeof (gpointer)); g_module_symbol (gmodule, mangled_name, &piinfo->addr); g_free (mangled_name); } if (!piinfo->addr) { - mangled_name = g_strdup_printf ("_%s@%d", import, method->signature->param_count * sizeof (gpointer)); + mangled_name = g_strdup_printf ("_%s@%d", import, mono_method_signature (method)->param_count * sizeof (gpointer)); g_module_symbol (gmodule, mangled_name, &piinfo->addr); g_free (mangled_name); } @@ -851,8 +851,12 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, if (!sig) /* already taken from the methodref */ sig = mono_metadata_blob_heap (image, cols [4]); size = mono_metadata_decode_blob_size (sig, &sig); - result->signature = mono_metadata_parse_method_signature_full ( - image, (MonoGenericContext *) container, idx, sig, NULL); + + /* there are generic params, or a container. FIXME: be lazy here for generics*/ + if (* sig & 0x10 || container) + result->signature = mono_metadata_parse_method_signature_full ( + image, (MonoGenericContext *) container, idx, sig, NULL); + if (!result->klass) { guint32 type = mono_metadata_typedef_from_method (image, token); @@ -862,42 +866,14 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, if (cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) { if (result->klass == mono_defaults.string_class && !strcmp (result->name, ".ctor")) result->string_ctor = 1; - - result->signature->pinvoke = 1; } else if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (!(cols [1] & METHOD_IMPL_ATTRIBUTE_NATIVE))) { MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)result; MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP]; - MonoCallConvention conv = 0; - - result->signature->pinvoke = 1; + piinfo->implmap_idx = mono_metadata_implmap_from_method (image, idx - 1); piinfo->piflags = mono_metadata_decode_row_col (im, piinfo->implmap_idx - 1, MONO_IMPLMAP_FLAGS); - - switch (piinfo->piflags & PINVOKE_ATTRIBUTE_CALL_CONV_MASK) { - case PINVOKE_ATTRIBUTE_CALL_CONV_WINAPI: - conv = MONO_CALL_DEFAULT; - break; - case PINVOKE_ATTRIBUTE_CALL_CONV_CDECL: - conv = MONO_CALL_C; - break; - case PINVOKE_ATTRIBUTE_CALL_CONV_STDCALL: - conv = MONO_CALL_STDCALL; - break; - case PINVOKE_ATTRIBUTE_CALL_CONV_THISCALL: - conv = MONO_CALL_THISCALL; - break; - case PINVOKE_ATTRIBUTE_CALL_CONV_FASTCALL: - conv = MONO_CALL_FASTCALL; - break; - case PINVOKE_ATTRIBUTE_CALL_CONV_GENERIC: - case PINVOKE_ATTRIBUTE_CALL_CONV_GENERICINST: - default: - g_warning ("unsupported calling convention"); - g_assert_not_reached (); - } - result->signature->call_convention = conv; } else { - if (result->signature->generic_param_count) { + if (result->signature && result->signature->generic_param_count) { MonoMethodSignature *sig = result->signature; for (i = 0; i < sig->generic_param_count; i++) { @@ -992,7 +968,7 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra if (constrained_class->generic_class) gclass = constrained_class->generic_class; - result = find_method (constrained_class, ic, method->name, method->signature); + result = find_method (constrained_class, ic, method->name, mono_method_signature (method)); if (!result) g_warning ("Missing method %s in assembly %s token %x", method->name, image->name, token); @@ -1007,7 +983,8 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra void mono_free_method (MonoMethod *method) { - mono_metadata_free_method_signature (method->signature); + if (method->signature) + mono_metadata_free_method_signature (method->signature); if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && ((MonoMethodNormal *)method)->header) { mono_metadata_free_mh (((MonoMethodNormal *)method)->header); } @@ -1023,9 +1000,9 @@ mono_method_get_param_names (MonoMethod *method, const char **names) MonoTableInfo *methodt; MonoTableInfo *paramt; - if (!method->signature->param_count) + if (!mono_method_signature (method)->param_count) return; - for (i = 0; i < method->signature->param_count; ++i) + for (i = 0; i < mono_method_signature (method)->param_count; ++i) names [i] = ""; if (klass->generic_class) /* copy the names later */ @@ -1038,7 +1015,7 @@ mono_method_get_param_names (MonoMethod *method, const char **names) g_hash_table_lookup ( ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method); if (method_aux && method_aux->param_names) { - for (i = 0; i < method->signature->param_count; ++i) + for (i = 0; i < mono_method_signature (method)->param_count; ++i) if (method_aux->param_names [i + 1]) names [i] = method_aux->param_names [i + 1]; } @@ -1104,7 +1081,7 @@ mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs) MonoTableInfo *methodt; MonoTableInfo *paramt; - for (i = 0; i < method->signature->param_count + 1; ++i) + for (i = 0; i < mono_method_signature (method)->param_count + 1; ++i) mspecs [i] = NULL; if (method->klass->image->dynamic) { @@ -1113,7 +1090,7 @@ mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs) ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method); if (method_aux && method_aux->param_marshall) { MonoMarshalSpec **dyn_specs = method_aux->param_marshall; - for (i = 0; i < method->signature->param_count + 1; ++i) + for (i = 0; i < mono_method_signature (method)->param_count + 1; ++i) if (dyn_specs [i]) { mspecs [i] = g_new0 (MonoMarshalSpec, 1); memcpy (mspecs [i], dyn_specs [i], sizeof (MonoMarshalSpec)); @@ -1168,7 +1145,7 @@ mono_method_has_marshal_info (MonoMethod *method) ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method); MonoMarshalSpec **dyn_specs = method_aux->param_marshall; if (dyn_specs) { - for (i = 0; i < method->signature->param_count + 1; ++i) + for (i = 0; i < mono_method_signature (method)->param_count + 1; ++i) if (dyn_specs [i]) return TRUE; } @@ -1272,9 +1249,66 @@ mono_loader_unlock (void) } MonoMethodSignature* -mono_method_signature (MonoMethod *method) +mono_method_signature (MonoMethod *m) { - return method->signature; + int idx; + int size; + MonoImage* img; + gpointer sig; + + if (m->signature) + return m->signature; + + mono_loader_lock (); + + if (m->signature) { + mono_loader_unlock (); + return m->signature; + } + + g_assert (mono_metadata_token_table (m->token) == MONO_TABLE_METHOD); + idx = mono_metadata_token_index (m->token); + img = m->klass->image; + + sig = mono_metadata_blob_heap (img, mono_metadata_decode_row_col (&img->tables [MONO_TABLE_METHOD], idx - 1, MONO_METHOD_SIGNATURE)); + size = mono_metadata_decode_blob_size (sig, &sig); + + m->signature = mono_metadata_parse_method_signature_full (img, NULL, idx, sig, NULL); + + if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) + m->signature->pinvoke = 1; + else if ((m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (!(m->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE))) { + MonoCallConvention conv = 0; + MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)m; + m->signature->pinvoke = 1; + + switch (piinfo->piflags & PINVOKE_ATTRIBUTE_CALL_CONV_MASK) { + case PINVOKE_ATTRIBUTE_CALL_CONV_WINAPI: + conv = MONO_CALL_DEFAULT; + break; + case PINVOKE_ATTRIBUTE_CALL_CONV_CDECL: + conv = MONO_CALL_C; + break; + case PINVOKE_ATTRIBUTE_CALL_CONV_STDCALL: + conv = MONO_CALL_STDCALL; + break; + case PINVOKE_ATTRIBUTE_CALL_CONV_THISCALL: + conv = MONO_CALL_THISCALL; + break; + case PINVOKE_ATTRIBUTE_CALL_CONV_FASTCALL: + conv = MONO_CALL_FASTCALL; + break; + case PINVOKE_ATTRIBUTE_CALL_CONV_GENERIC: + case PINVOKE_ATTRIBUTE_CALL_CONV_GENERICINST: + default: + g_warning ("unsupported calling convention"); + g_assert_not_reached (); + } + m->signature->call_convention = conv; + } + + mono_loader_unlock (); + return m->signature; } const char* diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c index b0e68344f2d..6a950d343ad 100644 --- a/mono/metadata/marshal.c +++ b/mono/metadata/marshal.c @@ -217,14 +217,14 @@ mono_delegate_to_ftnptr (MonoDelegate *delegate) g_assert (klass->delegate); method = delegate->method_info->method; - invoke = mono_class_get_method_from_name (klass, "Invoke", method->signature->param_count); + invoke = mono_class_get_method_from_name (klass, "Invoke", mono_method_signature (method)->param_count); - mspecs = g_new (MonoMarshalSpec*, invoke->signature->param_count + 1); + mspecs = g_new (MonoMarshalSpec*, mono_method_signature (invoke)->param_count + 1); mono_method_get_marshal_info (invoke, mspecs); wrapper = mono_marshal_get_managed_wrapper (method, delegate->target, mspecs); - for (i = invoke->signature->param_count; i >= 0; i--) + for (i = mono_method_signature (invoke)->param_count; i >= 0; i--) if (mspecs [i]) mono_metadata_free_marshal_spec (mspecs [i]); g_free (mspecs); @@ -871,7 +871,7 @@ mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char int i; mono_class_init (mme); for (i = 0; i < mme->method.count; ++i) { - if (strcmp (mme->methods [i]->name, ".ctor") == 0 && mme->methods [i]->signature->param_count == 0) { + if (strcmp (mme->methods [i]->name, ".ctor") == 0 && mono_method_signature (mme->methods [i])->param_count == 0) { ctor = mme->methods [i]; break; } @@ -1804,7 +1804,7 @@ mono_marshal_get_delegate_begin_invoke (MonoMethod *method) g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class && !strcmp (method->name, "BeginInvoke")); - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); cache = method->klass->image->delegate_begin_invoke_cache; if ((res = mono_marshal_find_in_cache (cache, sig))) @@ -1870,7 +1870,7 @@ mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params) g_assert (method != NULL); - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); msg = mono_method_call_message_new (method, params, NULL, NULL, NULL); @@ -2009,7 +2009,7 @@ mono_marshal_get_delegate_end_invoke (MonoMethod *method) g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class && !strcmp (method->name, "EndInvoke")); - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); cache = method->klass->image->delegate_end_invoke_cache; if ((res = mono_marshal_find_in_cache (cache, sig))) @@ -2071,7 +2071,7 @@ mono_remoting_wrapper (MonoMethod *method, gpointer *params) if (this->remote_class->proxy_class->contextbound && this->rp->context == (MonoObject *) mono_context_get ()) { int i; - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); int count = sig->param_count; gpointer* mparams = (gpointer*) alloca(count*sizeof(gpointer)); @@ -2116,7 +2116,7 @@ mono_marshal_get_remoting_invoke (MonoMethod *method) if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE || method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE) return method; - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); /* we cant remote methods without this pointer */ if (!sig->hasthis) @@ -2416,7 +2416,7 @@ mono_marshal_get_xappdomain_dispatch (MonoMethod *method, int *marshal_types, in if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_XDOMAIN_DISPATCH))) return res; - sig = method->signature; + sig = mono_method_signature (method); copy_return = (sig->ret->type != MONO_TYPE_VOID && ret_marshal_type != MONO_MARSHAL_SERIALIZE); j = 0; @@ -2692,7 +2692,7 @@ mono_marshal_get_xappdomain_invoke (MonoMethod *method) return method; /* we cant remote methods without this pointer */ - if (!method->signature->hasthis) + if (!mono_method_signature (method)->hasthis) return method; if (!mono_marshal_supports_fast_xdomain (method)) @@ -2703,7 +2703,7 @@ mono_marshal_get_xappdomain_invoke (MonoMethod *method) if ((res = mono_marshal_remoting_find_in_cache (method, MONO_WRAPPER_XDOMAIN_INVOKE))) return res; - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); if (sig_context_set == NULL) { sig_context_set = mono_metadata_signature_alloc (mono_defaults.corlib, 1); @@ -2878,7 +2878,7 @@ mono_marshal_get_xappdomain_invoke (MonoMethod *method) xdomain_method = mono_marshal_get_xappdomain_dispatch (method, marshal_types, complex_count, complex_out_count, ret_marshal_type); mono_marshal_emit_load_domain_method (mb, xdomain_method); - mono_mb_emit_calli (mb, xdomain_method->signature); + mono_mb_emit_calli (mb, mono_method_signature (xdomain_method)); if (copy_return) mono_mb_emit_stloc (mb, loc_return); @@ -3043,7 +3043,7 @@ mono_marshal_get_remoting_invoke_with_check (MonoMethod *method) if (method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) return method; - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); /* we cant remote methods without this pointer */ g_assert (sig->hasthis); @@ -3065,19 +3065,19 @@ mono_marshal_get_remoting_invoke_with_check (MonoMethod *method) /* wrapper for cross app domain calls */ native = mono_marshal_get_xappdomain_invoke (method); - mono_mb_emit_managed_call (mb, native, native->signature); + mono_mb_emit_managed_call (mb, native, mono_method_signature (native)); mono_mb_emit_byte (mb, CEE_RET); mono_mb_patch_addr (mb, pos_rem, mb->pos - (pos_rem + 4)); } /* wrapper for normal remote calls */ native = mono_marshal_get_remoting_invoke (method); - mono_mb_emit_managed_call (mb, native, native->signature); + mono_mb_emit_managed_call (mb, native, mono_method_signature (native)); mono_mb_emit_byte (mb, CEE_RET); /* not a proxy */ mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4)); - mono_mb_emit_managed_call (mb, method, method->signature); + mono_mb_emit_managed_call (mb, method, mono_method_signature (method)); mono_mb_emit_byte (mb, CEE_RET); res = mono_remoting_mb_create_and_cache (method, mb, sig, sig->param_count + 16); @@ -3103,7 +3103,7 @@ mono_marshal_get_delegate_invoke (MonoMethod *method) g_assert (method && method->klass->parent == mono_defaults.multicastdelegate_class && !strcmp (method->name, "Invoke")); - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); cache = method->klass->image->delegate_invoke_cache; if ((res = mono_marshal_find_in_cache (cache, sig))) @@ -3147,7 +3147,7 @@ mono_marshal_get_delegate_invoke (MonoMethod *method) mono_mb_emit_ldloc (mb, 0); for (i = 0; i < sig->param_count; i++) mono_mb_emit_ldarg (mb, i + 1); - mono_mb_emit_managed_call (mb, method, method->signature); + mono_mb_emit_managed_call (mb, method, mono_method_signature (method)); if (sig->ret->type != MONO_TYPE_VOID) mono_mb_emit_byte (mb, CEE_POP); @@ -3266,13 +3266,13 @@ mono_marshal_get_runtime_invoke (MonoMethod *method) callsig = NULL; for (item = strsig_list; item; item = item->next) { cs = item->data; - if (mono_metadata_signature_equal (method->signature, cs->ctor->signature)) { + if (mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cs->ctor))) { callsig = cs->sig; break; } } if (!callsig) { - callsig = mono_metadata_signature_dup (method->signature); + callsig = mono_metadata_signature_dup (mono_method_signature (method)); callsig->ret = &mono_defaults.string_class->byval_arg; cs = g_new (CtorSigPair, 1); cs->sig = callsig; @@ -3280,15 +3280,15 @@ mono_marshal_get_runtime_invoke (MonoMethod *method) strsig_list = g_slist_prepend (strsig_list, cs); } } else { - if (method->klass->valuetype && method->signature->hasthis) { + if (method->klass->valuetype && mono_method_signature (method)->hasthis) { /* * Valuetype methods receive a managed pointer as the this argument. * Create a new signature to reflect this. */ - callsig = signature_dup_add_this (method->signature, method->klass); + callsig = signature_dup_add_this (mono_method_signature (method), method->klass); } else - callsig = method->signature; + callsig = mono_method_signature (method); } cache = method->klass->image->runtime_invoke_cache; @@ -3315,12 +3315,12 @@ mono_marshal_get_runtime_invoke (MonoMethod *method) string_dummy = mono_string_new_wrapper ("dummy"); } - sig = method->signature; + sig = mono_method_signature (method); csig = mono_metadata_signature_alloc (method->klass->image, 4); csig->ret = &mono_defaults.object_class->byval_arg; - if (method->klass->valuetype && method->signature->hasthis) + if (method->klass->valuetype && mono_method_signature (method)->hasthis) csig->params [0] = callsig->params [0]; else csig->params [0] = &mono_defaults.object_class->byval_arg; @@ -3581,7 +3581,7 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars int retobj_var = 0; g_assert (method != NULL); - g_assert (!method->signature->pinvoke); + g_assert (!mono_method_signature (method)->pinvoke); cache = method->klass->image->managed_wrapper_cache; if (!this && (res = mono_marshal_find_in_cache (cache, method))) @@ -3595,7 +3595,7 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars alloc_sig->pinvoke = 1; } - sig = method->signature; + sig = mono_method_signature (method); mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED); @@ -5647,13 +5647,13 @@ mono_marshal_get_native_wrapper (MonoMethod *method) const char *exc_arg = NULL; g_assert (method != NULL); - g_assert (method->signature->pinvoke); + g_assert (mono_method_signature (method)->pinvoke); cache = method->klass->image->native_wrapper_cache; if ((res = mono_marshal_find_in_cache (cache, method))) return res; - sig = method->signature; + sig = mono_method_signature (method); if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) @@ -6303,7 +6303,7 @@ mono_marshal_get_struct_to_ptr (MonoClass *klass) mono_mb_emit_byte (mb, CEE_RET); - res = mono_mb_create_method (mb, stoptr->signature, 0); + res = mono_mb_create_method (mb, mono_method_signature (stoptr), 0); mono_mb_free (mb); klass->marshal_info->str_to_ptr = res; @@ -6364,7 +6364,7 @@ mono_marshal_get_ptr_to_struct (MonoClass *klass) mono_mb_emit_byte (mb, CEE_RET); - res = mono_mb_create_method (mb, ptostr->signature, 0); + res = mono_mb_create_method (mb, mono_method_signature (ptostr), 0); mono_mb_free (mb); klass->marshal_info->ptr_to_str = res; @@ -6397,7 +6397,7 @@ mono_marshal_get_synchronized_wrapper (MonoMethod *method) if ((res = mono_marshal_find_in_cache (cache, method))) return res; - sig = signature_no_pinvoke (method->signature); + sig = signature_no_pinvoke (mono_method_signature (method)); mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_SYNCHRONIZED); @@ -6460,7 +6460,7 @@ mono_marshal_get_synchronized_wrapper (MonoMethod *method) mono_mb_emit_byte (mb, CEE_PREFIX1); mono_mb_emit_byte (mb, CEE_LDFTN); mono_mb_emit_i4 (mb, mono_mb_add_data (mb, method)); - mono_mb_emit_calli (mb, method->signature); + mono_mb_emit_calli (mb, mono_method_signature (method)); if (!MONO_TYPE_IS_VOID (sig->ret)) mono_mb_emit_stloc (mb, ret_local); @@ -6503,7 +6503,7 @@ mono_marshal_get_synchronized_wrapper (MonoMethod *method) MonoMethod * mono_marshal_get_unbox_wrapper (MonoMethod *method) { - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); int i; MonoMethodBuilder *mb; MonoMethod *res; diff --git a/mono/metadata/mono-debug-debugger.c b/mono/metadata/mono-debug-debugger.c index 46b433468bd..3f168cce435 100644 --- a/mono/metadata/mono-debug-debugger.c +++ b/mono/metadata/mono-debug-debugger.c @@ -586,7 +586,7 @@ mono_debugger_add_method (MonoDebuggerSymbolFile *symfile, MonoDebugMethodInfo * for (i = 0; i < jit->num_params; i++) { *var_table++ = jit->params [i]; - *type_table++ = write_type (mono_debugger_symbol_table, minfo->method->signature->params [i]); + *type_table++ = write_type (mono_debugger_symbol_table, mono_method_signature (minfo->method)->params [i]); } if (jit->num_locals < read32(&(minfo->entry->_num_locals))) { @@ -879,7 +879,7 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl if (!strcmp (method->name, ".ctor")) { ++num_ctors; - num_ctor_params += method->signature->param_count; + num_ctor_params += mono_method_signature (method)->param_count; g_ptr_array_add (ctors, method); continue; } @@ -895,11 +895,11 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl if (method->flags & METHOD_ATTRIBUTE_STATIC) { ++num_static_methods; - num_static_params += method->signature->param_count; + num_static_params += mono_method_signature (method)->param_count; g_ptr_array_add (static_methods, method); } else { ++num_methods; - num_params += method->signature->param_count; + num_params += mono_method_signature (method)->param_count; g_ptr_array_add (methods, method); } } @@ -995,7 +995,7 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl continue; if (klass->properties [i].get) - WRITE_UINT32 (ptr, write_type (table, klass->properties [i].get->signature->ret)); + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (klass->properties [i].get)->ret)); else WRITE_UINT32 (ptr, 0); WRITE_POINTER (ptr, klass->properties [i].get); @@ -1007,7 +1007,7 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl continue; if (klass->events [i].add) { - WRITE_UINT32 (ptr, write_type (table, klass->events [i].add->signature->params[0])); + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (klass->events [i].add)->params[0])); } else { g_warning ("event add method not defined"); @@ -1023,13 +1023,13 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl int j; WRITE_POINTER (ptr, method); - if ((method->signature->ret) && (method->signature->ret->type != MONO_TYPE_VOID)) - WRITE_UINT32 (ptr, write_type (table, method->signature->ret)); + if ((mono_method_signature (method)->ret) && (mono_method_signature (method)->ret->type != MONO_TYPE_VOID)) + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (method)->ret)); else WRITE_UINT32 (ptr, 0); - WRITE_UINT32 (ptr, method->signature->param_count); - for (j = 0; j < method->signature->param_count; j++) - WRITE_UINT32 (ptr, write_type (table, method->signature->params [j])); + WRITE_UINT32 (ptr, mono_method_signature (method)->param_count); + for (j = 0; j < mono_method_signature (method)->param_count; j++) + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (method)->params [j])); } g_ptr_array_free (methods, FALSE); @@ -1047,7 +1047,7 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl continue; if (klass->properties [i].get) - WRITE_UINT32 (ptr, write_type (table, klass->properties [i].get->signature->ret)); + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (klass->properties [i].get)->ret)); else WRITE_UINT32 (ptr, 0); WRITE_POINTER (ptr, klass->properties [i].get); @@ -1059,7 +1059,7 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl continue; if (klass->events [i].add) { - WRITE_UINT32 (ptr, write_type (table, klass->events [i].add->signature->params[0])); + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (klass->events [i].add)->params[0])); } else { g_warning ("event add method not defined"); @@ -1075,13 +1075,13 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl int j; WRITE_POINTER (ptr, method); - if ((method->signature->ret) && (method->signature->ret->type != MONO_TYPE_VOID)) - WRITE_UINT32 (ptr, write_type (table, method->signature->ret)); + if ((mono_method_signature (method)->ret) && (mono_method_signature (method)->ret->type != MONO_TYPE_VOID)) + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (method)->ret)); else WRITE_UINT32 (ptr, 0); - WRITE_UINT32 (ptr, method->signature->param_count); - for (j = 0; j < method->signature->param_count; j++) - WRITE_UINT32 (ptr, write_type (table, method->signature->params [j])); + WRITE_UINT32 (ptr, mono_method_signature (method)->param_count); + for (j = 0; j < mono_method_signature (method)->param_count; j++) + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (method)->params [j])); } g_ptr_array_free (static_methods, FALSE); @@ -1092,9 +1092,9 @@ do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerCl WRITE_POINTER (ptr, ctor); WRITE_UINT32 (ptr, 0); - WRITE_UINT32 (ptr, ctor->signature->param_count); - for (j = 0; j < ctor->signature->param_count; j++) - WRITE_UINT32 (ptr, write_type (table, ctor->signature->params [j])); + WRITE_UINT32 (ptr, mono_method_signature (ctor)->param_count); + for (j = 0; j < mono_method_signature (ctor)->param_count; j++) + WRITE_UINT32 (ptr, write_type (table, mono_method_signature (ctor)->params [j])); } g_ptr_array_free (ctors, FALSE); @@ -1476,7 +1476,7 @@ get_exception_message (MonoObject *exc) for (i = 0; i < klass->method.count; ++i) { method = klass->methods [i]; if (!strcmp ("ToString", method->name) && - method->signature->param_count == 0 && + mono_method_signature (method)->param_count == 0 && method->flags & METHOD_ATTRIBUTE_VIRTUAL && method->flags & METHOD_ATTRIBUTE_PUBLIC) { break; diff --git a/mono/metadata/monodiet.c b/mono/metadata/monodiet.c index 6f6646081d1..b38a7ed1089 100644 --- a/mono/metadata/monodiet.c +++ b/mono/metadata/monodiet.c @@ -106,8 +106,8 @@ add_types_from_method (MonoMethod *method) { cattrs = mono_custom_attrs_from_method (method); handle_cattrs (cattrs); add_type (method->klass); - add_types_from_signature (method->signature); - for (i = 0; i < method->signature->param_count + 1; ++i) { + add_types_from_signature (mono_method_signature (method)); + for (i = 0; i < mono_method_signature (method)->param_count + 1; ++i) { cattrs = mono_custom_attrs_from_param (method, i); handle_cattrs (cattrs); } diff --git a/mono/metadata/object.c b/mono/metadata/object.c index b86a1c8523f..38e82c01dca 100644 --- a/mono/metadata/object.c +++ b/mono/metadata/object.c @@ -56,7 +56,7 @@ mono_runtime_object_init (MonoObject *this) for (i = 0; i < klass->method.count; ++i) { if (!strcmp (".ctor", klass->methods [i]->name) && - klass->methods [i]->signature->param_count == 0) { + mono_method_signature (klass->methods [i])->param_count == 0) { method = klass->methods [i]; break; } @@ -746,7 +746,7 @@ mono_class_vtable (MonoDomain *domain, MonoClass *class) MonoMethod *cm; if ((cm = class->vtable [i])) { - if (cm->signature->generic_param_count) + if (mono_method_signature (cm)->generic_param_count) vt->vtable [i] = cm; else vt->vtable [i] = arch_create_jit_trampoline (cm); @@ -1631,7 +1631,7 @@ mono_runtime_run_main (MonoMethod *method, int argc, char* argv[], } argc--; argv++; - if (method->signature->param_count) { + if (mono_method_signature (method)->param_count) { args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, argc); for (i = 0; i < argc; ++i) { /* The encodings should all work, given that @@ -1674,7 +1674,7 @@ create_unhandled_exception_eventargs (MonoObject *exc) for (i = 0; i < klass->method.count; ++i) { method = klass->methods [i]; if (!strcmp (".ctor", method->name) && - method->signature->param_count == 2 && + mono_method_signature (method)->param_count == 2 && method->flags & METHOD_ATTRIBUTE_PUBLIC) break; method = NULL; @@ -1793,7 +1793,7 @@ mono_runtime_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc) } /* FIXME: check signature of method */ - if (method->signature->ret->type == MONO_TYPE_I4) { + if (mono_method_signature (method)->ret->type == MONO_TYPE_I4) { MonoObject *res; res = mono_runtime_invoke (method, NULL, pa, exc); if (!exc || !*exc) @@ -1873,7 +1873,7 @@ MonoObject* mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params, MonoObject **exc) { - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); gpointer *pa = NULL; int i; @@ -2028,7 +2028,7 @@ mono_object_new_specific (MonoVTable *vtable) for (i = 0; i < klass->method.count; ++i) { if (!strcmp ("CreateProxyForType", klass->methods [i]->name) && - klass->methods [i]->signature->param_count == 1) { + mono_method_signature (klass->methods [i])->param_count == 1) { im = klass->methods [i]; break; } @@ -3063,7 +3063,7 @@ mono_message_init (MonoDomain *domain, MonoReflectionMethod *method, MonoArray *out_args) { - MonoMethodSignature *sig = method->method->signature; + MonoMethodSignature *sig = mono_method_signature (method->method); MonoString *name; int i, j; char **names; @@ -3135,7 +3135,7 @@ mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, for (i = 0; i < klass->method.count; ++i) { if (!strcmp ("PrivateInvoke", klass->methods [i]->name) && - klass->methods [i]->signature->param_count == 4) { + mono_method_signature (klass->methods [i])->param_count == 4) { im = klass->methods [i]; break; } @@ -3175,7 +3175,7 @@ mono_message_invoke (MonoObject *target, MonoMethodMessage *msg, domain = mono_domain_get (); method = msg->method->method; - sig = method->signature; + sig = mono_method_signature (method); for (i = 0; i < sig->param_count; i++) { if (sig->params [i]->byref) @@ -3222,7 +3222,7 @@ mono_print_unhandled_exception (MonoObject *exc) for (i = 0; i < klass->method.count; ++i) { method = klass->methods [i]; if (!strcmp ("ToString", method->name) && - method->signature->param_count == 0 && + mono_method_signature (method)->param_count == 0 && method->flags & METHOD_ATTRIBUTE_VIRTUAL && method->flags & METHOD_ATTRIBUTE_PUBLIC) { break; @@ -3286,7 +3286,7 @@ mono_delegate_ctor (MonoObject *this, MonoObject *target, gpointer addr) method = mono_marshal_get_remoting_invoke (method); delegate->method_ptr = mono_compile_method (method); delegate->target = target; - } else if (method->signature->hasthis && method->klass->valuetype) { + } else if (mono_method_signature (method)->hasthis && method->klass->valuetype) { method = mono_marshal_get_unbox_wrapper (method); delegate->method_ptr = mono_compile_method (method); delegate->target = target; @@ -3311,7 +3311,7 @@ mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod * MonoDelegate **cb, MonoObject **state) { MonoDomain *domain = mono_domain_get (); - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); MonoMethodMessage *msg; int i, count, type; @@ -3363,7 +3363,7 @@ mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod * void mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args) { - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); int i, j, type, size; for (i = 0, j = 0; i < sig->param_count; i++) { MonoType *pt = sig->params [i]; diff --git a/mono/metadata/profiler.c b/mono/metadata/profiler.c index f051b1f9626..2846e885ae0 100644 --- a/mono/metadata/profiler.c +++ b/mono/metadata/profiler.c @@ -703,7 +703,7 @@ method_get_name (MonoMethod* method) { char *sig, *res; - sig = mono_signature_get_desc (method->signature, FALSE); + sig = mono_signature_get_desc (mono_method_signature (method), FALSE); res = g_strdup_printf ("%s.%s::%s(%s)", method->klass->name_space, method->klass->name, method->name, sig); g_free (sig); diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c index 85803595f9e..3531b2cfe6b 100644 --- a/mono/metadata/reflection.c +++ b/mono/metadata/reflection.c @@ -2318,7 +2318,7 @@ mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method) /* * A methodref signature can't contain an unmanaged calling convention. */ - sig = mono_metadata_signature_dup (method->signature); + sig = mono_metadata_signature_dup (mono_method_signature (method)); if ((sig->call_convention != MONO_CALL_DEFAULT) && (sig->call_convention != MONO_CALL_VARARG)) sig->call_convention = MONO_CALL_DEFAULT; token = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, @@ -2454,10 +2454,10 @@ method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method) imethod = (MonoMethodInflated *) method; declaring = imethod->declaring; - sig = method_encode_signature (assembly, declaring->signature); + sig = method_encode_signature (assembly, mono_method_signature (declaring)); mtoken = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, declaring->name, sig); - if (!declaring->signature->generic_param_count) + if (!mono_method_signature (declaring)->generic_param_count) return mtoken; switch (mono_metadata_token_table (mtoken)) { @@ -2500,11 +2500,11 @@ mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *m) m = mono_get_inflated_method (m); imethod = (MonoMethodInflated *) m; - if (imethod->declaring->signature->generic_param_count) { + if (mono_method_signature (imethod->declaring)->generic_param_count) { token = method_encode_methodspec (assembly, m); } else { guint32 sig = method_encode_signature ( - assembly, imethod->declaring->signature); + assembly, mono_method_signature (imethod->declaring)); token = mono_image_get_memberref_token ( assembly, &m->klass->byval_arg, m->name, sig); } @@ -2519,7 +2519,7 @@ mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m) MonoMethodInflated *imethod = (MonoMethodInflated *) m; guint32 sig, token; - sig = method_encode_signature (assembly, imethod->declaring->signature); + sig = method_encode_signature (assembly, mono_method_signature (imethod->declaring)); token = mono_image_get_memberref_token ( assembly, &m->klass->byval_arg, m->name, sig); @@ -3573,7 +3573,7 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse case MONO_TABLE_METHODSPEC: if (!strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod")) { MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method; - g_assert (m->signature->generic_param_count); + g_assert (mono_method_signature (m)->generic_param_count); continue; } else { g_assert_not_reached (); @@ -4002,10 +4002,10 @@ mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, Mon guint32 sig_token, parent; int nargs, i; - g_assert (opt_param_types && (method->signature->sentinelpos >= 0)); + g_assert (opt_param_types && (mono_method_signature (method)->sentinelpos >= 0)); nargs = mono_array_length (opt_param_types); - old = method->signature; + old = mono_method_signature (method); sig = mono_metadata_signature_alloc ( &assembly->image, old->param_count + nargs); sig->hasthis = old->hasthis; @@ -5486,7 +5486,7 @@ mono_param_get_objects (MonoDomain *domain, MonoMethod *method) System_Reflection_ParameterInfo = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "ParameterInfo"); - if (!method->signature->param_count) + if (!mono_method_signature (method)->param_count) return mono_array_new (domain, System_Reflection_ParameterInfo, 0); /* Note: the cache is based on the address of the signature into the method @@ -5495,20 +5495,20 @@ mono_param_get_objects (MonoDomain *domain, MonoMethod *method) CHECK_OBJECT (MonoArray*, &(method->signature), NULL); member = mono_method_get_object (domain, method, NULL); - names = g_new (char *, method->signature->param_count); + names = g_new (char *, mono_method_signature (method)->param_count); mono_method_get_param_names (method, (const char **) names); - mspecs = g_new (MonoMarshalSpec*, method->signature->param_count + 1); + mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1); mono_method_get_marshal_info (method, mspecs); - res = mono_array_new (domain, System_Reflection_ParameterInfo, method->signature->param_count); - for (i = 0; i < method->signature->param_count; ++i) { + res = mono_array_new (domain, System_Reflection_ParameterInfo, mono_method_signature (method)->param_count); + for (i = 0; i < mono_method_signature (method)->param_count; ++i) { param = (MonoReflectionParameter *)mono_object_new (domain, System_Reflection_ParameterInfo); - param->ClassImpl = mono_type_get_object (domain, method->signature->params [i]); + param->ClassImpl = mono_type_get_object (domain, mono_method_signature (method)->params [i]); param->MemberImpl = (MonoObject*)member; param->NameImpl = mono_string_new (domain, names [i]); param->PositionImpl = i; - param->AttrsImpl = method->signature->params [i]->attrs; + param->AttrsImpl = mono_method_signature (method)->params [i]->attrs; if (!(param->AttrsImpl & PARAM_ATTRIBUTE_HAS_DEFAULT)) { param->DefaultValueImpl = dbnull; @@ -5516,7 +5516,7 @@ mono_param_get_objects (MonoDomain *domain, MonoMethod *method) MonoType *type = param->ClassImpl->type; if (!blobs) { - blobs = g_new0 (char *, method->signature->param_count); + blobs = g_new0 (char *, mono_method_signature (method)->param_count); get_default_param_value_blobs (method, blobs); } @@ -5535,7 +5535,7 @@ mono_param_get_objects (MonoDomain *domain, MonoMethod *method) g_free (names); g_free (blobs); - for (i = method->signature->param_count; i >= 0; i--) + for (i = mono_method_signature (method)->param_count; i >= 0; i--) if (mspecs [i]) mono_metadata_free_marshal_spec (mspecs [i]); g_free (mspecs); @@ -5671,7 +5671,7 @@ get_default_param_value_blobs (MonoMethod *method, char **blobs) MonoClass *klass = method->klass; MonoImage *image = klass->image; - MonoMethodSignature *methodsig = method->signature; + MonoMethodSignature *methodsig = mono_method_signature (method); MonoTableInfo *constt; MonoTableInfo *methodt; @@ -6206,7 +6206,7 @@ mono_reflection_get_token (MonoObject *obj) MonoReflectionMethod *m = (MonoReflectionMethod *)obj; if (m->method->is_inflated) { g_assert_not_reached (); - } else if (m->method->signature->generic_param_count) { + } else if (mono_method_signature (m->method)->generic_param_count) { g_assert_not_reached (); } else if (m->method->klass->generic_class) { g_assert_not_reached (); @@ -6546,12 +6546,12 @@ create_custom_attr (MonoImage *image, MonoMethod *method, const char *data, guin /*g_print ("got attr %s\n", method->klass->name);*/ - params = g_new (void*, method->signature->param_count); + params = g_new (void*, mono_method_signature (method)->param_count); /* skip prolog */ p += 2; - for (i = 0; i < method->signature->param_count; ++i) { - params [i] = load_cattr_value (image, method->signature->params [i], p, &p); + for (i = 0; i < mono_method_signature (method)->param_count; ++i) { + params [i] = load_cattr_value (image, mono_method_signature (method)->params [i], p, &p); } named = p; @@ -6598,7 +6598,8 @@ create_custom_attr (MonoImage *image, MonoMethod *method, const char *data, guin prop = mono_class_get_property_from_name (mono_object_class (attr), name); /* can we have more that 1 arg in a custom attr named property? */ - prop_type = prop->get? prop->get->signature->ret: prop->set->signature->params [prop->set->signature->param_count - 1]; + prop_type = prop->get? mono_method_signature (prop->get)->ret : + mono_method_signature (prop->set)->params [mono_method_signature (prop->set)->param_count - 1]; pparams [0] = load_cattr_value (image, prop_type, named, &named); mono_property_set_value (prop, attr, pparams, NULL); if (!type_is_reference (prop_type)) @@ -6799,7 +6800,7 @@ mono_custom_attrs_from_param (MonoMethod *method, guint32 param) method_index = find_method_index (method); ca = &image->tables [MONO_TABLE_METHOD]; - if (method->klass->generic_class || method->signature->generic_param_count) { + if (method->klass->generic_class || mono_method_signature (method)->generic_param_count) { /* FIXME FIXME FIXME */ return NULL; } @@ -6988,9 +6989,9 @@ get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type) MonoReflectionProperty *p = (MonoReflectionProperty *)prop; *name = g_strdup (p->property->name); if (p->property->get) - *type = p->property->get->signature->ret; + *type = mono_method_signature (p->property->get)->ret; else - *type = p->property->set->signature->params [p->property->set->signature->param_count - 1]; + *type = mono_method_signature (p->property->set)->params [mono_method_signature (p->property->set)->param_count - 1]; } } @@ -7232,7 +7233,7 @@ mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObj if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) { sig = ctor_builder_to_signature ((MonoReflectionCtorBuilder*)ctor); } else { - sig = ((MonoReflectionMethod*)ctor)->method->signature; + sig = mono_method_signature (((MonoReflectionMethod*)ctor)->method); } g_assert (mono_array_length (ctorArgs) == sig->param_count); buflen = 256; @@ -7785,7 +7786,7 @@ reflection_methodbuilder_to_mono_method (MonoClass *klass, if (rmb->pinfo) { if (!method_aux) method_aux = g_new0 (MonoReflectionMethodAux, 1); - method_aux->param_names = g_new0 (char *, m->signature->param_count + 1); + method_aux->param_names = g_new0 (char *, mono_method_signature (m)->param_count + 1); for (i = 0; i <= m->signature->param_count; ++i) { MonoReflectionParamBuilder *pb; if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) { @@ -8149,7 +8150,7 @@ mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, M method = rmethod->method; } - count = method->signature->generic_param_count; + count = mono_method_signature (method)->generic_param_count; if (count != mono_array_length (types)) return NULL; @@ -8214,7 +8215,7 @@ inflate_mono_method (MonoReflectionGenericClass *type, MonoMethod *method, MonoO gmethod->inst = g_new0 (MonoGenericInst, 1); gmethod->reflection_info = obj; - gmethod->inst->type_argc = method->signature->generic_param_count; + gmethod->inst->type_argc = mono_method_signature (method)->generic_param_count; gmethod->inst->type_argv = g_new0 (MonoType *, gmethod->inst->type_argc); for (i = 0; i < gmethod->inst->type_argc; i++) { diff --git a/mono/metadata/verify.c b/mono/metadata/verify.c index ac2e79b56cc..c60d39e5310 100644 --- a/mono/metadata/verify.c +++ b/mono/metadata/verify.c @@ -1157,7 +1157,7 @@ mono_method_verify (MonoMethod *method, int level) (method->flags & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT))) { return NULL; } - signature = method->signature; + signature = mono_method_signature (method); header = mono_method_get_header (method); ip = header->code; end = ip + header->code_size; @@ -1176,7 +1176,7 @@ mono_method_verify (MonoMethod *method, int level) params = signature->params; } - if (method->signature->is_inflated) + if (signature->is_inflated) generic_context = ((MonoMethodInflated *) method)->context; if (header->num_locals) { @@ -1396,8 +1396,8 @@ mono_method_verify (MonoMethod *method, int level) cmethod = mono_get_method_full (image, token, NULL, generic_context); if (!cmethod) ADD_INVALID (list, g_strdup_printf ("Method 0x%08x not found at 0x%04x", token, ip_offset)); - if (cmethod->signature->pinvoke) { - csig = cmethod->signature; + if (mono_method_signature (cmethod)) { + csig = mono_method_signature (cmethod); } else { csig = mono_method_get_signature (cmethod, image, token); } @@ -1638,7 +1638,7 @@ mono_method_verify (MonoMethod *method, int level) cmethod = mono_get_method_full (image, token, NULL, generic_context); if (!cmethod) ADD_INVALID (list, g_strdup_printf ("Constructor 0x%08x not found at 0x%04x", token, ip_offset)); - csig = cmethod->signature; + csig = mono_method_signature (cmethod); CHECK_STACK_UNDERFLOW (csig->param_count); cur_stack -= csig->param_count; CHECK_STACK_OVERFLOW (); diff --git a/mono/mini/ChangeLog b/mono/mini/ChangeLog index bb059b9ce04..d64022a49e1 100644 --- a/mono/mini/ChangeLog +++ b/mono/mini/ChangeLog @@ -1,3 +1,8 @@ +2005-01-29 Ben Maurer + + * *: MonoMethod->signature might be NULL now. You *MUST* use + mono_method_signature. + 2005-01-28 Zoltan Varga * driver.c (compile_all_methods_thread_main): Compile the methods diff --git a/mono/mini/debug-mini.c b/mono/mini/debug-mini.c index 144d15be1d6..e3ebbfd41bc 100644 --- a/mono/mini/debug-mini.c +++ b/mono/mini/debug-mini.c @@ -194,6 +194,7 @@ mono_debug_close_method (MonoCompile *cfg) MiniDebugMethodInfo *info; MonoDebugMethodJitInfo *jit; MonoMethodHeader *header; + MonoMethodSignature *sig; MonoMethod *method; int i; @@ -206,6 +207,7 @@ mono_debug_close_method (MonoCompile *cfg) method = cfg->method; header = mono_method_get_header (method); + sig = mono_method_signature (method); jit = info->jit; jit->code_start = cfg->native_code; @@ -214,19 +216,19 @@ mono_debug_close_method (MonoCompile *cfg) record_line_number (jit, jit->epilogue_begin, header->code_size); - jit->num_params = method->signature->param_count; + jit->num_params = sig->param_count; jit->params = g_new0 (MonoDebugVarInfo, jit->num_params); for (i = 0; i < jit->num_locals; i++) write_variable (cfg->varinfo [cfg->locals_start + i], &jit->locals [i]); - if (method->signature->hasthis) { + if (sig->hasthis) { jit->this_var = g_new0 (MonoDebugVarInfo, 1); write_variable (cfg->varinfo [0], jit->this_var); } for (i = 0; i < jit->num_params; i++) - write_variable (cfg->varinfo [i + method->signature->hasthis], &jit->params [i]); + write_variable (cfg->varinfo [i + sig->hasthis], &jit->params [i]); mono_debug_add_method (method, jit, cfg->domain); @@ -378,7 +380,7 @@ mono_debug_serialize_debug_info (MonoCompile *cfg, for (i = 0; i < jit->num_params; ++i) serialize_variable (&jit->params [i], p, &p); - if (cfg->method->signature->hasthis) + if (mono_method_signature (cfg->method)->hasthis) serialize_variable (jit->this_var, p, &p); for (i = 0; i < jit->num_locals; i++) @@ -445,7 +447,7 @@ deserialize_debug_info (MonoMethod *method, jit->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry)); jit->num_locals = header->num_locals; jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals); - jit->num_params = method->signature->param_count; + jit->num_params = mono_method_signature (method)->param_count; jit->params = g_new0 (MonoDebugVarInfo, jit->num_params); p = buf; @@ -456,7 +458,7 @@ deserialize_debug_info (MonoMethod *method, for (i = 0; i < jit->num_params; ++i) deserialize_variable (&jit->params [i], p, &p); - if (method->signature->hasthis) { + if (mono_method_signature (method)->hasthis) { jit->this_var = g_new0 (MonoDebugVarInfo, 1); deserialize_variable (jit->this_var, p, &p); } diff --git a/mono/mini/exceptions-amd64.c b/mono/mini/exceptions-amd64.c index dac256cc915..cde890b71ec 100644 --- a/mono/mini/exceptions-amd64.c +++ b/mono/mini/exceptions-amd64.c @@ -563,9 +563,9 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf /* Pop arguments off the stack */ { - MonoJitArgumentInfo *arg_info = alloca (sizeof (MonoJitArgumentInfo) * (ji->method->signature->param_count + 1)); + MonoJitArgumentInfo *arg_info = g_newa (MonoJitArgumentInfo, mono_method_signature (ji->method)->param_count + 1)); - guint32 stack_to_pop = mono_arch_get_argument_info (ji->method->signature, ji->method->signature->param_count, arg_info); + guint32 stack_to_pop = mono_arch_get_argument_info (mono_method_signature (ji->method), mono_method_signature (ji->method)->param_count, arg_info); new_ctx->SC_ESP += stack_to_pop; } diff --git a/mono/mini/exceptions-x86.c b/mono/mini/exceptions-x86.c index 41d4caaa58b..b10c9d80fe6 100644 --- a/mono/mini/exceptions-x86.c +++ b/mono/mini/exceptions-x86.c @@ -506,9 +506,9 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf /* Pop arguments off the stack */ { - MonoJitArgumentInfo *arg_info = alloca (sizeof (MonoJitArgumentInfo) * (ji->method->signature->param_count + 1)); + MonoJitArgumentInfo *arg_info = g_newa (MonoJitArgumentInfo, mono_method_signature (ji->method)->param_count + 1); - guint32 stack_to_pop = mono_arch_get_argument_info (ji->method->signature, ji->method->signature->param_count, arg_info); + guint32 stack_to_pop = mono_arch_get_argument_info (mono_method_signature (ji->method), mono_method_signature (ji->method)->param_count, arg_info); new_ctx->SC_ESP += stack_to_pop; } diff --git a/mono/mini/graph.c b/mono/mini/graph.c index 45168cf7a7f..cea10d1b061 100644 --- a/mono/mini/graph.c +++ b/mono/mini/graph.c @@ -201,7 +201,7 @@ mono_print_label (FILE *fp, MonoInst *tree) { case OP_VOIDCALLVIRT: { MonoCallInst *call = (MonoCallInst*)tree; if (call->method) { - if (call->method->signature->hasthis && tree->inst_left) { + if (mono_method_signature (call->method)->hasthis && tree->inst_left) { mono_print_label (fp, tree->inst_left); } fprintf (fp, "[%s]", call->method->name); diff --git a/mono/mini/inssel-amd64.brg b/mono/mini/inssel-amd64.brg index 2fee8018017..6bad9fc89ad 100644 --- a/mono/mini/inssel-amd64.brg +++ b/mono/mini/inssel-amd64.brg @@ -169,7 +169,7 @@ stmt: OP_SETRET (CEE_LDIND_I (OP_REGVAR)) { } stmt: OP_SETRET (freg) { - if (s->method->signature->ret->type == MONO_TYPE_R4) + if (mono_method_signature (s->method)->ret->type == MONO_TYPE_R4) tree->opcode = OP_AMD64_SET_XMMREG_R4; else tree->opcode = OP_AMD64_SET_XMMREG_R8; diff --git a/mono/mini/inssel-s390.brg b/mono/mini/inssel-s390.brg index fba017d08f7..d2f56dffb6b 100644 --- a/mono/mini/inssel-s390.brg +++ b/mono/mini/inssel-s390.brg @@ -149,7 +149,7 @@ stmt: OP_SETRET (lreg) { } stmt: OP_SETRET (freg) { - if (s->method->signature->ret->type == MONO_TYPE_R4) { + if (mono_method_signature (s->method)->ret->type == MONO_TYPE_R4) { tree->opcode = OP_S390_SETF4RET; tree->sreg1 = state->left->reg1; tree->dreg = s390_f0; diff --git a/mono/mini/inssel-s390x.brg b/mono/mini/inssel-s390x.brg index b0ef5c04349..18222c1bea2 100644 --- a/mono/mini/inssel-s390x.brg +++ b/mono/mini/inssel-s390x.brg @@ -114,7 +114,7 @@ stmt: OP_SETRET (reg) { # } stmt: OP_SETRET (freg) { - if (s->method->signature->ret->type == MONO_TYPE_R4) { + if (mono_method_signature (s->method)->ret->type == MONO_TYPE_R4) { tree->opcode = OP_S390_SETF4RET; tree->sreg1 = state->left->reg1; tree->dreg = s390_f0; diff --git a/mono/mini/jit-icalls.c b/mono/mini/jit-icalls.c index 582b81c9c6a..f7a9ff91ce1 100644 --- a/mono/mini/jit-icalls.c +++ b/mono/mini/jit-icalls.c @@ -399,7 +399,7 @@ mono_array_new_va (MonoMethod *cm, ...) MONO_ARCH_SAVE_REGS; - pcount = cm->signature->param_count; + pcount = mono_method_signature (cm)->param_count; rank = cm->klass->rank; va_start (ap, cm); diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c index ef216a7ac90..0a18d45baf6 100644 --- a/mono/mini/mini-amd64.c +++ b/mono/mini/mini-amd64.c @@ -795,7 +795,7 @@ mono_arch_allocate_vars (MonoCompile *m) header = mono_method_get_header (m->method); - sig = m->method->signature; + sig = mono_method_signature (m->method); cinfo = get_call_info (sig, FALSE); @@ -3063,7 +3063,7 @@ emit_load_volatile_arguments (MonoCompile *cfg, guint8 *code) /* FIXME: Generate intermediate code instead */ - sig = method->signature; + sig = mono_method_signature (method); cinfo = get_call_info (sig, FALSE); @@ -4828,7 +4828,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) } } - sig = method->signature; + sig = mono_method_signature (method); pos = 0; cinfo = get_call_info (sig, FALSE); @@ -5197,7 +5197,7 @@ mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean ena if (enable_arguments) { /* Allocate a new area on the stack and save arguments there */ - sig = cfg->method->signature; + sig = mono_method_signature (cfg->method); cinfo = get_call_info (sig, FALSE); @@ -5247,7 +5247,7 @@ mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean ena guchar *code = p; int save_mode = SAVE_NONE; MonoMethod *method = cfg->method; - int rtype = mono_type_get_underlying_type (method->signature->ret)->type; + int rtype = mono_type_get_underlying_type (mono_method_signature (method)->ret)->type; switch (rtype) { case MONO_TYPE_VOID: diff --git a/mono/mini/mini-ppc.c b/mono/mini/mini-ppc.c index 640d0ef424b..e6d97bc2f16 100644 --- a/mono/mini/mini-ppc.c +++ b/mono/mini/mini-ppc.c @@ -688,7 +688,7 @@ mono_arch_allocate_vars (MonoCompile *m) m->used_int_regs |= 1 << frame_reg; } - sig = m->method->signature; + sig = mono_method_signature (m->method); offset = 0; curinst = 0; @@ -969,7 +969,7 @@ mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean ena guchar *code = p; int save_mode = SAVE_NONE; MonoMethod *method = cfg->method; - int rtype = mono_type_get_underlying_type (method->signature->ret)->type; + int rtype = mono_type_get_underlying_type (mono_method_signature (method)->ret)->type; int save_offset = PPC_STACK_PARAM_OFFSET + cfg->param_area; save_offset += 15; save_offset &= ~15; @@ -3476,7 +3476,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) tracing = 1; - sig = method->signature; + sig = mono_method_signature (method); cfg->code_size = 256 + sig->param_count * 20; code = cfg->native_code = g_malloc (cfg->code_size); diff --git a/mono/mini/mini-s390.c b/mono/mini/mini-s390.c index f5b5551e00f..0da6fae8554 100644 --- a/mono/mini/mini-s390.c +++ b/mono/mini/mini-s390.c @@ -655,7 +655,7 @@ printf("!!\n"); if (rParm == NULL) return; - sig = method->signature; + sig = mono_method_signature (method); cinfo = calculate_sizes (sig, &sz, sig->pinvoke); @@ -760,7 +760,7 @@ leave_method (MonoMethod *method, ...) printf ("LEAVE: %s", fname); g_free (fname); - type = method->signature->ret; + type = mono_method_signature (method)->ret; handle_enum: switch (type->type) { @@ -899,7 +899,7 @@ handle_enum: break; default: printf ("(unknown return type %x)", - method->signature->ret->type); + mono_method_signature (method)->ret->type); } ip = ((gint32) __builtin_return_address (0)) & 0x7fffffff; @@ -1467,7 +1467,7 @@ mono_arch_allocate_vars (MonoCompile *cfg) if (frame_reg != STK_BASE) cfg->used_int_regs |= 1 << frame_reg; - sig = cfg->method->signature; + sig = mono_method_signature (cfg->method); cinfo = calculate_sizes (sig, &sz, sig->pinvoke); @@ -1849,7 +1849,7 @@ mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean ena int save_mode = SAVE_NONE, saveOffset; MonoMethod *method = cfg->method; - int rtype = mono_type_get_underlying_type (method->signature->ret)->type; + int rtype = mono_type_get_underlying_type (mono_method_signature (method)->ret)->type; saveOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE; if (method->save_lmf) @@ -1873,8 +1873,8 @@ handle_enum: save_mode = SAVE_FP; break; case MONO_TYPE_VALUETYPE: - if (method->signature->ret->data.klass->enumtype) { - rtype = method->signature->ret->data.klass->enum_basetype->type; + if (mono_method_signature (method)->ret->data.klass->enumtype) { + rtype = mono_method_signature (method)->ret->data.klass->enum_basetype->type; goto handle_enum; } save_mode = SAVE_STRUCT; @@ -4838,7 +4838,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) } /* load arguments allocated to register from the stack */ - sig = method->signature; + sig = mono_method_signature (method); pos = 0; cinfo = calculate_sizes (sig, &sz, sig->pinvoke); diff --git a/mono/mini/mini-s390x.c b/mono/mini/mini-s390x.c index 63c02759920..7d72fdb2b52 100644 --- a/mono/mini/mini-s390x.c +++ b/mono/mini/mini-s390x.c @@ -659,7 +659,7 @@ enter_method (MonoMethod *method, RegParm *rParm, char *sp) if (rParm == NULL) return; - sig = method->signature; + sig = mono_method_signature (method); cinfo = calculate_sizes (sig, &sz, sig->pinvoke); @@ -771,7 +771,7 @@ leave_method (MonoMethod *method, ...) printf ("LEAVE: %s", fname); g_free (fname); - type = method->signature->ret; + type = mono_method_signature (method)->ret; handle_enum: switch (type->type) { @@ -900,7 +900,7 @@ handle_enum: break; default: printf ("(unknown return type %x)", - method->signature->ret->type); + mono_method_signature (method)->ret->type); } ip = ((gint64) __builtin_return_address (0)); @@ -1383,7 +1383,7 @@ mono_arch_allocate_vars (MonoCompile *m) if (frame_reg != STK_BASE) m->used_int_regs |= 1 << frame_reg; - sig = m->method->signature; + sig = mono_method_signature (m->method); cinfo = calculate_sizes (sig, &sz, sig->pinvoke); @@ -1725,7 +1725,7 @@ mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean ena int save_mode = SAVE_NONE, saveOffset; MonoMethod *method = cfg->method; - int rtype = method->signature->ret->type; + int rtype = mono_method_signature (method)->ret->type; saveOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE; if (method->save_lmf) @@ -1749,8 +1749,8 @@ handle_enum: save_mode = SAVE_FP; break; case MONO_TYPE_VALUETYPE: - if (method->signature->ret->data.klass->enumtype) { - rtype = method->signature->ret->data.klass->enum_basetype->type; + if (mono_method_signature (method)->ret->data.klass->enumtype) { + rtype = mono_method_signature (method)->ret->data.klass->enum_basetype->type; goto handle_enum; } save_mode = SAVE_STRUCT; @@ -5219,7 +5219,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) } /* load arguments allocated to register from the stack */ - sig = method->signature; + sig = mono_method_signature (method); pos = 0; cinfo = calculate_sizes (sig, &sz, sig->pinvoke); @@ -5446,7 +5446,7 @@ mono_arch_emit_epilog (MonoCompile *cfg) { MonoJumpInfo *patch_info; MonoMethod *method = cfg->method; - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); MonoInst *inst; int i, tracing = 0; guint8 *code; diff --git a/mono/mini/mini-sparc.c b/mono/mini/mini-sparc.c index 0b7e4dc9655..8608a632950 100644 --- a/mono/mini/mini-sparc.c +++ b/mono/mini/mini-sparc.c @@ -727,7 +727,7 @@ mono_arch_get_global_int_regs (MonoCompile *cfg) MonoMethodSignature *sig; CallInfo *cinfo; - sig = cfg->method->signature; + sig = mono_method_signature (cfg->method); cinfo = get_call_info (sig, FALSE); @@ -772,7 +772,7 @@ mono_arch_allocate_vars (MonoCompile *m) header = mono_method_get_header (m->method); - sig = m->method->signature; + sig = mono_method_signature (m->method); cinfo = get_call_info (sig, FALSE); @@ -2749,7 +2749,7 @@ emit_load_volatile_arguments (MonoCompile *cfg, guint32 *code) /* FIXME: Generate intermediate code instead */ - sig = method->signature; + sig = mono_method_signature (method); cinfo = get_call_info (sig, FALSE); @@ -3517,7 +3517,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = emit_move_return_value (ins, code); break; case OP_SETFRET: - if (cfg->method->signature->ret->type == MONO_TYPE_R4) + if (mono_method_signature (cfg->method)->ret->type == MONO_TYPE_R4) sparc_fdtos (code, ins->sreg1, sparc_f0); else { #ifdef SPARCV9 @@ -4230,7 +4230,7 @@ mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean ena { int i; guint32 *code = (guint32*)p; - MonoMethodSignature *sig = cfg->method->signature; + MonoMethodSignature *sig = mono_method_signature (cfg->method); CallInfo *cinfo; /* Save registers to stack */ @@ -4301,7 +4301,7 @@ mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean ena int save_mode = SAVE_NONE; MonoMethod *method = cfg->method; - switch (mono_type_get_underlying_type (method->signature->ret)->type) { + switch (mono_type_get_underlying_type (mono_method_signature (method)->ret)->type) { case MONO_TYPE_VOID: /* special case string .ctor icall */ if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) @@ -4447,7 +4447,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) } */ - sig = method->signature; + sig = mono_method_signature (method); cinfo = get_call_info (sig, FALSE); @@ -4640,7 +4640,7 @@ mono_arch_emit_epilog (MonoCompile *cfg) * The V8 ABI requires that calls to functions which return a structure * return to %i7+12 */ - if (!v64 && cfg->method->signature->pinvoke && MONO_TYPE_ISSTRUCT(cfg->method->signature->ret)) + if (!v64 && mono_method_signature (cfg->method)->pinvoke && MONO_TYPE_ISSTRUCT(mono_method_signature (cfg->method)->ret)) sparc_jmpl_imm (code, sparc_i7, 12, sparc_g0); else sparc_ret (code); diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c index 23f39cc0ca1..461161c6fe0 100644 --- a/mono/mini/mini-x86.c +++ b/mono/mini/mini-x86.c @@ -674,8 +674,7 @@ mono_arch_allocate_vars (MonoCompile *m) gint32 *offsets; header = mono_method_get_header (m->method); - - sig = m->method->signature; + sig = mono_method_signature (m->method); offset = 8; curinst = 0; @@ -977,7 +976,7 @@ mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean ena int arg_size = 0, save_mode = SAVE_NONE; MonoMethod *method = cfg->method; - switch (mono_type_get_underlying_type (method->signature->ret)->type) { + switch (mono_type_get_underlying_type (mono_method_signature (method)->ret)->type) { case MONO_TYPE_VOID: /* special case string .ctor icall */ if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) @@ -4225,7 +4224,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE); /* load arguments allocated to register from the stack */ - sig = method->signature; + sig = mono_method_signature (method); pos = 0; for (i = 0; i < sig->param_count + sig->hasthis; ++i) { @@ -4247,7 +4246,7 @@ void mono_arch_emit_epilog (MonoCompile *cfg) { MonoMethod *method = cfg->method; - MonoMethodSignature *sig = method->signature; + MonoMethodSignature *sig = mono_method_signature (method); int pos; guint32 stack_to_pop; guint8 *code; @@ -4341,7 +4340,7 @@ mono_arch_emit_epilog (MonoCompile *cfg) MonoJitArgumentInfo *arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1)); stack_to_pop = mono_arch_get_argument_info (sig, sig->param_count, arg_info); - } else if (MONO_TYPE_ISSTRUCT (cfg->method->signature->ret)) + } else if (MONO_TYPE_ISSTRUCT (mono_method_signature (cfg->method)->ret)) stack_to_pop = 4; else stack_to_pop = 0; diff --git a/mono/mini/mini.c b/mono/mini/mini.c index 11092360c62..13e48d6fa1c 100644 --- a/mono/mini/mini.c +++ b/mono/mini/mini.c @@ -66,7 +66,7 @@ #define MONO_IS_COND_BRANCH_OP(ins) (((ins)->opcode >= CEE_BEQ && (ins)->opcode <= CEE_BLT_UN) || ((ins)->opcode >= OP_LBEQ && (ins)->opcode <= OP_LBLT_UN) || ((ins)->opcode >= OP_FBEQ && (ins)->opcode <= OP_FBLT_UN) || ((ins)->opcode >= OP_IBEQ && (ins)->opcode <= OP_IBLT_UN)) #define MONO_IS_COND_BRANCH_NOFP(ins) (MONO_IS_COND_BRANCH_OP(ins) && (ins)->inst_left->inst_left->type != STACK_R8) -#define MONO_CHECK_THIS(ins) (cfg->method->signature->hasthis && (ins)->ssa_op == MONO_SSA_LOAD && (ins)->inst_left->inst_c0 == 0) +#define MONO_CHECK_THIS(ins) (mono_method_signature (cfg->method)->hasthis && (ins)->ssa_op == MONO_SSA_LOAD && (ins)->inst_left->inst_c0 == 0) static void setup_stat_profiler (void); gboolean mono_arch_print_tree(MonoInst *tree, int arity); @@ -2593,7 +2593,7 @@ static gboolean mono_method_check_inlining (MonoCompile *cfg, MonoMethod *method) { MonoMethodHeader *header = mono_method_get_header (method); - MonoMethodSignature *signature = method->signature; + MonoMethodSignature *signature = mono_method_signature (method); MonoVTable *vtable; int i; @@ -2675,7 +2675,7 @@ mini_get_ldelema_ins (MonoCompile *cfg, MonoBasicBlock *bblock, MonoMethod *cmet char *name; MonoJitICallInfo *info; - rank = cmethod->signature->param_count - (is_set? 1: 0); + rank = mono_method_signature (cmethod)->param_count - (is_set? 1: 0); if (rank == 2 && (cfg->opt & MONO_OPT_INTRINS)) { MonoInst *indexes; @@ -3088,18 +3088,18 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b image = method->klass->image; header = mono_method_get_header (method); generic_container = ((MonoMethodNormal *)method)->generic_container; - sig = method->signature; + sig = mono_method_signature (method); num_args = sig->hasthis + sig->param_count; ip = (unsigned char*)header->code; end = ip + header->code_size; mono_jit_stats.cil_code_size += header->code_size; - if (method->signature->is_inflated) + if (sig->is_inflated) generic_context = ((MonoMethodInflated *) method)->context; else if (generic_container) generic_context = &generic_container->context; - g_assert (!method->signature->has_type_parameters); + g_assert (!sig->has_type_parameters); if (cfg->method == method) { real_offset = 0; @@ -3244,7 +3244,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b NEW_DECLSECCONST (cfg, args[0], image, actions.demand); NEW_ICONST (cfg, args [1], actions.demand.size); /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */ - mono_emit_method_call_spilled (cfg, init_localsbb, secman->demand, secman->demand->signature, args, ip, NULL); + mono_emit_method_call_spilled (cfg, init_localsbb, secman->demand, mono_method_signature (secman->demand), args, ip, NULL); } if (actions.noncasdemand.blob) { /* CLR 1.x uses a .noncasdemand (but 2.x doesn't) */ @@ -3252,14 +3252,14 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b NEW_DECLSECCONST (cfg, args[0], image, actions.noncasdemand); NEW_ICONST (cfg, args [1], actions.noncasdemand.size); /* Calls static void SecurityManager.InternalDemand (byte* permissions, int size); */ - mono_emit_method_call_spilled (cfg, init_localsbb, secman->demand, secman->demand->signature, args, ip, NULL); + mono_emit_method_call_spilled (cfg, init_localsbb, secman->demand, mono_method_signature (secman->demand), args, ip, NULL); } if (actions.demandchoice.blob) { /* New in 2.0, Demand must succeed for one of the permissions (i.e. not all) */ NEW_DECLSECCONST (cfg, args[0], image, actions.demandchoice); NEW_ICONST (cfg, args [1], actions.demandchoice.size); /* Calls static void SecurityManager.InternalDemandChoice (byte* permissions, int size); */ - mono_emit_method_call_spilled (cfg, init_localsbb, secman->demandchoice, secman->demandchoice->signature, args, ip, NULL); + mono_emit_method_call_spilled (cfg, init_localsbb, secman->demandchoice, mono_method_signature (secman->demandchoice), args, ip, NULL); } } @@ -3665,11 +3665,11 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b if (!cmethod->klass->inited) mono_class_init (cmethod->klass); - if (cmethod->signature->pinvoke) { + if (mono_method_signature (cmethod)->pinvoke) { MonoMethod *wrapper = mono_marshal_get_native_wrapper (cmethod); - fsig = wrapper->signature; + fsig = mono_method_signature (wrapper); } else if (constrained_call) { - fsig = cmethod->signature; + fsig = mono_method_signature (cmethod); } else { fsig = mono_method_get_signature_full (cmethod, image, token, generic_context); } @@ -3749,11 +3749,11 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b goto unverified; } - if (cmethod && virtual && cmethod->signature->generic_param_count) { + if (cmethod && virtual && mono_method_signature (cmethod)->generic_param_count) { MonoInst *this_temp, *store; MonoInst *iargs [3]; - g_assert (cmethod->signature->is_inflated); + g_assert (mono_method_signature (cmethod)->is_inflated); this_temp = mono_compile_create_var (cfg, type_from_stack_type (sp [0]), OP_LOCAL); this_temp->cil_code = ip; @@ -3779,7 +3779,8 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b break; } - if ((ins_flag & MONO_INST_TAILCALL) && cmethod && (*ip == CEE_CALL) && (mono_metadata_signature_equal (method->signature, cmethod->signature))) { + if ((ins_flag & MONO_INST_TAILCALL) && cmethod && (*ip == CEE_CALL) && + (mono_metadata_signature_equal (mono_method_signature (method), mono_method_signature (cmethod)))) { int i; /* FIXME: This assumes the two methods has the same number and type of arguments */ for (i = 0; i < n; ++i) { @@ -3871,7 +3872,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b /* keep it simple */ for (i = fsig->param_count - 1; i >= 0; i--) { - if (MONO_TYPE_ISSTRUCT (cmethod->signature->params [i])) + if (MONO_TYPE_ISSTRUCT (mono_method_signature (cmethod)->params [i])) has_vtargs = TRUE; } @@ -4007,7 +4008,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b CHECK_STACK (1); --sp; MONO_INST_NEW (cfg, ins, CEE_NOP); - ins->opcode = mono_type_to_stind (method->signature->ret); + ins->opcode = mono_type_to_stind (mono_method_signature (method)->ret); if (ins->opcode == CEE_STOBJ) { NEW_RETLOADA (cfg, ins); handle_stobj (cfg, bblock, ins, *sp, ip, ins->klass, FALSE, FALSE); @@ -4606,7 +4607,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b mono_isinst = mono_marshal_get_isinst (klass); iargs [0] = sp [0]; - costs = inline_method (cfg, mono_isinst, mono_isinst->signature, bblock, + costs = inline_method (cfg, mono_isinst, mono_method_signature (mono_isinst), bblock, iargs, ip, real_offset, dont_inline, &ebblock, TRUE); g_assert (costs > 0); @@ -4662,7 +4663,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b mono_castclass = mono_marshal_get_castclass (klass); iargs [0] = sp [0]; - costs = inline_method (cfg, mono_castclass, mono_castclass->signature, bblock, + costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass), bblock, iargs, ip, real_offset, dont_inline, &ebblock, TRUE); g_assert (costs > 0); @@ -4790,7 +4791,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b mono_castclass = mono_marshal_get_castclass (klass); iargs [0] = sp [0]; - costs = inline_method (cfg, mono_castclass, mono_castclass->signature, bblock, + costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass), bblock, iargs, ip, real_offset, dont_inline, &ebblock, TRUE); g_assert (costs > 0); @@ -4871,7 +4872,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b iargs [4] = sp [1]; if (cfg->opt & MONO_OPT_INLINE) { - costs = inline_method (cfg, stfld_wrapper, stfld_wrapper->signature, bblock, + costs = inline_method (cfg, stfld_wrapper, mono_method_signature (stfld_wrapper), bblock, iargs, ip, real_offset, dont_inline, &ebblock, TRUE); g_assert (costs > 0); @@ -4889,7 +4890,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b inline_costs += costs; break; } else { - mono_emit_method_call_spilled (cfg, bblock, stfld_wrapper, stfld_wrapper->signature, iargs, ip, NULL); + mono_emit_method_call_spilled (cfg, bblock, stfld_wrapper, mono_method_signature (stfld_wrapper), iargs, ip, NULL); } } else { MonoInst *store; @@ -4924,8 +4925,8 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b NEW_CLASSCONST (cfg, iargs [1], klass); NEW_FIELDCONST (cfg, iargs [2], field); NEW_ICONST (cfg, iargs [3], klass->valuetype ? field->offset - sizeof (MonoObject) : field->offset); - if ((cfg->opt & MONO_OPT_INLINE) && !MONO_TYPE_ISSTRUCT (ldfld_wrapper->signature->ret)) { - costs = inline_method (cfg, ldfld_wrapper, ldfld_wrapper->signature, bblock, + if ((cfg->opt & MONO_OPT_INLINE) && !MONO_TYPE_ISSTRUCT (mono_method_signature (ldfld_wrapper)->ret)) { + costs = inline_method (cfg, ldfld_wrapper, mono_method_signature (ldfld_wrapper), bblock, iargs, ip, real_offset, dont_inline, &ebblock, TRUE); g_assert (costs > 0); @@ -4953,7 +4954,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b inline_costs += costs; break; } else { - temp = mono_emit_method_call_spilled (cfg, bblock, ldfld_wrapper, ldfld_wrapper->signature, iargs, ip, NULL); + temp = mono_emit_method_call_spilled (cfg, bblock, ldfld_wrapper, mono_method_signature (ldfld_wrapper), iargs, ip, NULL); if (*ip == CEE_LDFLDA) { /* not sure howto handle this */ NEW_TEMPLOADA (cfg, *sp, temp); @@ -5393,7 +5394,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b iargs [1] = sp [1]; iargs [0] = sp [0]; - mono_emit_method_call_spilled (cfg, bblock, helper, helper->signature, iargs, ip, NULL); + mono_emit_method_call_spilled (cfg, bblock, helper, mono_method_signature (helper), iargs, ip, NULL); } else { NEW_LDELEMA (cfg, load, sp, klass); load->cil_code = ip; @@ -5427,7 +5428,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b iargs [1] = sp [1]; iargs [0] = sp [0]; - mono_emit_method_call_spilled (cfg, bblock, helper, helper->signature, iargs, ip, NULL); + mono_emit_method_call_spilled (cfg, bblock, helper, mono_method_signature (helper), iargs, ip, NULL); /* MonoInst *group; @@ -5791,7 +5792,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b break; case CEE_MONO_RETOBJ: g_assert (cfg->ret); - g_assert (method->signature->pinvoke); + g_assert (mono_method_signature (method)->pinvoke); CHECK_STACK (1); --sp; @@ -8003,7 +8004,7 @@ mono_compile_create_vars (MonoCompile *cfg) header = mono_method_get_header (cfg->method); - sig = cfg->method->signature; + sig = mono_method_signature (cfg->method); if (!MONO_TYPE_IS_VOID (sig->ret)) { cfg->ret = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst)); @@ -9543,7 +9544,7 @@ mono_jit_create_remoting_trampoline (MonoMethod *method, MonoRemotingTarget targ guint8 *addr = NULL; if ((method->flags & METHOD_ATTRIBUTE_ABSTRACT) || - (method->signature->hasthis && (method->klass->marshalbyref || method->klass == mono_defaults.object_class))) { + (mono_method_signature (method)->hasthis && (method->klass->marshalbyref || method->klass == mono_defaults.object_class))) { nm = mono_marshal_get_remoting_invoke_for_target (method, target); addr = mono_compile_method (nm); } else { @@ -9835,7 +9836,7 @@ mono_precompile_assembly (MonoAssembly *ass, void *user_data) invoke = mono_marshal_get_runtime_invoke (method); mono_compile_method (invoke); } - if (method->klass->marshalbyref && method->signature->hasthis) { + if (method->klass->marshalbyref && mono_method_signature (method)->hasthis) { invoke = mono_marshal_get_remoting_invoke_with_check (method); mono_compile_method (invoke); } diff --git a/mono/mini/trace.c b/mono/mini/trace.c index 74cdfd7f02f..216311ebadb 100644 --- a/mono/mini/trace.c +++ b/mono/mini/trace.c @@ -289,19 +289,19 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) g_error ("unaligned stack detected (%p)", ebp); } - sig = method->signature; + sig = mono_method_signature (method); arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1)); mono_arch_get_argument_info (sig, sig->param_count, arg_info); - if (MONO_TYPE_ISSTRUCT (method->signature->ret)) { - g_assert (!method->signature->ret->byref); + if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) { + g_assert (!mono_method_signature (method)->ret->byref); printf ("VALUERET:%p, ", *((gpointer *)(ebp + 8))); } - if (method->signature->hasthis) { + if (mono_method_signature (method)->hasthis) { gpointer *this = (gpointer *)(ebp + arg_info [0].offset); if (method->klass->valuetype) { printf ("value:%p, ", *this); @@ -321,11 +321,11 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) } } - for (i = 0; i < method->signature->param_count; ++i) { + for (i = 0; i < mono_method_signature (method)->param_count; ++i) { gpointer *cpos = (gpointer *)(ebp + arg_info [i + 1].offset); int size = arg_info [i + 1].size; - MonoType *type = method->signature->params [i]; + MonoType *type = mono_method_signature (method)->params [i]; if (type->byref) { printf ("[BYREF:%p], ", *cpos); @@ -422,7 +422,7 @@ mono_trace_leave_method (MonoMethod *method, ...) printf ("LEAVE: %s", fname); g_free (fname); - type = method->signature->ret; + type = mono_method_signature (method)->ret; handle_enum: switch (type->type) { @@ -517,7 +517,7 @@ handle_enum: } break; default: - printf ("(unknown return type %x)", method->signature->ret->type); + printf ("(unknown return type %x)", mono_method_signature (method)->ret->type); } //printf (" ip: %p\n", __builtin_return_address (1)); diff --git a/mono/mini/tramp-amd64.c b/mono/mini/tramp-amd64.c index 868788c1443..7dc99a0a035 100644 --- a/mono/mini/tramp-amd64.c +++ b/mono/mini/tramp-amd64.c @@ -51,7 +51,7 @@ get_unbox_trampoline (MonoMethod *m, gpointer addr) int this_reg = AMD64_RDI; MonoDomain *domain = mono_domain_get (); - if (!m->signature->ret->byref && MONO_TYPE_ISSTRUCT (m->signature->ret)) + if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret)) this_reg = AMD64_RSI; mono_domain_lock (domain); diff --git a/mono/mini/tramp-ppc.c b/mono/mini/tramp-ppc.c index 8a22eb95ab6..8ba28830845 100644 --- a/mono/mini/tramp-ppc.c +++ b/mono/mini/tramp-ppc.c @@ -51,7 +51,7 @@ get_unbox_trampoline (MonoMethod *m, gpointer addr) guint8 *code, *start; int this_pos = 3; - if (!m->signature->ret->byref && MONO_TYPE_ISSTRUCT (m->signature->ret)) + if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret)) this_pos = 4; start = code = g_malloc (20); diff --git a/mono/mini/tramp-s390.c b/mono/mini/tramp-s390.c index d6c56e65db4..4e2f4d370fe 100644 --- a/mono/mini/tramp-s390.c +++ b/mono/mini/tramp-s390.c @@ -113,8 +113,8 @@ get_unbox_trampoline (MonoMethod *method, gpointer addr) int this_pos = s390_r2; start = addr; - if ((!method->signature->ret->byref) && - (MONO_TYPE_ISSTRUCT (method->signature->ret))) + if ((!mono_method_signature (method)->ret->byref) && + (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret))) this_pos = s390_r3; start = code = mono_global_codeman_reserve (28); diff --git a/mono/mini/tramp-s390x.c b/mono/mini/tramp-s390x.c index 3b91fbe8087..a6fda39b000 100644 --- a/mono/mini/tramp-s390x.c +++ b/mono/mini/tramp-s390x.c @@ -114,8 +114,8 @@ get_unbox_trampoline (MonoMethod *method, gpointer addr) start = addr; if ((method->klass->valuetype)) { - if ((!method->signature->ret->byref) && - (MONO_TYPE_ISSTRUCT (method->signature->ret))) + if ((!mono_method_signature (method)->ret->byref) && + (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret))) this_pos = s390_r3; start = code = g_malloc (28); diff --git a/mono/mini/tramp-sparc.c b/mono/mini/tramp-sparc.c index 34f084b6603..a1a00ff5778 100644 --- a/mono/mini/tramp-sparc.c +++ b/mono/mini/tramp-sparc.c @@ -50,7 +50,7 @@ get_unbox_trampoline (MonoMethod *m, gpointer addr) guint8 *code, *start; int this_pos = 4, reg; - if (!m->signature->ret->byref && MONO_TYPE_ISSTRUCT (m->signature->ret)) + if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret)) this_pos = 8; start = code = mono_global_codeman_reserve (36); diff --git a/mono/mini/tramp-x86.c b/mono/mini/tramp-x86.c index 122e922366a..b68bd8a82fb 100644 --- a/mono/mini/tramp-x86.c +++ b/mono/mini/tramp-x86.c @@ -54,7 +54,7 @@ get_unbox_trampoline (MonoMethod *m, gpointer addr) int this_pos = 4; MonoDomain *domain = mono_domain_get (); - if (!m->signature->ret->byref && MONO_TYPE_ISSTRUCT (m->signature->ret)) + if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret)) this_pos = 8; mono_domain_lock (domain); -- 2.11.4.GIT