+2005-01-29 Ben Maurer <bmaurer@ximian.com>
+
+ * *: MonoMethod->signature might be NULL now. You *MUST* use
+ mono_method_signature.
+
2005-01-20 Bernie Solomon <bernard@ugsolutions.com>
* interp.c: mono_init_icall got renamed
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);
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);
}
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);
}
{
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);
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);
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;
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;
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));
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;
{
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 {
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);
{
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);
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);
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;
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));
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)
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);
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;
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)) {
/* 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) {
+2005-01-29 Ben Maurer <bmaurer@ximian.com>
+
+ * 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 <vargaz@freemail.hu>
* object.c (mono_runtime_get_main_args): Return an array from the
(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);
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;
}
!(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;
}
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;
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;
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);
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)
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;
}
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;
}
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;
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));
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;
}
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*
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;
(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
(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*
}
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++) {
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"))
{
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;
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;
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;
}
}
/* !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);
/* 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);
}
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);
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++) {
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);
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);
}
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 */
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];
}
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) {
((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));
((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;
}
}
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*
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);
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;
}
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)))
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);
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)))
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));
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)
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;
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))
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);
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);
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);
/* 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);
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)))
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);
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;
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;
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;
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)))
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);
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))
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;
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;
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);
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);
MonoMethod *
mono_marshal_get_unbox_wrapper (MonoMethod *method)
{
- MonoMethodSignature *sig = method->signature;
+ MonoMethodSignature *sig = mono_method_signature (method);
int i;
MonoMethodBuilder *mb;
MonoMethod *res;
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))) {
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;
}
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);
}
}
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);
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");
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);
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);
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");
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);
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);
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;
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);
}
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;
}
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);
}
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
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;
}
/* 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)
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;
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;
}
MonoReflectionMethod *method,
MonoArray *out_args)
{
- MonoMethodSignature *sig = method->method->signature;
+ MonoMethodSignature *sig = mono_method_signature (method->method);
MonoString *name;
int i, j;
char **names;
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;
}
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)
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;
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;
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;
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];
{
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);
/*
* 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,
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)) {
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);
}
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);
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 ();
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;
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
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;
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);
}
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);
MonoClass *klass = method->klass;
MonoImage *image = klass->image;
- MonoMethodSignature *methodsig = method->signature;
+ MonoMethodSignature *methodsig = mono_method_signature (method);
MonoTableInfo *constt;
MonoTableInfo *methodt;
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 ();
/*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;
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))
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;
}
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];
}
}
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;
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))) {
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;
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++) {
(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;
params = signature->params;
}
- if (method->signature->is_inflated)
+ if (signature->is_inflated)
generic_context = ((MonoMethodInflated *) method)->context;
if (header->num_locals) {
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);
}
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 ();
+2005-01-29 Ben Maurer <bmaurer@ximian.com>
+
+ * *: MonoMethod->signature might be NULL now. You *MUST* use
+ mono_method_signature.
+
2005-01-28 Zoltan Varga <vargaz@freemail.hu>
* driver.c (compile_all_methods_thread_main): Compile the methods
MiniDebugMethodInfo *info;
MonoDebugMethodJitInfo *jit;
MonoMethodHeader *header;
+ MonoMethodSignature *sig;
MonoMethod *method;
int i;
method = cfg->method;
header = mono_method_get_header (method);
+ sig = mono_method_signature (method);
jit = info->jit;
jit->code_start = cfg->native_code;
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);
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++)
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;
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);
}
/* 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;
}
/* 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;
}
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);
}
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;
}
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;
# }
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;
MONO_ARCH_SAVE_REGS;
- pcount = cm->signature->param_count;
+ pcount = mono_method_signature (cm)->param_count;
rank = cm->klass->rank;
va_start (ap, cm);
header = mono_method_get_header (m->method);
- sig = m->method->signature;
+ sig = mono_method_signature (m->method);
cinfo = get_call_info (sig, FALSE);
/* FIXME: Generate intermediate code instead */
- sig = method->signature;
+ sig = mono_method_signature (method);
cinfo = get_call_info (sig, FALSE);
}
}
- sig = method->signature;
+ sig = mono_method_signature (method);
pos = 0;
cinfo = get_call_info (sig, FALSE);
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);
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:
m->used_int_regs |= 1 << frame_reg;
}
- sig = m->method->signature;
+ sig = mono_method_signature (m->method);
offset = 0;
curinst = 0;
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;
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);
if (rParm == NULL)
return;
- sig = method->signature;
+ sig = mono_method_signature (method);
cinfo = calculate_sizes (sig, &sz, sig->pinvoke);
printf ("LEAVE: %s", fname);
g_free (fname);
- type = method->signature->ret;
+ type = mono_method_signature (method)->ret;
handle_enum:
switch (type->type) {
break;
default:
printf ("(unknown return type %x)",
- method->signature->ret->type);
+ mono_method_signature (method)->ret->type);
}
ip = ((gint32) __builtin_return_address (0)) & 0x7fffffff;
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);
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)
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;
}
/* 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);
if (rParm == NULL)
return;
- sig = method->signature;
+ sig = mono_method_signature (method);
cinfo = calculate_sizes (sig, &sz, sig->pinvoke);
printf ("LEAVE: %s", fname);
g_free (fname);
- type = method->signature->ret;
+ type = mono_method_signature (method)->ret;
handle_enum:
switch (type->type) {
break;
default:
printf ("(unknown return type %x)",
- method->signature->ret->type);
+ mono_method_signature (method)->ret->type);
}
ip = ((gint64) __builtin_return_address (0));
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);
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)
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;
}
/* 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);
{
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;
MonoMethodSignature *sig;
CallInfo *cinfo;
- sig = cfg->method->signature;
+ sig = mono_method_signature (cfg->method);
cinfo = get_call_info (sig, FALSE);
header = mono_method_get_header (m->method);
- sig = m->method->signature;
+ sig = mono_method_signature (m->method);
cinfo = get_call_info (sig, FALSE);
/* FIXME: Generate intermediate code instead */
- sig = method->signature;
+ sig = mono_method_signature (method);
cinfo = get_call_info (sig, FALSE);
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
{
int i;
guint32 *code = (guint32*)p;
- MonoMethodSignature *sig = cfg->method->signature;
+ MonoMethodSignature *sig = mono_method_signature (cfg->method);
CallInfo *cinfo;
/* Save registers to stack */
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)
}
*/
- sig = method->signature;
+ sig = mono_method_signature (method);
cinfo = get_call_info (sig, FALSE);
* 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);
gint32 *offsets;
header = mono_method_get_header (m->method);
-
- sig = m->method->signature;
+ sig = mono_method_signature (m->method);
offset = 8;
curinst = 0;
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)
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) {
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;
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;
#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);
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;
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;
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;
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) */
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);
}
}
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);
}
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;
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) {
/* 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;
}
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);
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);
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);
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);
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);
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;
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);
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);
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;
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;
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;
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));
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 {
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);
}
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);
}
}
- 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);
printf ("LEAVE: %s", fname);
g_free (fname);
- type = method->signature->ret;
+ type = mono_method_signature (method)->ret;
handle_enum:
switch (type->type) {
}
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));
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);
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);
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);
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);
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);
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);
projects / mono.git / commitdiff