X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Ficall.c;h=de0582b7cc1cf8f5f649054f9fc32d3f36bc231e;hb=256e3ee192da85cf7c09a3890c06f7bc448ac817;hp=cccf45d42c0fc3c69818522c6ed417d75ce574e5;hpb=96c46ddad421fad6b381c00d38bec5804c5191e2;p=mono.git diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index cccf45d42c0..de0582b7cc1 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -63,7 +63,7 @@ #include #include #include -#include +#include #include #include #include @@ -841,41 +841,37 @@ ves_icall_System_Array_SetGenericValueImpl (MonoArray *arr, guint32 pos, gpointe } ICALL_EXPORT void -ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle) +ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArrayHandle array, MonoClassField *field_handle, MonoError *error) { - MonoClass *klass = array->obj.vtable->klass; + mono_error_init (error); + + MonoClass *klass = mono_handle_class (array); guint32 size = mono_array_element_size (klass); MonoType *type = mono_type_get_underlying_type (&klass->element_class->byval_arg); int align; const char *field_data; if (MONO_TYPE_IS_REFERENCE (type) || type->type == MONO_TYPE_VALUETYPE) { - MonoException *exc = mono_get_exception_argument("array", - "Cannot initialize array of non-primitive type."); - mono_set_pending_exception (exc); + mono_error_set_argument (error, "array", "Cannot initialize array of non-primitive type"); return; } if (!(field_handle->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) { - MonoException *exc = mono_get_exception_argument("field_handle", - "Field doesn't have an RVA"); - mono_set_pending_exception (exc); + mono_error_set_argument (error, "field_handle", "Field '%s' doesn't have an RVA", mono_field_get_name (field_handle)); return; } - size *= array->max_length; + size *= MONO_HANDLE_GETVAL(array, max_length); field_data = mono_field_get_data (field_handle); if (size > mono_type_size (field_handle->type, &align)) { - MonoException *exc = mono_get_exception_argument("field_handle", - "Field not large enough to fill array"); - mono_set_pending_exception (exc); + mono_error_set_argument (error, "field_handle", "Field not large enough to fill array"); return; } #if G_BYTE_ORDER != G_LITTLE_ENDIAN #define SWAP(n) { \ - guint ## n *data = (guint ## n *) mono_array_addr (array, char, 0); \ + guint ## n *data = (guint ## n *) mono_array_addr (MONO_HANDLE_RAW(array), char, 0); \ guint ## n *src = (guint ## n *) field_data; \ int i, \ nEnt = (size / sizeof(guint ## n)); \ @@ -904,11 +900,11 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoAr SWAP (64); break; default: - memcpy (mono_array_addr (array, char, 0), field_data, size); + memcpy (mono_array_addr (MONO_HANDLE_RAW(array), char, 0), field_data, size); break; } #else - memcpy (mono_array_addr (array, char, 0), field_data, size); + memcpy (mono_array_addr (MONO_HANDLE_RAW(array), char, 0), field_data, size); #endif } @@ -1002,6 +998,10 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStac // .net seems to check that at least 50% of stack is available min_size = thread->stack_size / 2; + // TODO: It's not always set + if (!min_size) + return TRUE; + current = (guint8 *)&stack_addr; if (current > stack_addr) { if ((current - stack_addr) < min_size) @@ -1302,7 +1302,7 @@ get_caller_no_system_or_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboole } static MonoReflectionType * -type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoError *error) +type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoAssembly **caller_assembly, MonoError *error) { MonoMethod *m, *dest; @@ -1353,6 +1353,7 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoErro } else { g_warning (G_STRLOC); } + *caller_assembly = assembly; if (info->assembly.name) assembly = mono_assembly_load (&info->assembly, assembly ? assembly->basedir : NULL, NULL); @@ -1397,6 +1398,7 @@ ves_icall_System_Type_internal_from_name (MonoString *name, MonoTypeNameParse info; MonoReflectionType *type = NULL; gboolean parsedOk; + MonoAssembly *caller_assembly; char *str = mono_string_to_utf8_checked (name, &error); if (!is_ok (&error)) @@ -1412,18 +1414,27 @@ ves_icall_System_Type_internal_from_name (MonoString *name, goto leave; } - type = type_from_parsed_name (&info, ignoreCase, &error); + type = type_from_parsed_name (&info, ignoreCase, &caller_assembly, &error); - mono_reflection_free_type_info (&info); - - if (!is_ok (&error)) + if (!is_ok (&error)) { + mono_reflection_free_type_info (&info); goto leave; + } - if (type == NULL){ + if (type == NULL) { if (throwOnError) { - mono_error_set_type_load_name (&error, g_strdup (str), g_strdup (""), ""); - goto leave; + char *tname = info.name_space ? g_strdup_printf ("%s.%s", info.name_space, info.name) : g_strdup (info.name); + char *aname; + if (info.assembly.name) + aname = mono_stringify_assembly_name (&info.assembly); + else if (caller_assembly) + aname = mono_stringify_assembly_name (mono_assembly_get_name (caller_assembly)); + else + aname = g_strdup (""); + mono_error_set_type_load_name (&error, tname, aname, ""); } + mono_reflection_free_type_info (&info); + goto leave; } leave: @@ -1584,13 +1595,6 @@ handle_enum: return 0; } -static gboolean -mono_type_is_primitive (MonoType *type) -{ - return (type->type >= MONO_TYPE_BOOLEAN && type->type <= MONO_TYPE_R8) || - type-> type == MONO_TYPE_I || type->type == MONO_TYPE_U; -} - static MonoType* mono_type_get_underlying_type_ignore_byref (MonoType *type) { @@ -2087,12 +2091,12 @@ ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *rfield) if (image_is_dynamic (field->parent->image)) { MonoClass *klass = field->parent; int fidx = field - klass->fields; + MonoFieldDefaultValue *def_values = mono_class_get_field_def_values (klass); + + g_assert (def_values); + def_type = def_values [fidx].def_type; + def_value = def_values [fidx].data; - g_assert (fidx >= 0 && fidx < klass->field.count); - g_assert (klass->ext); - g_assert (klass->ext->field_def_values); - def_type = klass->ext->field_def_values [fidx].def_type; - def_value = klass->ext->field_def_values [fidx].data; if (def_type == MONO_TYPE_END) { mono_set_pending_exception (mono_get_exception_invalid_operation (NULL)); return NULL; @@ -2601,15 +2605,14 @@ ves_icall_reflection_get_token (MonoObject* obj) return result; } -ICALL_EXPORT MonoReflectionModule* -ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionType *type) +ICALL_EXPORT MonoReflectionModuleHandle +ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionTypeHandle type, MonoError *error) { - MonoError error; - MonoReflectionModule *result = NULL; - MonoClass *klass = mono_class_from_mono_type (type->type); - result = mono_module_get_object_checked (mono_object_domain (type), klass->image, &error); - mono_error_set_pending_exception (&error); - return result; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (type); + MonoType *t = MONO_HANDLE_GETVAL (type, type); + MonoClass *klass = mono_class_from_mono_type (t); + return mono_module_get_object_handle (domain, klass->image, error); } ICALL_EXPORT MonoReflectionAssembly* @@ -3175,7 +3178,7 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this_arg, Mo return NULL; } - if ((mono_class_get_flags (m->klass) & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this_arg) { + if (mono_class_is_abstract (m->klass) && !strcmp (m->name, ".ctor") && !this_arg) { mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.")); return NULL; } @@ -3634,64 +3637,77 @@ ves_icall_System_Enum_get_hashcode (MonoObject *eobj) return 0; } +static void +get_enum_field (MonoDomain *domain, MonoArrayHandle names, MonoArrayHandle values, int base_type, MonoClassField *field, guint* j, guint64 *previous_value, gboolean *sorted, MonoError *error) +{ + mono_error_init (error); + HANDLE_FUNCTION_ENTER(); + guint64 field_value; + const char *p; + MonoTypeEnum def_type; + + if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) + goto leave; + if (strcmp ("value__", mono_field_get_name (field)) == 0) + goto leave; + if (mono_field_is_deleted (field)) + goto leave; + MonoStringHandle name = mono_string_new_handle (domain, mono_field_get_name (field), error); + if (!is_ok (error)) + goto leave; + MONO_HANDLE_ARRAY_SETREF (names, *j, name); + + p = mono_class_get_field_default_value (field, &def_type); + /* len = */ mono_metadata_decode_blob_size (p, &p); + + field_value = read_enum_value (p, base_type); + MONO_HANDLE_ARRAY_SETVAL (values, guint64, *j, field_value); + + if (*previous_value > field_value) + *sorted = FALSE; + + *previous_value = field_value; + (*j)++; +leave: + HANDLE_FUNCTION_RETURN(); +} + ICALL_EXPORT MonoBoolean -ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionType *type, MonoArray **values, MonoArray **names) +ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionTypeHandle type, MonoArrayHandleOut values, MonoArrayHandleOut names, MonoError *error) { - MonoError error; - MonoDomain *domain = mono_object_domain (type); - MonoClass *enumc = mono_class_from_mono_type (type->type); + MonoDomain *domain = MONO_HANDLE_DOMAIN (type); + MonoClass *enumc = mono_class_from_mono_type (MONO_HANDLE_RAW(type)->type); guint j = 0, nvalues; gpointer iter; MonoClassField *field; int base_type; - guint64 field_value, previous_value = 0; + guint64 previous_value = 0; gboolean sorted = TRUE; - mono_class_init_checked (enumc, &error); - if (mono_error_set_pending_exception (&error)) - return FALSE; - + mono_error_init (error); + mono_class_init_checked (enumc, error); + return_val_if_nok (error, FALSE); if (!enumc->enumtype) { - mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum.")); + mono_error_set_argument (error, "enumType", "Type provided must be an Enum."); return TRUE; } base_type = mono_class_enum_basetype (enumc)->type; - nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0; - *names = mono_array_new_checked (domain, mono_defaults.string_class, nvalues, &error); - if (mono_error_set_pending_exception (&error)) - return FALSE; - *values = mono_array_new_checked (domain, mono_defaults.uint64_class, nvalues, &error); - if (mono_error_set_pending_exception (&error)) - return FALSE; + nvalues = mono_class_num_fields (enumc) > 0 ? mono_class_num_fields (enumc) - 1 : 0; + MONO_HANDLE_ASSIGN(names, mono_array_new_handle (domain, mono_defaults.string_class, nvalues, error)); + return_val_if_nok (error, FALSE); + MONO_HANDLE_ASSIGN(values, mono_array_new_handle (domain, mono_defaults.uint64_class, nvalues, error)); + return_val_if_nok (error, FALSE); iter = NULL; while ((field = mono_class_get_fields (enumc, &iter))) { - const char *p; - MonoTypeEnum def_type; - - if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) - continue; - if (strcmp ("value__", mono_field_get_name (field)) == 0) - continue; - if (mono_field_is_deleted (field)) - continue; - mono_array_setref (*names, j, mono_string_new (domain, mono_field_get_name (field))); - - p = mono_class_get_field_default_value (field, &def_type); - /* len = */ mono_metadata_decode_blob_size (p, &p); - - field_value = read_enum_value (p, base_type); - mono_array_set (*values, guint64, j, field_value); - - if (previous_value > field_value) - sorted = FALSE; - - previous_value = field_value; - ++j; + get_enum_field(domain, names, values, base_type, field, &j, &previous_value, &sorted, error); + if (!is_ok (error)) + break; } + return_val_if_nok (error, FALSE); return sorted; } @@ -4591,15 +4607,13 @@ leave: return res; } -ICALL_EXPORT MonoReflectionModule* -ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly) +ICALL_EXPORT MonoReflectionModuleHandle +ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssemblyHandle assembly, MonoError *error) { - MonoError error; - MonoReflectionModule *result = NULL; - result = mono_module_get_object_checked (mono_object_domain (assembly), assembly->assembly->image, &error); - if (!mono_error_ok (&error)) - mono_error_set_pending_exception (&error); - return result; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly); + MonoAssembly *a = MONO_HANDLE_GETVAL (assembly, assembly); + return mono_module_get_object_handle (domain, a->image, error); } ICALL_EXPORT MonoArray* @@ -4644,138 +4658,47 @@ ves_icall_System_Reflection_Assembly_GetAotId (MonoError *error) return res; } -static MonoObject* -create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision, MonoError *error) +static MonoAssemblyName* +create_referenced_assembly_name (MonoDomain *domain, MonoImage *image, MonoTableInfo *t, int i, MonoError *error) { - static MonoMethod *create_version = NULL; - MonoObject *result; - gpointer args [4]; - mono_error_init (error); - - - if (!create_version) { - MonoMethodDesc *desc = mono_method_desc_new (":.ctor(int,int,int,int)", FALSE); - create_version = mono_method_desc_search_in_class (desc, mono_class_get_system_version_class ()); - g_assert (create_version); - mono_method_desc_free (desc); - } - - args [0] = &major; - args [1] = &minor; - args [2] = &build; - args [3] = &revision; - result = mono_object_new_checked (domain, mono_class_get_system_version_class (), error); - return_val_if_nok (error, NULL); - - mono_runtime_invoke_checked (create_version, result, args, error); - return_val_if_nok (error, NULL); - - return result; + MonoAssemblyName *aname = g_new0 (MonoAssemblyName, 1); + + mono_assembly_get_assemblyref (image, i, aname); + aname->hash_alg = ASSEMBLY_HASH_SHA1 /* SHA1 (default) */; + /* name and culture are pointers into the image tables, but we need + * real malloc'd strings (so that we can g_free() them later from + * Mono.RuntimeMarshal.FreeAssemblyName) */ + aname->name = g_strdup (aname->name); + aname->culture = g_strdup (aname->culture); + /* Don't need the hash value in managed */ + aname->hash_value = NULL; + aname->hash_len = 0; + g_assert (aname->public_key == NULL); + + /* note: this function doesn't return the codebase on purpose (i.e. it can + be used under partial trust as path information isn't present). */ + return aname; } -ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly) +ICALL_EXPORT GPtrArray* +ves_icall_System_Reflection_Assembly_InternalGetReferencedAssemblies (MonoReflectionAssemblyHandle assembly, MonoError *error) { - MonoError error; - MonoArray *result; - MonoDomain *domain = mono_object_domain (assembly); - int i, count = 0; - static MonoMethod *create_culture = NULL; - MonoImage *image = assembly->assembly->image; - MonoTableInfo *t; - MonoObject *o; - - t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF]; - count = t->rows; - - result = mono_array_new_checked (domain, mono_class_get_assembly_name_class (), count, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - - if (count > 0 && !create_culture) { - MonoMethodDesc *desc = mono_method_desc_new ( - "System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE); - create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib); - g_assert (create_culture); - mono_method_desc_free (desc); - } - - for (i = 0; i < count; i++) { - MonoObject *version; - MonoReflectionAssemblyName *aname; - guint32 cols [MONO_ASSEMBLYREF_SIZE]; - - mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE); - - aname = (MonoReflectionAssemblyName *) mono_object_new_checked ( - domain, mono_class_get_assembly_name_class (), &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]))); - - aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION]; - aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION]; - aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER]; - aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER]; - aname->flags = cols [MONO_ASSEMBLYREF_FLAGS]; - aname->versioncompat = 1; /* SameMachine (default) */ - aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */ - - version = create_version (domain, aname->major, aname->minor, aname->build, aname->revision, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - MONO_OBJECT_SETREF (aname, version, version); - - if (create_culture) { - gpointer args [2]; - MonoBoolean assembly_ref = 1; - args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE])); - args [1] = &assembly_ref; - - o = mono_runtime_invoke_checked (create_culture, NULL, args, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - MONO_OBJECT_SETREF (aname, cultureInfo, o); - } - - if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) { - const gchar *pkey_ptr = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]); - guint32 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr); - - if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) { - /* public key token isn't copied - the class library will - automatically generate it from the public key if required */ - MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - MONO_OBJECT_SETREF (aname, publicKey, pkey); - memcpy (mono_array_addr (pkey, guint8, 0), pkey_ptr, pkey_len); - } else { - MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly); + MonoAssembly *ass = MONO_HANDLE_GETVAL(assembly, assembly); + MonoImage *image = ass->image; - MONO_OBJECT_SETREF (aname, keyToken, keyToken); - memcpy (mono_array_addr (keyToken, guint8, 0), pkey_ptr, pkey_len); - } - } else { - MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLYREF]; + int count = t->rows; - MONO_OBJECT_SETREF (aname, keyToken, keyToken); - } - - /* note: this function doesn't return the codebase on purpose (i.e. it can - be used under partial trust as path information isn't present). */ + GPtrArray *result = g_ptr_array_sized_new (count); - mono_array_setref (result, i, aname); + for (int i = 0; i < count; i++) { + MonoAssemblyName *aname = create_referenced_assembly_name (domain, image, t, i, error); + if (!is_ok (error)) + break; + g_ptr_array_add (result, aname); } return result; } @@ -4798,23 +4721,24 @@ g_concat_dir_and_file (const char *dir, const char *file) } ICALL_EXPORT void * -ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module) +ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, gint32 *size, MonoReflectionModuleHandleOut ref_module, MonoError *error) { - MonoError error; - MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h); + MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly); + MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; guint32 i; guint32 cols [MONO_MANIFEST_SIZE]; guint32 impl, file_idx; const char *val; MonoImage *module; - char *n = mono_string_to_utf8_checked (name, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + char *n = mono_string_handle_to_utf8 (name, error); + return_val_if_nok (error, NULL); for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); - val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); + val = mono_metadata_string_heap (assembly->image, cols [MONO_MANIFEST_NAME]); if (strcmp (val, n) == 0) break; } @@ -4831,84 +4755,87 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflection g_assert ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE); file_idx = impl >> MONO_IMPLEMENTATION_BITS; - module = mono_image_load_file_for_image_checked (assembly->assembly->image, file_idx, &error); - if (mono_error_set_pending_exception (&error) || !module) + module = mono_image_load_file_for_image_checked (assembly->image, file_idx, error); + if (!is_ok (error) || !module) return NULL; } else - module = assembly->assembly->image; + module = assembly->image; - MonoReflectionModule *rm = mono_module_get_object_checked (mono_domain_get (), module, &error); - if (mono_error_set_pending_exception (&error)) + MonoReflectionModuleHandle rm = mono_module_get_object_handle (domain, module, error); + if (!is_ok (error)) return NULL; - mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) rm); + MONO_HANDLE_ASSIGN (ref_module, rm); return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size); } -ICALL_EXPORT gboolean -ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info) +static gboolean +get_manifest_resource_info_internal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, MonoManifestResourceInfoHandle info, MonoError *error) { - MonoError error; - MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; + HANDLE_FUNCTION_ENTER (); + MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h); + MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly); + MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; int i; guint32 cols [MONO_MANIFEST_SIZE]; guint32 file_cols [MONO_FILE_SIZE]; const char *val; char *n; - n = mono_string_to_utf8_checked (name, &error); - if (mono_error_set_pending_exception (&error)) - return FALSE; + gboolean result = FALSE; + + n = mono_string_handle_to_utf8 (name, error); + if (!is_ok (error)) + goto leave; + for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); - val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); + val = mono_metadata_string_heap (assembly->image, cols [MONO_MANIFEST_NAME]); if (strcmp (val, n) == 0) break; } g_free (n); if (i == table->rows) - return FALSE; + goto leave; if (!cols [MONO_MANIFEST_IMPLEMENTATION]) { - info->location = RESOURCE_LOCATION_EMBEDDED | RESOURCE_LOCATION_IN_MANIFEST; + MONO_HANDLE_SETVAL (info, location, guint32, RESOURCE_LOCATION_EMBEDDED | RESOURCE_LOCATION_IN_MANIFEST); } else { switch (cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) { case MONO_IMPLEMENTATION_FILE: i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS; - table = &assembly->assembly->image->tables [MONO_TABLE_FILE]; + table = &assembly->image->tables [MONO_TABLE_FILE]; mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE); - val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]); - MONO_OBJECT_SETREF (info, filename, mono_string_new (mono_object_domain (assembly), val)); + val = mono_metadata_string_heap (assembly->image, file_cols [MONO_FILE_NAME]); + MONO_HANDLE_SET (info, filename, mono_string_new_handle (domain, val, error)); if (file_cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA) - info->location = 0; + MONO_HANDLE_SETVAL (info, location, guint32, 0); else - info->location = RESOURCE_LOCATION_EMBEDDED; + MONO_HANDLE_SETVAL (info, location, guint32, RESOURCE_LOCATION_EMBEDDED); break; case MONO_IMPLEMENTATION_ASSEMBLYREF: i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS; - mono_assembly_load_reference (assembly->assembly->image, i - 1); - if (assembly->assembly->image->references [i - 1] == (gpointer)-1) { - char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name); - MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL); - g_free (msg); - mono_set_pending_exception (ex); - return FALSE; - } - MonoReflectionAssembly *assm_obj; - assm_obj = mono_assembly_get_object_checked (mono_domain_get (), assembly->assembly->image->references [i - 1], &error); - if (!assm_obj) { - mono_error_set_pending_exception (&error); - return FALSE; + mono_assembly_load_reference (assembly->image, i - 1); + if (assembly->image->references [i - 1] == REFERENCE_MISSING) { + mono_error_set_assembly_load (error, NULL, "Assembly %d referenced from assembly %s not found ", i - 1, assembly->image->name); + goto leave; } - MONO_OBJECT_SETREF (info, assembly, assm_obj); + MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (mono_domain_get (), assembly->image->references [i - 1], error); + if (!is_ok (error)) + goto leave; + MONO_HANDLE_SET (info, assembly, assm_obj); /* Obtain info recursively */ - ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info); - info->location |= RESOURCE_LOCATION_ANOTHER_ASSEMBLY; + get_manifest_resource_info_internal (assm_obj, name, info, error); + if (!is_ok (error)) + goto leave; + guint32 location = MONO_HANDLE_GETVAL (info, location); + location |= RESOURCE_LOCATION_ANOTHER_ASSEMBLY; + MONO_HANDLE_SETVAL (info, location, guint32, location); break; case MONO_IMPLEMENTATION_EXP_TYPE: @@ -4917,7 +4844,16 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflec } } - return TRUE; + result = TRUE; +leave: + HANDLE_FUNCTION_RETURN_VAL (result); +} + +ICALL_EXPORT gboolean +ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, MonoManifestResourceInfoHandle info_h, MonoError *error) +{ + mono_error_init (error); + return get_manifest_resource_info_internal (assembly_h, name, info_h, error); } ICALL_EXPORT MonoObject* @@ -4975,22 +4911,71 @@ ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *a return (MonoObject*)result; } -ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly) +static gboolean +add_module_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int *dest_idx, MonoImage* module, MonoError *error) { - MonoError error; + HANDLE_FUNCTION_ENTER (); + mono_error_init (error); + if (module) { + MonoReflectionModuleHandle rm = mono_module_get_object_handle (domain, module, error); + if (!is_ok (error)) + goto leave; + + MONO_HANDLE_ARRAY_SETREF (dest, *dest_idx, rm); + ++(*dest_idx); + } + +leave: + HANDLE_FUNCTION_RETURN_VAL (is_ok (error)); +} + +static gboolean +add_file_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int dest_idx, MonoImage *image, MonoTableInfo *table, int table_idx, MonoError *error) +{ + HANDLE_FUNCTION_ENTER (); + mono_error_init (error); + + guint32 cols [MONO_FILE_SIZE]; + mono_metadata_decode_row (table, table_idx, cols, MONO_FILE_SIZE); + if (cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA) { + MonoReflectionModuleHandle rm = mono_module_file_get_object_handle (domain, image, table_idx, error); + if (!is_ok (error)) + goto leave; + MONO_HANDLE_ARRAY_SETREF (dest, dest_idx, rm); + } else { + MonoImage *m = mono_image_load_file_for_image_checked (image, table_idx + 1, error); + if (!is_ok (error)) + goto leave; + if (!m) { + const char *filename = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]); + mono_error_set_assembly_load (error, g_strdup (filename), "%s", ""); + goto leave; + } + MonoReflectionModuleHandle rm = mono_module_get_object_handle (domain, m, error); + if (!is_ok (error)) + goto leave; + MONO_HANDLE_ARRAY_SETREF (dest, dest_idx, rm); + } + +leave: + HANDLE_FUNCTION_RETURN_VAL (is_ok (error)); +} + +ICALL_EXPORT MonoArrayHandle +ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssemblyHandle assembly_h, MonoError *error) +{ + mono_error_init (error); MonoDomain *domain = mono_domain_get(); - MonoArray *res; + MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly); MonoClass *klass; int i, j, file_count = 0; MonoImage **modules; guint32 module_count, real_module_count; MonoTableInfo *table; - guint32 cols [MONO_FILE_SIZE]; - MonoImage *image = assembly->assembly->image; + MonoImage *image = assembly->image; g_assert (image != NULL); - g_assert (!assembly_is_dynamic (assembly->assembly)); + g_assert (!assembly_is_dynamic (assembly)); table = &image->tables [MONO_TABLE_FILE]; file_count = table->rows; @@ -5004,50 +4989,29 @@ ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly real_module_count ++; klass = mono_class_get_module_class (); - res = mono_array_new_checked (domain, klass, 1 + real_module_count + file_count, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + MonoArrayHandle res = mono_array_new_handle (domain, klass, 1 + real_module_count + file_count, error); + if (!is_ok (error)) + goto fail; - MonoReflectionModule *image_obj = mono_module_get_object_checked (domain, image, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + MonoReflectionModuleHandle image_obj = mono_module_get_object_handle (domain, image, error); + if (!is_ok (error)) + goto fail; + + MONO_HANDLE_ARRAY_SETREF (res, 0, image_obj); - mono_array_setref (res, 0, image_obj); j = 1; for (i = 0; i < module_count; ++i) - if (modules [i]) { - MonoReflectionModule *rm = mono_module_get_object_checked (domain, modules[i], &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - mono_array_setref (res, j, rm); - ++j; - } + if (!add_module_to_modules_array (domain, res, &j, modules[i], error)) + goto fail; for (i = 0; i < file_count; ++i, ++j) { - mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE); - if (cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA) { - MonoReflectionModule *rm = mono_module_file_get_object_checked (domain, image, i, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - mono_array_setref (res, j, rm); - } - else { - MonoImage *m = mono_image_load_file_for_image_checked (image, i + 1, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - if (!m) { - MonoString *fname = mono_string_new (mono_domain_get (), mono_metadata_string_heap (image, cols [MONO_FILE_NAME])); - mono_set_pending_exception (mono_get_exception_file_not_found2 (NULL, fname)); - return NULL; - } - MonoReflectionModule *rm = mono_module_get_object_checked (domain, m, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - mono_array_setref (res, j, rm); - } + if (!add_file_to_modules_array (domain, res, j, image, table, i, error)) + goto fail; } return res; +fail: + return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE); } ICALL_EXPORT MonoReflectionMethod* @@ -5096,7 +5060,8 @@ mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass) mono_class_setup_methods (method->klass); if (mono_class_has_failure (method->klass)) return NULL; - for (i = 0; i < method->klass->method.count; ++i) { + int mcount = mono_class_get_method_count (method->klass); + for (i = 0; i < mcount; ++i) { if (method->klass->methods [i] == method) { offset = i; break; @@ -5105,7 +5070,7 @@ mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass) mono_class_setup_methods (klass); if (mono_class_has_failure (klass)) return NULL; - g_assert (offset >= 0 && offset < klass->method.count); + g_assert (offset >= 0 && offset < mono_class_get_method_count (klass)); return klass->methods [offset]; } @@ -5256,114 +5221,6 @@ ves_icall_MonoMethod_get_core_clr_security_level (MonoReflectionMethod *rfield) return mono_security_core_clr_method_level (method, TRUE); } -static void -fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token, MonoError *error) -{ - static MonoMethod *create_culture = NULL; - MonoObject *obj; - gpointer args [2]; - guint32 pkey_len; - const char *pkey_ptr; - gchar *codebase; - MonoBoolean assembly_ref = 0; - - mono_error_init (error); - - MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name)); - aname->major = name->major; - aname->minor = name->minor; - aname->build = name->build; - aname->flags = name->flags; - aname->revision = name->revision; - aname->hashalg = name->hash_alg; - aname->versioncompat = 1; /* SameMachine (default) */ - aname->processor_architecture = name->arch; - - if (by_default_version) { - MonoObject *version; - - version = create_version (domain, name->major, name->minor, name->build, name->revision, error); - return_if_nok (error); - - MONO_OBJECT_SETREF (aname, version, version); - } - - codebase = NULL; - if (absolute != NULL && *absolute != '\0') { - gchar *result; - - codebase = g_strdup (absolute); - - mono_icall_make_platform_path (codebase); - - const gchar *prepend = mono_icall_get_file_path_prefix (codebase); - - result = g_strconcat (prepend, codebase, NULL); - g_free (codebase); - codebase = result; - } - - if (codebase) { - MONO_OBJECT_SETREF (aname, codebase, mono_string_new (domain, codebase)); - g_free (codebase); - } - - if (!create_culture) { - MonoMethodDesc *desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE); - create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib); - g_assert (create_culture); - mono_method_desc_free (desc); - } - - if (name->culture) { - args [0] = mono_string_new (domain, name->culture); - args [1] = &assembly_ref; - - obj = mono_runtime_invoke_checked (create_culture, NULL, args, error); - return_if_nok (error); - - MONO_OBJECT_SETREF (aname, cultureInfo, obj); - } - - if (name->public_key) { - pkey_ptr = (char*)name->public_key; - pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr); - - MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, error); - return_if_nok (error); - MONO_OBJECT_SETREF (aname, publicKey, pkey); - memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len); - aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG; - } else if (default_publickey) { - MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error); - return_if_nok (error); - MONO_OBJECT_SETREF (aname, publicKey, pkey); - aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG; - } - - /* MonoAssemblyName keeps the public key token as an hexadecimal string */ - if (name->public_key_token [0]) { - int i, j; - char *p; - - MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 8, error); - return_if_nok (error); - - MONO_OBJECT_SETREF (aname, keyToken, keyToken); - p = mono_array_addr (keyToken, char, 0); - - for (i = 0, j = 0; i < 8; i++) { - *p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4; - *p |= g_ascii_xdigit_value (name->public_key_token [j++]); - p++; - } - } else if (default_token) { - MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error); - return_if_nok (error); - MONO_OBJECT_SETREF (aname, keyToken, keyToken); - } -} - ICALL_EXPORT MonoString * ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly *assembly) { @@ -5386,19 +5243,19 @@ ves_icall_System_Reflection_AssemblyName_GetNativeName (MonoAssembly *mass) } ICALL_EXPORT void -ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname) +ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoStringHandle fname, MonoAssemblyName *name, MonoStringHandleOut normalized_codebase, MonoError *error) { - MonoError error; char *filename; MonoImageOpenStatus status = MONO_IMAGE_OK; + char *codebase = NULL; gboolean res; MonoImage *image; - MonoAssemblyName name; char *dirname; - filename = mono_string_to_utf8_checked (fname, &error); - if (mono_error_set_pending_exception (&error)) - return; + mono_error_init (error); + + filename = mono_string_handle_to_utf8 (fname, error); + return_if_nok (error); dirname = g_path_get_dirname (filename); replace_shadow_path (mono_domain_get (), dirname, &filename); @@ -5407,27 +5264,37 @@ ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, image = mono_image_open (filename, &status); if (!image){ - MonoException *exc; - - g_free (filename); if (status == MONO_IMAGE_IMAGE_INVALID) - exc = mono_get_exception_bad_image_format2 (NULL, fname); + mono_error_set_bad_image_name (error, g_strdup (filename), "%s", ""); else - exc = mono_get_exception_file_not_found2 (NULL, fname); - mono_set_pending_exception (exc); + mono_error_set_assembly_load (error, g_strdup (filename), "%s", ""); + g_free (filename); return; } - res = mono_assembly_fill_assembly_name (image, &name); + res = mono_assembly_fill_assembly_name_full (image, name, TRUE); if (!res) { mono_image_close (image); g_free (filename); - mono_set_pending_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest")); + mono_error_set_argument (error, "assemblyFile", "The file does not contain a manifest"); return; } - fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, TRUE, FALSE, TRUE, &error); - mono_error_set_pending_exception (&error); + if (filename != NULL && *filename != '\0') { + gchar *result; + + codebase = g_strdup (filename); + + mono_icall_make_platform_path (codebase); + + const gchar *prepend = mono_icall_get_file_path_prefix (codebase); + + result = g_strconcat (prepend, codebase, NULL); + g_free (codebase); + codebase = result; + } + MONO_HANDLE_ASSIGN (normalized_codebase, mono_string_new_handle (mono_domain_get (), codebase, error)); + g_free (codebase); mono_image_close (image); g_free (filename); @@ -5477,12 +5344,29 @@ mono_module_type_is_visible (MonoTableInfo *tdef, MonoImage *image, int type) return TRUE; } -static MonoArray* -mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly, MonoError *error) +static void +image_get_type (MonoDomain *domain, MonoImage *image, MonoTableInfo *tdef, int table_idx, int count, MonoArrayHandle res, MonoArrayHandle exceptions, MonoBoolean exportedOnly, MonoError *error) +{ + mono_error_init (error); + HANDLE_FUNCTION_ENTER (); + MonoError klass_error; + MonoClass *klass = mono_class_get_checked (image, table_idx | MONO_TOKEN_TYPE_DEF, &klass_error); + + if (klass) { + MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &klass->byval_arg, error); + return_if_nok (error); + + MONO_HANDLE_ARRAY_SETREF (res, count, rt); + } else { + MonoException *ex = mono_error_convert_to_exception (error); + MONO_HANDLE_ARRAY_SETRAW (exceptions, count, ex); + } + HANDLE_FUNCTION_RETURN (); +} + +static MonoArrayHandle +mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArrayHandleOut exceptions, MonoBoolean exportedOnly, MonoError *error) { - MonoReflectionType *rt; - MonoArray *res; - MonoClass *klass; MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF]; int i, count; @@ -5498,24 +5382,15 @@ mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **excepti } else { count = tdef->rows - 1; } - res = mono_array_new_checked (domain, mono_defaults.runtimetype_class, count, error); - return_val_if_nok (error, NULL); - *exceptions = mono_array_new_checked (domain, mono_defaults.exception_class, count, error); - return_val_if_nok (error, NULL); + MonoArrayHandle res = mono_array_new_handle (domain, mono_defaults.runtimetype_class, count, error); + return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE)); + MONO_HANDLE_ASSIGN (exceptions, mono_array_new_handle (domain, mono_defaults.exception_class, count, error)); + return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE)); count = 0; for (i = 1; i < tdef->rows; ++i) { - if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) { - klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, error); - - if (klass) { - rt = mono_type_get_object_checked (domain, &klass->byval_arg, error); - return_val_if_nok (error, NULL); - - mono_array_setref (res, count, rt); - } else { - MonoException *ex = mono_error_convert_to_exception (error); - mono_array_setref (*exceptions, count, ex); - } + if (!exportedOnly || mono_module_type_is_visible (tdef, image, i+1)) { + image_get_type (domain, image, tdef, i + 1, count, res, exceptions, exportedOnly, error); + return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE)); count++; } } @@ -5523,64 +5398,80 @@ mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **excepti return res; } -ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly) +static void +append_module_types (MonoDomain *domain, MonoArrayHandleOut res, MonoArrayHandleOut exceptions, MonoImage *image, MonoBoolean exportedOnly, MonoError *error) { - MonoError error; - MonoArray *res = NULL; - MonoArray *exceptions = NULL; - MonoImage *image = NULL; - MonoTableInfo *table = NULL; - MonoDomain *domain; - GList *list = NULL; - int i, len, ex_count; + HANDLE_FUNCTION_ENTER (); + mono_error_init (error); + MonoArrayHandle ex2 = MONO_HANDLE_NEW (MonoArray, NULL); + MonoArrayHandle res2 = mono_module_get_types (domain, image, ex2, exportedOnly, error); + if (!is_ok (error)) + goto leave; - domain = mono_object_domain (assembly); + /* Append the new types to the end of the array */ + if (mono_array_handle_length (res2) > 0) { + guint32 len1, len2; - g_assert (!assembly_is_dynamic (assembly->assembly)); - image = assembly->assembly->image; - table = &image->tables [MONO_TABLE_FILE]; - res = mono_module_get_types (domain, image, &exceptions, exportedOnly, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + len1 = mono_array_handle_length (res); + len2 = mono_array_handle_length (res2); - /* Append data from all modules in the assembly */ - for (i = 0; i < table->rows; ++i) { - if (!(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) { - MonoImage *loaded_image = mono_assembly_load_module_checked (image->assembly, i + 1, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - if (loaded_image) { - MonoArray *ex2; - MonoArray *res2; + MonoArrayHandle res3 = mono_array_new_handle (domain, mono_defaults.runtimetype_class, len1 + len2, error); + if (!is_ok (error)) + goto leave; - res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + mono_array_handle_memcpy_refs (res3, 0, res, 0, len1); + mono_array_handle_memcpy_refs (res3, len1, res2, 0, len2); + MONO_HANDLE_ASSIGN (res, res3); + + MonoArrayHandle ex3 = mono_array_new_handle (domain, mono_defaults.runtimetype_class, len1 + len2, error); + if (!is_ok (error)) + goto leave; + mono_array_handle_memcpy_refs (ex3, 0, exceptions, 0, len1); + mono_array_handle_memcpy_refs (ex3, len1, ex2, 0, len2); + MONO_HANDLE_ASSIGN (exceptions, ex3); + } +leave: + HANDLE_FUNCTION_RETURN (); +} - /* Append the new types to the end of the array */ - if (mono_array_length (res2) > 0) { - guint32 len1, len2; - MonoArray *res3, *ex3; +static void +set_class_failure_in_array (MonoArrayHandle exl, int i, MonoClass *klass) +{ + HANDLE_FUNCTION_ENTER (); + MonoError unboxed_error; + mono_error_init (&unboxed_error); + mono_error_set_for_class_failure (&unboxed_error, klass); - len1 = mono_array_length (res); - len2 = mono_array_length (res2); + MonoExceptionHandle exc = MONO_HANDLE_NEW (MonoException, mono_error_convert_to_exception (&unboxed_error)); + MONO_HANDLE_ARRAY_SETREF (exl, i, exc); + HANDLE_FUNCTION_RETURN (); +} - res3 = mono_array_new_checked (domain, mono_defaults.runtimetype_class, len1 + len2, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - mono_array_memcpy_refs (res3, 0, res, 0, len1); - mono_array_memcpy_refs (res3, len1, res2, 0, len2); - res = res3; +ICALL_EXPORT MonoArrayHandle +ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssemblyHandle assembly_handle, MonoBoolean exportedOnly, MonoError *error) +{ + MonoArrayHandle exceptions = MONO_HANDLE_NEW(MonoArray, NULL); + int i; - ex3 = mono_array_new_checked (domain, mono_defaults.runtimetype_class, len1 + len2, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1); - mono_array_memcpy_refs (ex3, len1, ex2, 0, len2); - exceptions = ex3; - } + MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_handle); + MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_handle, assembly); + + g_assert (!assembly_is_dynamic (assembly)); + MonoImage *image = assembly->image; + MonoTableInfo *table = &image->tables [MONO_TABLE_FILE]; + MonoArrayHandle res = mono_module_get_types (domain, image, exceptions, exportedOnly, error); + return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE)); + + /* Append data from all modules in the assembly */ + for (i = 0; i < table->rows; ++i) { + if (!(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) { + MonoImage *loaded_image = mono_assembly_load_module_checked (image->assembly, i + 1, error); + return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE)); + + if (loaded_image) { + append_module_types (domain, res, exceptions, loaded_image, exportedOnly, error); + return_val_if_nok (error, MONO_HANDLE_CAST (MonoArray, NULL_HANDLE)); } } } @@ -5590,20 +5481,21 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, * contain all exceptions for NULL items. */ - len = mono_array_length (res); + int len = mono_array_handle_length (res); - ex_count = 0; + int ex_count = 0; + GList *list = NULL; + MonoReflectionTypeHandle t = MONO_HANDLE_NEW (MonoReflectionType, NULL); for (i = 0; i < len; i++) { - MonoReflectionType *t = (MonoReflectionType *)mono_array_get (res, gpointer, i); - MonoClass *klass; + MONO_HANDLE_ARRAY_GETREF (t, res, i); - if (t) { - klass = mono_type_get_class (t->type); + if (!MONO_HANDLE_IS_NULL (t)) { + MonoClass *klass = mono_type_get_class (MONO_HANDLE_GETVAL (t, type)); if ((klass != NULL) && mono_class_has_failure (klass)) { /* keep the class in the list */ list = g_list_append (list, klass); /* and replace Type with NULL */ - mono_array_setref (res, i, NULL); + MONO_HANDLE_ARRAY_SETRAW (res, i, NULL); } } else { ex_count ++; @@ -5612,48 +5504,47 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, if (list || ex_count) { GList *tmp = NULL; - MonoException *exc = NULL; - MonoArray *exl = NULL; int j, length = g_list_length (list) + ex_count; - exl = mono_array_new_checked (domain, mono_defaults.exception_class, length, &error); - if (mono_error_set_pending_exception (&error)) { + MonoArrayHandle exl = mono_array_new_handle (domain, mono_defaults.exception_class, length, error); + if (!is_ok (error)) { g_list_free (list); - return NULL; + return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE); } /* Types for which mono_class_get_checked () succeeded */ + MonoExceptionHandle exc = MONO_HANDLE_NEW (MonoException, NULL); for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) { - MonoException *exc = mono_class_get_exception_for_failure ((MonoClass *)tmp->data); - mono_array_setref (exl, i, exc); + set_class_failure_in_array (exl, i, (MonoClass*)tmp->data); } /* Types for which it don't */ - for (j = 0; j < mono_array_length (exceptions); ++j) { - MonoException *exc = mono_array_get (exceptions, MonoException*, j); - if (exc) { + for (j = 0; j < mono_array_handle_length (exceptions); ++j) { + MONO_HANDLE_ARRAY_GETREF (exc, exceptions, j); + if (!MONO_HANDLE_IS_NULL (exc)) { g_assert (i < length); - mono_array_setref (exl, i, exc); + MONO_HANDLE_ARRAY_SETREF (exl, i, exc); i ++; } } g_list_free (list); list = NULL; - exc = mono_get_exception_reflection_type_load_checked (res, exl, &error); - if (!is_ok (&error)) { - mono_error_set_pending_exception (&error); - return NULL; + MONO_HANDLE_ASSIGN (exc, mono_get_exception_reflection_type_load_checked (res, exl, error)); + if (!is_ok (error)) { + return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE); } - mono_set_pending_exception (exc); - return NULL; + mono_error_set_exception_handle (error, exc); + return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE); } return res; } ICALL_EXPORT void -ves_icall_Mono_RuntimeMarshal_FreeAssemblyName (MonoAssemblyName *aname) +ves_icall_Mono_RuntimeMarshal_FreeAssemblyName (MonoAssemblyName *aname, gboolean free_struct) { mono_assembly_name_free (aname); + if (free_struct) + g_free (aname); } ICALL_EXPORT gboolean @@ -5664,37 +5555,32 @@ ves_icall_System_Reflection_AssemblyName_ParseAssemblyName (const char *name, Mo return mono_assembly_name_parse_full (name, aname, TRUE, is_version_definited, is_token_defined); } -ICALL_EXPORT MonoReflectionType* -ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModuleHandle module, MonoError *error) { - MonoError error; - MonoReflectionType *ret; - MonoDomain *domain = mono_object_domain (module); + MonoDomain *domain = MONO_HANDLE_DOMAIN (module); + MonoImage *image = MONO_HANDLE_GETVAL (module, image); MonoClass *klass; - g_assert (module->image); + g_assert (image); - if (image_is_dynamic (module->image) && ((MonoDynamicImage*)(module->image))->initial_image) - /* These images do not have a global type */ - return NULL; + MonoReflectionTypeHandle ret = MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); - klass = mono_class_get_checked (module->image, 1 | MONO_TOKEN_TYPE_DEF, &error); - if (!mono_error_ok (&error)) { - mono_error_set_pending_exception (&error); - return NULL; - } + if (image_is_dynamic (image) && ((MonoDynamicImage*)image)->initial_image) + /* These images do not have a global type */ + goto leave; - ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error); - if (!mono_error_ok (&error)) { - mono_error_set_pending_exception (&error); - return NULL; - } + klass = mono_class_get_checked (image, 1 | MONO_TOKEN_TYPE_DEF, error); + if (!is_ok (error)) + goto leave; + ret = mono_type_get_object_handle (domain, &klass->byval_arg, error); +leave: return ret; } ICALL_EXPORT void -ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module) +ves_icall_System_Reflection_Module_Close (MonoReflectionModuleHandle module, MonoError *error) { /*if (module->image) mono_image_close (module->image);*/ @@ -5704,7 +5590,7 @@ ICALL_EXPORT MonoStringHandle ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModuleHandle refmodule, MonoError *error) { MonoDomain *domain = MONO_HANDLE_DOMAIN (refmodule); - MonoImage *image = MONO_HANDLE_RAW (refmodule)->image; + MonoImage *image = MONO_HANDLE_GETVAL (refmodule, image); g_assert (image); return mono_string_new_handle (domain, image->guid, error); @@ -5712,20 +5598,20 @@ ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModuleHandle r #ifndef HOST_WIN32 static inline gpointer -mono_icall_module_get_hinstance (MonoReflectionModule *module) +mono_icall_module_get_hinstance (MonoReflectionModuleHandle module) { return (gpointer) (-1); } #endif /* HOST_WIN32 */ ICALL_EXPORT gpointer -ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule *module) +ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModuleHandle module, MonoError *error) { return mono_icall_module_get_hinstance (module); } ICALL_EXPORT void -ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine) +ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine, MonoError *error) { if (image_is_dynamic (image)) { MonoDynamicImage *dyn = (MonoDynamicImage*)image; @@ -5739,34 +5625,34 @@ ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, } ICALL_EXPORT gint32 -ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image) +ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image, MonoError *error) { return (image->md_version_major << 16) | (image->md_version_minor); } -ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module) +ICALL_EXPORT MonoArrayHandle +ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModuleHandle module, MonoError *error) { - MonoError error; - MonoArray *exceptions; - int i; + mono_error_init (error); - if (!module->image) { - MonoArray *arr = mono_array_new_checked (mono_object_domain (module), mono_defaults.runtimetype_class, 0, &error); - mono_error_set_pending_exception (&error); + MonoImage *image = MONO_HANDLE_GETVAL (module, image); + MonoDomain *domain = MONO_HANDLE_DOMAIN (module); + + if (!image) { + MonoArrayHandle arr = mono_array_new_handle (domain, mono_defaults.runtimetype_class, 0, error); return arr; } else { - MonoArray *res; - - res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - for (i = 0; i < mono_array_length (exceptions); ++i) { - MonoException *ex = mono_array_get (exceptions, MonoException *, i); - if (ex) { - mono_set_pending_exception (ex); - return NULL; + MonoArrayHandle exceptions = MONO_HANDLE_NEW (MonoArray, NULL); + MonoArrayHandle res = mono_module_get_types (domain, image, exceptions, FALSE, error); + return_val_if_nok (error, MONO_HANDLE_CAST(MonoArray, NULL_HANDLE)); + + int n = mono_array_handle_length (exceptions); + MonoExceptionHandle ex = MONO_HANDLE_NEW (MonoException, NULL); + for (int i = 0; i < n; ++i) { + MONO_HANDLE_ARRAY_GETREF(ex, exceptions, i); + if (!MONO_HANDLE_IS_NULL (ex)) { + mono_error_set_exception_handle (error, ex); + return MONO_HANDLE_CAST(MonoArray, NULL_HANDLE); } } return res; @@ -6974,7 +6860,7 @@ ves_icall_Remoting_RemotingServices_GetVirtualMethod ( mono_class_setup_vtable (klass); vtable = klass->vtable; - if (mono_class_get_flags (method->klass) & TYPE_ATTRIBUTE_INTERFACE) { + if (mono_class_is_interface (method->klass)) { gboolean variance_used = FALSE; /*MS fails with variant interfaces but it's the right thing to do anyway.*/ int offs = mono_class_interface_offset_with_variance (klass, method->klass, &variance_used); @@ -7037,7 +6923,7 @@ ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClas if (mono_error_set_pending_exception (&error)) return NULL; - if (MONO_CLASS_IS_INTERFACE (klass) || (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_ABSTRACT)) { + if (MONO_CLASS_IS_INTERFACE (klass) || mono_class_is_abstract (klass)) { mono_set_pending_exception (mono_get_exception_argument ("type", "Type cannot be instantiated")); return NULL; } @@ -7924,14 +7810,15 @@ ves_icall_MonoCustomAttrs_GetCustomAttributesDataInternal (MonoObject *obj) } -ICALL_EXPORT MonoString* -ves_icall_Mono_Runtime_GetDisplayName (void) +ICALL_EXPORT MonoStringHandle +ves_icall_Mono_Runtime_GetDisplayName (MonoError *error) { char *info; - MonoString *display_name; + MonoStringHandle display_name; + mono_error_init (error); info = mono_get_runtime_callbacks ()->get_runtime_build_info (); - display_name = mono_string_new (mono_domain_get (), info); + display_name = mono_string_new_handle (mono_domain_get (), info, error); g_free (info); return display_name; } @@ -7958,38 +7845,6 @@ ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code) return message; } -ICALL_EXPORT gpointer -ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void) -{ - return GetCurrentProcess (); -} - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_GetExitCodeProcess (gpointer handle, gint32 *exitcode) -{ - return GetExitCodeProcess (handle, (guint32*) exitcode); -} - -#ifndef HOST_WIN32 -static inline MonoBoolean -mono_icall_close_process (gpointer handle) -{ - return CloseProcess (handle); -} -#endif /* !HOST_WIN32 */ - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_CloseProcess (gpointer handle) -{ - return mono_icall_close_process (handle); -} - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint32 exitcode) -{ - return TerminateProcess (handle, exitcode); -} - #ifndef HOST_WIN32 static inline gint32 mono_icall_wait_for_input_idle (gpointer handle, gint32 milliseconds) @@ -8004,74 +7859,12 @@ ves_icall_Microsoft_Win32_NativeMethods_WaitForInputIdle (gpointer handle, gint3 return mono_icall_wait_for_input_idle (handle, milliseconds); } -#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) -static inline MonoBoolean -mono_icall_get_process_working_set_size (gpointer handle, gsize *min, gsize *max) -{ - return GetProcessWorkingSetSize (handle, min, max); -} -#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */ - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max) -{ - return mono_icall_get_process_working_set_size (handle, min, max); -} - -#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) -static inline MonoBoolean -mono_icall_set_process_working_set_size (gpointer handle, gsize min, gsize max) -{ - return SetProcessWorkingSetSize (handle, min, max); -} -#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */ - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max) -{ - return mono_icall_set_process_working_set_size (handle, min, max); -} - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_GetProcessTimes (gpointer handle, gint64 *creationtime, gint64 *exittime, gint64 *kerneltime, gint64 *usertime) -{ - return GetProcessTimes (handle, (LPFILETIME) creationtime, (LPFILETIME) exittime, (LPFILETIME) kerneltime, (LPFILETIME) usertime); -} - ICALL_EXPORT gint32 ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcessId (void) { return mono_process_current_pid (); } -#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) -static inline gint32 -mono_icall_get_priority_class (gpointer handle) -{ - return GetPriorityClass (handle); -} -#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */ - -ICALL_EXPORT gint32 -ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle) -{ - return mono_icall_get_priority_class (handle); -} - -#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) -static inline MonoBoolean -mono_icall_set_priority_class (gpointer handle, gint32 priorityClass) -{ - return SetPriorityClass (handle, priorityClass); -} -#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */ - -ICALL_EXPORT MonoBoolean -ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass) -{ - return mono_icall_set_priority_class (handle, priorityClass); -} - ICALL_EXPORT MonoBoolean ves_icall_Mono_TlsProviderFactory_IsBtlsSupported (void) {