2 * loader.c: Image Loader
5 * Paolo Molaro (lupus@ximian.com)
6 * Miguel de Icaza (miguel@ximian.com)
7 * Patrik Torstensson (patrik.torstensson@labs2.com)
9 * (C) 2001 Ximian, Inc.
11 * This file is used by the interpreter and the JIT engine to locate
12 * assemblies. Used to load AssemblyRef and later to resolve various
16 * This should keep track of the assembly versions that we are loading.
25 #include <mono/metadata/metadata.h>
26 #include <mono/metadata/image.h>
27 #include <mono/metadata/assembly.h>
28 #include <mono/metadata/tokentype.h>
29 #include <mono/metadata/cil-coff.h>
30 #include <mono/metadata/tabledefs.h>
31 #include <mono/metadata/loader.h>
32 #include <mono/metadata/class.h>
33 #include <mono/metadata/debug-helpers.h>
34 #include <mono/metadata/reflection.h>
36 static gboolean dummy_icall = TRUE;
38 MonoDefaults mono_defaults;
40 static GHashTable *icall_hash = NULL;
43 mono_add_internal_call (const char *name, gconstpointer method)
47 icall_hash = g_hash_table_new (g_str_hash , g_str_equal);
50 g_hash_table_insert (icall_hash, g_strdup (name), method);
54 ves_icall_dummy (void)
56 g_warning ("the mono runtime is not initialized");
57 g_assert_not_reached ();
61 mono_lookup_internal_call (MonoMethod *method)
68 return ves_icall_dummy;
71 g_warning ("can't resolve internal call, method is null");
75 g_warning ("icall_hash not initialized");
76 g_assert_not_reached ();
79 if (*method->klass->name_space)
80 name = g_strconcat (method->klass->name_space, ".", method->klass->name, "::", method->name, NULL);
82 name = g_strconcat (method->klass->name, "::", method->name, NULL);
83 if (!(res = g_hash_table_lookup (icall_hash, name))) {
84 /* trying to resolve with full signature */
87 tmpsig = mono_signature_get_desc(method->signature, TRUE);
88 if (*method->klass->name_space)
89 name = g_strconcat (method->klass->name_space, ".", method->klass->name, "::", method->name, "(", tmpsig, ")", NULL);
91 name = g_strconcat (method->klass->name, "::", method->name, "(", tmpsig, ")", NULL);
92 if (!(res = g_hash_table_lookup (icall_hash, name))) {
93 g_warning ("cant resolve internal call to \"%s\" (tested without signature also)", name);
94 g_print ("\nYour mono runtime and corlib are out of sync.\n");
95 g_print ("When you update one from cvs you need to update, compile and install\nthe other too.\n");
96 g_print ("Do not report this as a bug unless you're sure you have updated correctly:\nyou probably have a broken mono install.\n");
97 g_print ("If you see other errors or faults after this message they are probably related\n");
98 g_print ("and you need to fix your mono install first.\n");
115 mono_field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass)
118 MonoTableInfo *tables = image->tables;
120 guint32 nindex, class;
123 guint32 idx = mono_metadata_token_index (token);
125 if (image->assembly->dynamic) {
126 MonoClassField *result;
127 MonoDynamicAssembly *assembly = image->assembly->dynamic;
130 obj = g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
132 if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
133 result = ((MonoReflectionField*)obj)->field;
137 g_assert_not_reached ();
138 *retklass = result->parent;
142 mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
143 nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
144 class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
146 fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
148 ptr = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
149 mono_metadata_decode_blob_size (ptr, &ptr);
150 /* we may want to check the signature here... */
153 case MEMBERREF_PARENT_TYPEREF:
154 klass = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | nindex);
156 g_warning ("Missing field %s in typeref index %d", fname, nindex);
159 mono_class_init (klass);
162 return mono_class_get_field_from_name (klass, fname);
169 mono_field_from_token (MonoImage *image, guint32 token, MonoClass **retklass)
174 if (image->assembly->dynamic) {
175 MonoClassField *result;
176 MonoDynamicAssembly *assembly = image->assembly->dynamic;
179 obj = g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
181 if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
182 result = ((MonoReflectionField*)obj)->field;
185 else if (strcmp (obj->vtable->klass->name, "FieldBuilder") == 0) {
186 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
191 g_print (obj->vtable->klass->name);
192 g_assert_not_reached ();
194 *retklass = result->parent;
198 if (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF)
199 return mono_field_from_memberref (image, token, retklass);
201 type = mono_metadata_typedef_from_field (image, mono_metadata_token_index (token));
204 k = mono_class_get (image, MONO_TOKEN_TYPE_DEF | type);
210 return mono_class_get_field (k, token);
214 find_method (MonoClass *klass, const char* name, MonoMethodSignature *sig)
218 /* mostly dumb search for now */
219 for (i = 0; i < klass->method.count; ++i) {
220 MonoMethod *m = klass->methods [i];
221 if (!strcmp (name, m->name)) {
222 if (mono_metadata_signature_equal (sig, m->signature))
226 klass = klass->parent;
233 method_from_memberref (MonoImage *image, guint32 idx)
237 MonoTableInfo *tables = image->tables;
239 guint32 nindex, class;
241 MonoMethodSignature *sig;
244 mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, 3);
245 nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
246 class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
247 /*g_print ("methodref: 0x%x 0x%x %s\n", class, nindex,
248 mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));*/
250 mname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
252 ptr = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
253 mono_metadata_decode_blob_size (ptr, &ptr);
254 sig = mono_metadata_parse_method_signature (image, 0, ptr, NULL);
257 case MEMBERREF_PARENT_TYPEREF:
258 klass = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | nindex);
260 g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
261 mono_metadata_free_method_signature (sig);
264 mono_class_init (klass);
265 method = find_method (klass, mname, sig);
267 g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
268 mono_metadata_free_method_signature (sig);
270 case MEMBERREF_PARENT_TYPESPEC: {
271 guint32 bcols [MONO_TYPESPEC_SIZE];
276 mono_metadata_decode_row (&tables [MONO_TABLE_TYPESPEC], nindex - 1,
277 bcols, MONO_TYPESPEC_SIZE);
278 ptr = mono_metadata_blob_heap (image, bcols [MONO_TYPESPEC_SIGNATURE]);
279 len = mono_metadata_decode_value (ptr, &ptr);
280 type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr);
282 if (type->type != MONO_TYPE_ARRAY && type->type != MONO_TYPE_SZARRAY) {
283 klass = mono_class_from_mono_type (type);
284 mono_class_init (klass);
285 method = find_method (klass, mname, sig);
287 g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
288 mono_metadata_free_method_signature (sig);
292 result = (MonoMethod *)g_new0 (MonoMethodPInvoke, 1);
293 result->klass = mono_class_get (image, MONO_TOKEN_TYPE_SPEC | nindex);
294 result->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
295 result->signature = sig;
296 result->name = mname;
298 if (!strcmp (mname, ".ctor")) {
299 /* we special-case this in the runtime. */
304 if (!strcmp (mname, "Set")) {
305 g_assert (sig->hasthis);
306 g_assert (type->data.array->rank + 1 == sig->param_count);
307 result->iflags |= METHOD_IMPL_ATTRIBUTE_RUNTIME;
312 if (!strcmp (mname, "Get")) {
313 g_assert (sig->hasthis);
314 g_assert (type->data.array->rank == sig->param_count);
315 result->iflags |= METHOD_IMPL_ATTRIBUTE_RUNTIME;
320 if (!strcmp (mname, "Address")) {
321 g_assert (sig->hasthis);
322 g_assert (type->data.array->rank == sig->param_count);
323 result->iflags |= METHOD_IMPL_ATTRIBUTE_RUNTIME;
328 g_assert_not_reached ();
332 g_assert_not_reached ();
338 typedef struct MonoDllMap MonoDllMap;
347 static GHashTable *dll_map;
350 mono_dllmap_lookup (const char *dll, const char* func, const char **rdll, const char **rfunc) {
351 MonoDllMap *map, *tmp;
355 map = g_hash_table_lookup (dll_map, dll);
358 *rdll = map->target? map->target: dll;
360 for (tmp = map->next; tmp; tmp = tmp->next) {
361 if (strcmp (func, tmp->name) == 0) {
373 mono_dllmap_insert (const char *dll, const char *func, const char *tdll, const char *tfunc) {
374 MonoDllMap *map, *entry;
377 dll_map = g_hash_table_new (g_str_hash, g_str_equal);
379 map = g_hash_table_lookup (dll_map, dll);
381 map = g_new0 (MonoDllMap, 1);
382 map->dll = g_strdup (dll);
384 map->target = g_strdup (tdll);
385 g_hash_table_insert (dll_map, map->dll, map);
388 entry = g_new0 (MonoDllMap, 1);
389 entry->name = g_strdup (func);
391 entry->target = g_strdup (tfunc);
392 if (tdll && map->target && strcmp (map->target, tdll))
393 entry->dll = g_strdup (tdll);
394 entry->next = map->next;
400 mono_lookup_pinvoke_call (MonoMethod *method)
402 MonoImage *image = method->klass->image;
403 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method;
404 MonoTableInfo *tables = image->tables;
405 MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
406 MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
407 guint32 im_cols [MONO_IMPLMAP_SIZE];
409 const char *import = NULL;
410 const char *scope = NULL;
414 g_assert (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL);
418 if (!piinfo->implmap_idx)
421 mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
423 piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
424 import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
425 scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
426 scope = mono_metadata_string_heap (image, scope_token);
428 mono_dllmap_lookup (scope, import, &scope, &import);
430 full_name = g_module_build_path (NULL, scope);
431 gmodule = g_module_open (full_name, G_MODULE_BIND_LAZY);
434 gchar *error = g_strdup (g_module_error ());
435 if (!(gmodule=g_module_open (scope, G_MODULE_BIND_LAZY))) {
436 g_warning ("Failed to load library %s (%s): %s", full_name, scope, error);
445 g_module_symbol (gmodule, import, &method->addr);
448 g_warning ("Failed to load function %s from %s", import, scope);
455 mono_get_method (MonoImage *image, guint32 token, MonoClass *klass)
458 int table = mono_metadata_token_table (token);
459 int idx = mono_metadata_token_index (token);
460 MonoTableInfo *tables = image->tables;
461 const char *loc, *sig = NULL;
463 guint32 cols [MONO_TYPEDEF_SIZE];
465 if ((result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
468 if (image->assembly->dynamic) {
469 MonoDynamicAssembly *assembly = image->assembly->dynamic;
472 obj = g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
474 if (strcmp (obj->vtable->klass->name, "MonoMethod") == 0) {
475 result = ((MonoReflectionMethod*)obj)->method;
477 else if (strcmp (obj->vtable->klass->name, "MethodBuilder") == 0) {
478 result = ((MonoReflectionMethodBuilder*)obj)->mhandle;
481 g_print (obj->vtable->klass->name);
482 g_assert_not_reached ();
488 if (table != MONO_TABLE_METHOD) {
489 if (table != MONO_TABLE_MEMBERREF)
490 g_print("got wrong token: 0x%08x\n", token);
491 g_assert (table == MONO_TABLE_MEMBERREF);
492 result = method_from_memberref (image, idx);
493 g_hash_table_insert (image->method_cache, GINT_TO_POINTER (token), result);
497 mono_metadata_decode_row (&tables [table], idx - 1, cols, 6);
499 if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
500 (cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
501 result = (MonoMethod *)g_new0 (MonoMethodPInvoke, 1);
503 result = (MonoMethod *)g_new0 (MonoMethodNormal, 1);
506 result->klass = klass;
507 result->flags = cols [2];
508 result->iflags = cols [1];
509 result->token = token;
510 result->name = mono_metadata_string_heap (image, cols [3]);
512 if (!sig) /* already taken from the methodref */
513 sig = mono_metadata_blob_heap (image, cols [4]);
514 size = mono_metadata_decode_blob_size (sig, &sig);
515 result->signature = mono_metadata_parse_method_signature (image, idx, sig, NULL);
517 if (!result->klass) {
518 guint32 type = mono_metadata_typedef_from_method (image, token);
519 result->klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | type);
522 if (cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
523 if (result->klass == mono_defaults.string_class && !strcmp (result->name, ".ctor"))
524 result->string_ctor = 1;
526 result->addr = mono_lookup_internal_call (result);
527 result->signature->pinvoke = 1;
528 } else if (cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
529 result->signature->pinvoke = 1;
530 ((MonoMethodPInvoke *)result)->implmap_idx = mono_metadata_implmap_from_method (image, idx - 1);
532 /* if this is a methodref from another module/assembly, this fails */
533 loc = mono_cli_rva_map ((MonoCLIImageInfo *)image->image_info, cols [0]);
535 if (!result->klass->dummy && !(result->flags & METHOD_ATTRIBUTE_ABSTRACT) &&
536 !(result->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
538 ((MonoMethodNormal *)result)->header = mono_metadata_parse_mh (image, loc);
542 g_hash_table_insert (image->method_cache, GINT_TO_POINTER (token), result);
548 mono_free_method (MonoMethod *method)
550 mono_metadata_free_method_signature (method->signature);
551 if (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
552 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method;
553 g_free (piinfo->code);
554 } else if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) {
555 mono_metadata_free_mh (((MonoMethodNormal *)method)->header);
562 mono_method_get_param_names (MonoMethod *method, const char **names)
565 MonoClass *klass = method->klass;
566 MonoTableInfo *methodt;
567 MonoTableInfo *paramt;
569 if (!method->signature->param_count)
571 for (i = 0; i < method->signature->param_count; ++i)
574 mono_class_init (klass);
576 if (klass->wastypebuilder) /* copy the names later */
579 methodt = &klass->image->tables [MONO_TABLE_METHOD];
580 paramt = &klass->image->tables [MONO_TABLE_PARAM];
581 for (i = 0; i < klass->method.count; ++i) {
582 if (method == klass->methods [i]) {
583 guint32 idx = klass->method.first + i;
584 guint32 cols [MONO_PARAM_SIZE];
585 guint param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
587 if (idx + 1 < methodt->rows)
588 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
590 lastp = paramt->rows + 1;
591 for (i = param_index; i < lastp; ++i) {
592 mono_metadata_decode_row (paramt, i -1, cols, MONO_PARAM_SIZE);
593 if (cols [MONO_PARAM_SEQUENCE]) /* skip return param spec */
594 names [cols [MONO_PARAM_SEQUENCE] - 1] = mono_metadata_string_heap (klass->image, cols [MONO_PARAM_NAME]);
602 mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs)
605 MonoClass *klass = method->klass;
606 MonoTableInfo *methodt;
607 MonoTableInfo *paramt;
609 for (i = 0; i < method->signature->param_count + 1; ++i)
612 mono_class_init (klass);
614 methodt = &klass->image->tables [MONO_TABLE_METHOD];
615 paramt = &klass->image->tables [MONO_TABLE_PARAM];
617 for (i = 0; i < klass->method.count; ++i) {
618 if (method == klass->methods [i]) {
619 guint32 idx = klass->method.first + i;
620 guint32 cols [MONO_PARAM_SIZE];
621 guint param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
623 if (idx + 1 < methodt->rows)
624 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
626 lastp = paramt->rows + 1;
628 for (i = param_index; i < lastp; ++i) {
629 mono_metadata_decode_row (paramt, i -1, cols, MONO_PARAM_SIZE);
631 if (cols [MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_FIELD_MARSHAL) {
633 tp = mono_metadata_get_marshal_info (klass->image, i - 1, FALSE);
635 mspecs [cols [MONO_PARAM_SEQUENCE]]= mono_metadata_parse_marshal_spec (klass->image, tp);
644 mono_method_get_wrapper_data (MonoMethod *method, guint32 id)
647 g_assert (method != NULL);
648 g_assert (method->wrapper_type != MONO_WRAPPER_NONE);
650 if (!(l = g_list_nth (((MonoMethodWrapper *)method)->data, id - 1)))
651 g_assert_not_reached ();
657 default_stack_walk (MonoStackWalk func, gpointer user_data) {
658 g_error ("stack walk not installed");
661 static MonoStackWalkImpl stack_walk = default_stack_walk;
664 mono_stack_walk (MonoStackWalk func, gpointer user_data)
666 stack_walk (func, user_data);
670 mono_install_stack_walk (MonoStackWalkImpl func)
676 last_managed (MonoMethod *m, gint no, gint ilo, gboolean managed, gpointer data)
678 MonoMethod **dest = data;
680 /*g_print ("In %s::%s [%d] [%d]\n", m->klass->name, m->name, no, ilo);*/
686 mono_method_get_last_managed (void)
688 MonoMethod *m = NULL;
689 stack_walk (last_managed, &m);