#ifdef __CYGWIN__
#define mono_map_dll(name) (name)
#else
-static char *dll_map[] = {
+static const char *dll_map[] = {
"libc", "libc.so.6",
"libm", "libm.so.6",
"cygwin1.dll", "libc.so.6",
}
#endif
-void
-mono_init (void)
-{
- static gboolean initialized = FALSE;
- MonoAssembly *ass;
- enum MonoImageOpenStatus status = MONO_IMAGE_OK;
-
- if (initialized)
- return;
-
- /* find the corlib */
- ass = mono_assembly_open (CORLIB_NAME, NULL, &status);
- g_assert (status == MONO_IMAGE_OK);
- g_assert (ass != NULL);
- mono_defaults.corlib = ass->image;
-
- mono_defaults.object_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Object");
- g_assert (mono_defaults.object_class != 0);
-
- mono_defaults.void_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Void");
- g_assert (mono_defaults.void_class != 0);
-
- mono_defaults.boolean_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Boolean");
- g_assert (mono_defaults.boolean_class != 0);
-
- mono_defaults.byte_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Byte");
- g_assert (mono_defaults.byte_class != 0);
-
- mono_defaults.sbyte_class = mono_class_from_name (
- mono_defaults.corlib, "System", "SByte");
- g_assert (mono_defaults.sbyte_class != 0);
-
- mono_defaults.int16_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Int16");
- g_assert (mono_defaults.int16_class != 0);
-
- mono_defaults.uint16_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UInt16");
- g_assert (mono_defaults.uint16_class != 0);
-
- mono_defaults.int32_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Int32");
- g_assert (mono_defaults.int32_class != 0);
-
- mono_defaults.uint32_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UInt32");
- g_assert (mono_defaults.uint32_class != 0);
-
- mono_defaults.uint_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UIntPtr");
- g_assert (mono_defaults.uint_class != 0);
-
- mono_defaults.int_class = mono_class_from_name (
- mono_defaults.corlib, "System", "IntPtr");
- g_assert (mono_defaults.int_class != 0);
-
- mono_defaults.int64_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Int64");
- g_assert (mono_defaults.int64_class != 0);
-
- mono_defaults.uint64_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UInt64");
- g_assert (mono_defaults.uint64_class != 0);
-
- mono_defaults.single_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Single");
- g_assert (mono_defaults.single_class != 0);
-
- mono_defaults.double_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Double");
- g_assert (mono_defaults.double_class != 0);
-
- mono_defaults.char_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Char");
- g_assert (mono_defaults.char_class != 0);
-
- mono_defaults.string_class = mono_class_from_name (
- mono_defaults.corlib, "System", "String");
- g_assert (mono_defaults.string_class != 0);
-
- mono_defaults.enum_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Enum");
- g_assert (mono_defaults.enum_class != 0);
-
- mono_defaults.array_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Array");
- g_assert (mono_defaults.array_class != 0);
-
- mono_defaults.delegate_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Delegate");
- g_assert (mono_defaults.delegate_class != 0);
-
- mono_defaults.typehandle_class = mono_class_from_name (
- mono_defaults.corlib, "System", "RuntimeTypeHandle");
- g_assert (mono_defaults.typehandle_class != 0);
-
- mono_defaults.methodhandle_class = mono_class_from_name (
- mono_defaults.corlib, "System", "RuntimeMethodHandle");
- g_assert (mono_defaults.methodhandle_class != 0);
-
- mono_defaults.fieldhandle_class = mono_class_from_name (
- mono_defaults.corlib, "System", "RuntimeFieldHandle");
- g_assert (mono_defaults.fieldhandle_class != 0);
-
- mono_defaults.type_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Type");
- g_assert (mono_defaults.type_class != 0);
-
-}
-
static GHashTable *icall_hash = NULL;
void
-mono_add_internal_call (const char *name, gpointer method)
+mono_add_internal_call (const char *name, gconstpointer method)
{
if (!icall_hash) {
dummy_icall = FALSE;
}
static void
-ves_icall_dummy ()
+ves_icall_dummy (void)
{
g_warning ("the mono runtime is not initialized");
g_assert_not_reached ();
return res;
}
+MonoClassField*
+mono_field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass)
+{
+ MonoImage *mimage;
+ MonoClass *klass;
+ MonoTableInfo *tables = image->tables;
+ guint32 cols[6];
+ guint32 nindex, class, i;
+ const char *fname, *name, *nspace;
+ const char *ptr;
+ guint32 idx = mono_metadata_token_index (token);
+
+ mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
+ nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
+ class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
+
+ fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
+
+ ptr = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
+ mono_metadata_decode_blob_size (ptr, &ptr);
+ /* we may want to check the signature here... */
+
+ switch (class) {
+ case MEMBERREF_PARENT_TYPEREF: {
+ guint32 scopeindex, scopetable;
+
+ mono_metadata_decode_row (&tables [MONO_TABLE_TYPEREF], nindex-1, cols, MONO_TYPEREF_SIZE);
+ scopeindex = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
+ scopetable = cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
+ /*g_print ("typeref: 0x%x 0x%x %s.%s\n", scopetable, scopeindex,
+ mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]),
+ mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]));*/
+ switch (scopetable) {
+ case RESOLTION_SCOPE_ASSEMBLYREF:
+ /*
+ * To find the field we have the following info:
+ * *) name and namespace of the class from the TYPEREF table
+ * *) name and signature of the field from the MEMBERREF table
+ */
+ nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
+ name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
+
+ /* this will triggered by references to mscorlib */
+ if (image->references [scopeindex-1] == NULL)
+ g_error ("Reference to mscorlib? Probably need to implement %s.%s::%s in corlib", nspace, name, fname);
+
+ mimage = image->references [scopeindex-1]->image;
+
+ klass = mono_class_from_name (mimage, nspace, name);
+ mono_class_init (klass);
+
+ /* mostly dumb search for now */
+ for (i = 0; i < klass->field.count; ++i) {
+ MonoClassField *f = &klass->fields [i];
+ if (!strcmp (fname, f->name)) {
+ if (retklass)
+ *retklass = klass;
+ return f;
+ }
+ }
+ g_warning ("Missing field %s.%s::%s", nspace, name, fname);
+ return NULL;
+ default:
+ return NULL;
+ }
+ break;
+ }
+ default:
+ return NULL;
+ }
+}
+
static MonoMethod *
-method_from_memberref (MonoImage *image, guint32 index)
+method_from_memberref (MonoImage *image, guint32 idx)
{
MonoImage *mimage;
MonoClass *klass;
MonoMethodSignature *sig;
const char *ptr;
- mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], index-1, cols, 3);
+ mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, 3);
nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
/*g_print ("methodref: 0x%x 0x%x %s\n", class, nindex,
mimage = image->references [scopeindex-1]->image;
klass = mono_class_from_name (mimage, nspace, name);
- mono_class_metadata_init (klass);
-
- /*
- * FIXME: this is a workaround for the different signatures
- * in delegates constructors you get in user code (native int)
- * and in mscorlib (native unsigned int)
- */
- if (klass->parent && klass->parent->parent == mono_defaults.delegate_class) {
- for (i = 0; i < klass->method.count; ++i) {
- MonoMethod *m = klass->methods [i];
- if (!strcmp (mname, m->name)) {
- if (!strcmp (mname, ".ctor")) {
- /* we assume signature is correct */
- mono_metadata_free_method_signature (sig);
- return m;
- }
- if (mono_metadata_signature_equal (sig, m->signature)) {
- mono_metadata_free_method_signature (sig);
- return m;
- }
- }
- }
+ if (!klass) {
+ g_warning ("Missing method %s.%s::%s", nspace, name, mname);
+ mono_metadata_free_method_signature (sig);
+ return NULL;
}
+ mono_class_init (klass);
+
/* mostly dumb search for now */
for (i = 0; i < klass->method.count; ++i) {
MonoMethod *m = klass->methods [i];
g_assert_not_reached ();
result = (MonoMethod *)g_new0 (MonoMethodPInvoke, 1);
- result->klass = mono_defaults.array_class;
+ result->klass = mono_class_get (image, MONO_TOKEN_TYPE_SPEC | nindex);
result->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
result->signature = sig;
result->name = mname;
- if (!strcmp (mname, ".ctor")) {
- g_assert (sig->hasthis);
- if (type->data.array->rank == sig->param_count) {
- result->addr = mono_lookup_internal_call ("__array_ctor");
- } else if ((type->data.array->rank * 2) == sig->param_count) {
- result->addr = mono_lookup_internal_call ("__array_bound_ctor");
- } else
- g_assert_not_reached ();
-
- result->flags = METHOD_ATTRIBUTE_PINVOKE_IMPL;
- return result;
+ if (!strcmp (mname, ".ctor")) {
+ /* we special-case this in the runtime. */
+ result->addr = NULL;
+ return result;
}
-
+
if (!strcmp (mname, "Set")) {
g_assert (sig->hasthis);
g_assert (type->data.array->rank + 1 == sig->param_count);
return result;
}
+ if (!strcmp (mname, "Address")) {
+ g_assert (sig->hasthis);
+ g_assert (type->data.array->rank == sig->param_count);
+
+ result->addr = mono_lookup_internal_call ("__array_Address");
+ return result;
+ }
+
g_assert_not_reached ();
break;
}
}
static void
-fill_pinvoke_info (MonoImage *image, MonoMethodPInvoke *piinfo, int index)
+fill_pinvoke_info (MonoImage *image, MonoMethodPInvoke *piinfo, int idx)
{
MonoMethod *mh = &piinfo->method;
MonoTableInfo *tables = image->tables;
mono_metadata_decode_row (im, i, im_cols, 4);
- if ((im_cols[1] >> 1) == index + 1) {
+ if ((im_cols[1] >> 1) == idx + 1) {
import = mono_metadata_string_heap (image, im_cols [2]);
{
MonoMethod *result;
int table = mono_metadata_token_table (token);
- int index = mono_metadata_token_index (token);
+ int idx = mono_metadata_token_index (token);
MonoTableInfo *tables = image->tables;
const char *loc, *sig = NULL;
char *name;
int size;
guint32 cols [MONO_TYPEDEF_SIZE];
- if (table == MONO_TABLE_METHOD && (result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
+ if ((result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
return result;
if (table != MONO_TABLE_METHOD) {
+ if (table != MONO_TABLE_MEMBERREF)
+ g_print("got wrong token: 0x%08x\n", token);
g_assert (table == MONO_TABLE_MEMBERREF);
- return method_from_memberref (image, index);
+ result = method_from_memberref (image, idx);
+ g_hash_table_insert (image->method_cache, GINT_TO_POINTER (token), result);
+ return result;
}
- mono_metadata_decode_row (&tables [table], index - 1, cols, 6);
+ mono_metadata_decode_row (&tables [table], idx - 1, cols, 6);
if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
(cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
else
result = (MonoMethod *)g_new0 (MonoMethodNormal, 1);
+ result->slot = -1;
result->klass = klass;
result->flags = cols [2];
result->iflags = cols [1];
g_free (name);
result->flags |= METHOD_ATTRIBUTE_PINVOKE_IMPL;
} else if (cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
- fill_pinvoke_info (image, (MonoMethodPInvoke *)result, index - 1);
+ fill_pinvoke_info (image, (MonoMethodPInvoke *)result, idx - 1);
} else {
/* if this is a methodref from another module/assembly, this fails */
loc = mono_cli_rva_map ((MonoCLIImageInfo *)image->image_info, cols [0]);
g_free (method);
}
+void
+mono_method_get_param_names (MonoMethod *method, const char **names)
+{
+ int i, lastp;
+ MonoClass *klass = method->klass;
+ MonoTableInfo *methodt = &klass->image->tables [MONO_TABLE_METHOD];
+ MonoTableInfo *paramt = &klass->image->tables [MONO_TABLE_PARAM];
+
+ if (!method->signature->param_count)
+ return;
+ for (i = 0; i < method->signature->param_count; ++i)
+ names [i] = "";
+
+ mono_class_init (klass);
+ if (!klass->methods)
+ return;
+
+ for (i = 0; i < klass->method.count; ++i) {
+ if (method == klass->methods [i]) {
+ guint32 idx = klass->method.first + i;
+ guint32 cols [MONO_PARAM_SIZE];
+ guint param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
+
+ if (idx < methodt->rows)
+ lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
+ else
+ lastp = paramt->rows;
+ for (i = param_index; i < lastp; ++i) {
+ mono_metadata_decode_row (paramt, i -1, cols, MONO_PARAM_SIZE);
+ if (cols [MONO_PARAM_SEQUENCE]) /* skip return param spec */
+ names [cols [MONO_PARAM_SEQUENCE] - 1] = mono_metadata_string_heap (klass->image, cols [MONO_PARAM_NAME]);
+ }
+ return;
+ }
+ }
+}
+