X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Ficall.c;h=d4622567695a834b97124f5ee0b28658317cf64f;hb=6dd95a6fdf4b17c5df5b52cd75356cb864681bdb;hp=a9d68804dc1c604fd51231fae2e4a3381da873c9;hpb=fd44a557dd35089533cbd5b9ec59f5a1c8047b50;p=mono.git diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index a9d68804dc1..d4622567695 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -43,7 +43,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -83,6 +85,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -107,12 +112,26 @@ #include #endif +#if HAVE_BTLS +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif + extern MonoString* ves_icall_System_Environment_GetOSVersionString (void); ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void); -TYPED_HANDLE_DECL (MonoReflectionType); - /* Lazy class loading functions */ static GENERATE_GET_CLASS_WITH_CACHE (system_version, System, Version) static GENERATE_GET_CLASS_WITH_CACHE (assembly_name, System.Reflection, AssemblyName) @@ -983,11 +1002,6 @@ ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStac /* if we have no info we are optimistic and assume there is enough room */ if (!stack_addr) return TRUE; -#ifdef HOST_WIN32 - // FIXME: Windows dynamically extends the stack, so stack_addr might be close - // to the current sp - return TRUE; -#endif current = (guint8 *)&stack_addr; if (current > stack_addr) { if ((current - stack_addr) < min_size) @@ -1213,100 +1227,6 @@ ves_icall_System_Object_GetType (MonoObject *obj) return ret; } -ICALL_EXPORT gint32 -ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance) -{ - MONO_CHECK_ARG_NULL (obj, 0); - - MonoError error; - gint32 result = mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE, &error); - mono_error_set_pending_exception (&error); - return result; -} - -ICALL_EXPORT gint32 -ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb, - MonoReflectionMethod *method, - MonoArray *opt_param_types) -{ - MONO_CHECK_ARG_NULL (method, 0); - - MonoError error; - gint32 result = mono_image_create_method_token ( - mb->dynamic_image, (MonoObject *) method, opt_param_types, &error); - mono_error_set_pending_exception (&error); - return result; -} - -ICALL_EXPORT void -ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file) -{ - MonoError error; - mono_image_create_pefile (mb, file, &error); - mono_error_set_pending_exception (&error); -} - -ICALL_EXPORT void -ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb) -{ - MonoError error; - mono_image_build_metadata (mb, &error); - mono_error_set_pending_exception (&error); -} - -ICALL_EXPORT void -ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token) -{ - mono_image_register_token (mb->dynamic_image, token, obj); -} - -ICALL_EXPORT MonoObject* -ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilder *mb, guint32 token) -{ - MonoObject *obj; - - mono_loader_lock (); - obj = (MonoObject *)mono_g_hash_table_lookup (mb->dynamic_image->tokens, GUINT_TO_POINTER (token)); - mono_loader_unlock (); - - return obj; -} - -ICALL_EXPORT MonoReflectionModule* -ves_icall_System_Reflection_Emit_AssemblyBuilder_InternalAddModule (MonoReflectionAssemblyBuilder *ab, MonoString *fileName) -{ - MonoError error; - MonoReflectionModule *result = mono_image_load_module_dynamic (ab, fileName, &error); - mono_error_set_pending_exception (&error); - return result; -} - -/** - * ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class: - * @tb: a TypeBuilder object - * - * (icall) - * Creates the generic class after all generic parameters have been added. - */ -ICALL_EXPORT void -ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class (MonoReflectionTypeBuilder *tb) -{ - MonoError error; - (void) mono_reflection_create_generic_class (tb, &error); - mono_error_set_pending_exception (&error); -} - -#ifndef DISABLE_REFLECTION_EMIT -ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Emit_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues) -{ - MonoError error; - MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error); - mono_error_set_pending_exception (&error); - return result; -} -#endif - static gboolean get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { @@ -1500,7 +1420,7 @@ ves_icall_System_Type_internal_from_name (MonoString *name, if (type == NULL){ if (throwOnError) { - mono_error_set_type_load_name (&error, g_strdup (str), NULL, ""); + mono_error_set_type_load_name (&error, g_strdup (str), g_strdup (""), ""); goto leave; } } @@ -2732,37 +2652,38 @@ ves_icall_RuntimeType_get_DeclaringType (MonoReflectionType *type) return ret; } -ICALL_EXPORT MonoString* -ves_icall_RuntimeType_get_Name (MonoReflectionType *type) +ICALL_EXPORT MonoStringHandle +ves_icall_RuntimeType_get_Name (MonoReflectionTypeHandle reftype, MonoError *error) { - MonoDomain *domain = mono_domain_get (); - MonoClass *klass = mono_class_from_mono_type (type->type); + MonoDomain *domain = mono_domain_get (); + MonoType *type = MONO_HANDLE_RAW(reftype)->type; + MonoClass *klass = mono_class_from_mono_type (type); - if (type->type->byref) { + if (type->byref) { char *n = g_strdup_printf ("%s&", klass->name); - MonoString *res = mono_string_new (domain, n); + MonoStringHandle res = mono_string_new_handle (domain, n, error); g_free (n); return res; } else { - return mono_string_new (domain, klass->name); + return mono_string_new_handle (domain, klass->name, error); } } -ICALL_EXPORT MonoString* -ves_icall_RuntimeType_get_Namespace (MonoReflectionType *type) +ICALL_EXPORT MonoStringHandle +ves_icall_RuntimeType_get_Namespace (MonoReflectionTypeHandle type, MonoError *error) { MonoDomain *domain = mono_domain_get (); - MonoClass *klass = mono_class_from_mono_type (type->type); + MonoClass *klass = mono_class_from_mono_type_handle (type); while (klass->nested_in) klass = klass->nested_in; if (klass->name_space [0] == '\0') - return NULL; + return NULL_HANDLE_STRING; else - return mono_string_new (domain, klass->name_space); + return mono_string_new_handle (domain, klass->name_space, error); } ICALL_EXPORT gint32 @@ -2959,19 +2880,6 @@ ves_icall_RuntimeTypeHandle_IsGenericVariable (MonoReflectionType *type) return is_generic_parameter (type->type); } -ICALL_EXPORT MonoBoolean -ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb) -{ - return is_generic_parameter (tb->type.type); -} - -ICALL_EXPORT void -ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype, - MonoReflectionType *t) -{ - enumtype->type = t->type; -} - ICALL_EXPORT MonoReflectionMethod* ves_icall_RuntimeType_GetCorrespondingInflatedMethod (MonoReflectionType *type, MonoReflectionMethod* generic) @@ -4525,8 +4433,8 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as /* need to report exceptions ? */ if (throwOnError && mono_class_has_failure (klass)) { /* report SecurityException (or others) that occured when loading the assembly */ - MonoException *exc = mono_class_get_exception_for_failure (klass); - mono_set_pending_exception (exc); + mono_error_set_for_class_failure (&error, klass); + mono_error_set_pending_exception (&error); return NULL; } } @@ -4649,15 +4557,12 @@ ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, return result; } -ICALL_EXPORT MonoString * -ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly) +ICALL_EXPORT MonoStringHandle +ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssemblyHandle refassembly, MonoError *error) { - MonoDomain *domain = mono_object_domain (assembly); - MonoString *res; - - res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image)); - - return res; + MonoDomain *domain = MONO_HANDLE_DOMAIN (refassembly); + MonoAssembly *assembly = MONO_HANDLE_RAW (refassembly)->assembly; + return mono_string_new_handle (domain, mono_image_get_filename (assembly->image), error); } ICALL_EXPORT MonoBoolean @@ -4666,12 +4571,13 @@ ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly return assembly->assembly->ref_only; } -ICALL_EXPORT MonoString * -ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly *assembly) +ICALL_EXPORT MonoStringHandle +ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssemblyHandle refassembly, MonoError *error) { - MonoDomain *domain = mono_object_domain (assembly); + MonoDomain *domain = MONO_HANDLE_DOMAIN (refassembly); + MonoAssembly *assembly = MONO_HANDLE_RAW (refassembly)->assembly; - return mono_string_new (domain, assembly->assembly->image->version); + return mono_string_new_handle (domain, assembly->image->version, error); } ICALL_EXPORT MonoReflectionMethod* @@ -4726,8 +4632,8 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAss return result; } -ICALL_EXPORT MonoString* -ves_icall_System_Reflection_Assembly_GetAotId () +ICALL_EXPORT MonoStringHandle +ves_icall_System_Reflection_Assembly_GetAotId (MonoError *error) { int i; guint8 aotid_sum = 0; @@ -4743,8 +4649,11 @@ ves_icall_System_Reflection_Assembly_GetAotId () if (aotid_sum == 0) return NULL; - - return mono_string_new (domain, mono_guid_to_string((guint8*) aotid)); + + gchar *guid = mono_guid_to_string((guint8*) aotid); + MonoStringHandle res = mono_string_new_handle (domain, guid, error); + g_free (guid); + return res; } static MonoObject* @@ -4934,8 +4843,8 @@ 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 (assembly->assembly->image, file_idx); - if (!module) + module = mono_image_load_file_for_image_checked (assembly->assembly->image, file_idx, &error); + if (mono_error_set_pending_exception (&error) || !module) return NULL; } else @@ -5135,7 +5044,9 @@ ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly mono_array_setref (res, j, rm); } else { - MonoImage *m = mono_image_load_file_for_image (image, i + 1); + 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)); @@ -5326,7 +5237,7 @@ ves_icall_System_RuntimeType_getFullName (MonoReflectionTypeHandle object, gbool return NULL_HANDLE_STRING; } - res = mono_string_new_handle (domain, name); + res = mono_string_new_handle (domain, name, error); g_free (name); return res; @@ -5659,7 +5570,9 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, /* 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 (image->assembly, i + 1); + 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; @@ -5810,13 +5723,14 @@ ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module) mono_image_close (module->image);*/ } -ICALL_EXPORT MonoString* -ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module) +ICALL_EXPORT MonoStringHandle +ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModuleHandle refmodule, MonoError *error) { - MonoDomain *domain = mono_object_domain (module); + MonoDomain *domain = MONO_HANDLE_DOMAIN (refmodule); + MonoImage *image = MONO_HANDLE_RAW (refmodule)->image; - g_assert (module->image); - return mono_string_new (domain, module->image->guid); + g_assert (image); + return mono_string_new_handle (domain, image->guid, error); } ICALL_EXPORT gpointer @@ -6214,77 +6128,6 @@ ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 t return res; } -ICALL_EXPORT MonoReflectionType* -ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers) -{ - MonoError error; - MonoReflectionType *ret; - MonoClass *klass; - int isbyref = 0, rank; - char *p; - char *str = mono_string_to_utf8_checked (smodifiers, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - - klass = mono_class_from_mono_type (tb->type.type); - p = str; - /* logic taken from mono_reflection_parse_type(): keep in sync */ - while (*p) { - switch (*p) { - case '&': - if (isbyref) { /* only one level allowed by the spec */ - g_free (str); - return NULL; - } - isbyref = 1; - p++; - - g_free (str); - - ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->this_arg, &error); - mono_error_set_pending_exception (&error); - - return ret; - case '*': - klass = mono_ptr_class_get (&klass->byval_arg); - mono_class_init (klass); - p++; - break; - case '[': - rank = 1; - p++; - while (*p) { - if (*p == ']') - break; - if (*p == ',') - rank++; - else if (*p != '*') { /* '*' means unknown lower bound */ - g_free (str); - return NULL; - } - ++p; - } - if (*p != ']') { - g_free (str); - return NULL; - } - p++; - klass = mono_array_class_get (klass, rank); - mono_class_init (klass); - break; - default: - break; - } - } - - g_free (str); - - ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error); - mono_error_set_pending_exception (&error); - - return ret; -} - ICALL_EXPORT MonoBoolean ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionType *t) { @@ -6301,7 +6144,6 @@ static void check_for_invalid_type (MonoClass *klass, MonoError *error) { char *name; - MonoString *str; mono_error_init (error); @@ -6309,10 +6151,7 @@ check_for_invalid_type (MonoClass *klass, MonoError *error) return; name = mono_type_get_full_name (klass); - str = mono_string_new (mono_domain_get (), name); - g_free (name); - mono_error_set_exception_instance (error, mono_get_exception_type_load (str, NULL)); - + mono_error_set_type_load_name (error, name, g_strdup (""), ""); } ICALL_EXPORT MonoReflectionType * ves_icall_RuntimeType_make_array_type (MonoReflectionType *type, int rank) @@ -6323,7 +6162,8 @@ ves_icall_RuntimeType_make_array_type (MonoReflectionType *type, int rank) klass = mono_class_from_mono_type (type->type); check_for_invalid_type (klass, &error); - mono_error_set_pending_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (rank == 0) //single dimentional array aklass = mono_array_class_get (klass, 1); @@ -6390,6 +6230,7 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon MonoObject *delegate; gpointer func; MonoMethod *method = info->method; + MonoMethodSignature *sig = mono_method_signature(method); mono_class_init_checked (delegate_class, &error); if (mono_error_set_pending_exception (&error)) @@ -6414,6 +6255,13 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon } } + if (sig->generic_param_count && method->wrapper_type == MONO_WRAPPER_NONE) { + if (!method->is_inflated) { + mono_set_pending_exception(mono_get_exception_argument("method", " Cannot bind to the target method because its signature differs from that of the delegate type")); + return NULL; + } + } + delegate = mono_object_new_checked (mono_object_domain (type), delegate_class, &error); if (mono_error_set_pending_exception (&error)) return NULL; @@ -6719,27 +6567,20 @@ ves_icall_System_Environment_GetIs64BitOperatingSystem (void) #endif } -ICALL_EXPORT MonoString * -ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name) +ICALL_EXPORT MonoStringHandle +ves_icall_System_Environment_GetEnvironmentVariable_native (const gchar *utf8_name, MonoError *error) { - MonoError error; const gchar *value; - gchar *utf8_name; - if (name == NULL) - return NULL; + if (utf8_name == NULL) + return NULL_HANDLE_STRING; - utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */ - if (mono_error_set_pending_exception (&error)) - return NULL; value = g_getenv (utf8_name); - g_free (utf8_name); - if (value == 0) - return NULL; + return NULL_HANDLE_STRING; - return mono_string_new (mono_domain_get (), value); + return mono_string_new_handle (mono_domain_get (), value, error); } /* @@ -6938,10 +6779,10 @@ ves_icall_System_Environment_Exit (int result) exit (result); } -ICALL_EXPORT MonoString* -ves_icall_System_Environment_GetGacPath (void) +ICALL_EXPORT MonoStringHandle +ves_icall_System_Environment_GetGacPath (MonoError *error) { - return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ()); + return mono_string_new_handle (mono_domain_get (), mono_assembly_getrootdir (), error); } ICALL_EXPORT MonoString* @@ -7042,10 +6883,10 @@ ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path) return result; } -ICALL_EXPORT MonoString * -ves_icall_System_Environment_InternalGetHome (void) +ICALL_EXPORT MonoStringHandle +ves_icall_System_Environment_InternalGetHome (MonoError *error) { - return mono_string_new (mono_domain_get (), g_get_home_dir ()); + return mono_string_new_handle (mono_domain_get (), g_get_home_dir (), error); } static const char *encodings [] = { @@ -7116,7 +6957,7 @@ ves_icall_System_Text_EncodingHelper_InternalCodePage (gint32 *int_code_page) if (strstr (codepage, "utf_8") != NULL) *int_code_page |= 0x10000000; - free (codepage); + g_free (codepage); if (want_name && *int_code_page == -1) return mono_string_new (mono_domain_get (), cset); @@ -7295,10 +7136,10 @@ ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClas } } -ICALL_EXPORT MonoString * -ves_icall_System_IO_get_temp_path (void) +ICALL_EXPORT MonoStringHandle +ves_icall_System_IO_get_temp_path (MonoError *error) { - return mono_string_new (mono_domain_get (), g_get_tmp_dir ()); + return mono_string_new_handle (mono_domain_get (), g_get_tmp_dir (), error); } #ifndef PLATFORM_NO_DRIVEINFO @@ -7416,17 +7257,18 @@ get_bundled_app_config (void) return mono_string_new (mono_domain_get (), app_config); } -static MonoString * -get_bundled_machine_config (void) +/* this is an icall */ +static MonoStringHandle +get_bundled_machine_config (MonoError *error) { const gchar *machine_config; machine_config = mono_get_machine_config (); if (!machine_config) - return NULL; + return NULL_HANDLE_STRING; - return mono_string_new (mono_domain_get (), machine_config); + return mono_string_new_handle (mono_domain_get (), machine_config, error); } ICALL_EXPORT MonoString * @@ -7564,6 +7406,7 @@ ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definiti klass = klass->generic_class->container_class; } +retry: if (definition) { /* At the end of the loop, klass points to the eldest class that has this virtual function slot. */ for (parent = klass->parent; parent != NULL; parent = parent->parent) { @@ -7650,14 +7493,38 @@ ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definiti result = klass->vtable [slot]; if (result == NULL) { /* It is an abstract method */ + gboolean found = FALSE; gpointer iter = NULL; - while ((result = mono_class_get_methods (klass, &iter))) - if (result->slot == slot) + while ((result = mono_class_get_methods (klass, &iter))) { + if (result->slot == slot) { + found = TRUE; break; + } + } + /* found might be FALSE if we looked in an abstract class + * that doesn't override an abstract method of its + * parent: + * abstract class Base { + * public abstract void Foo (); + * } + * abstract class Derived : Base { } + * class Child : Derived { + * public override void Foo () { } + * } + * + * if m was Child.Foo and we ask for the base method, + * then we get here with klass == Derived and found == FALSE + */ + /* but it shouldn't be the case that if we're looking + * for the definition and didn't find a result; the + * loop above should've taken us as far as we could + * go! */ + g_assert (!(definition && !found)); + if (!found) + goto retry; } - if (result == NULL) - return m; + g_assert (result != NULL); ret = mono_method_get_object_checked (mono_domain_get (), result, NULL, &error); mono_error_set_pending_exception (&error); @@ -8179,7 +8046,12 @@ ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint3 ICALL_EXPORT gint32 ves_icall_Microsoft_Win32_NativeMethods_WaitForInputIdle (gpointer handle, gint32 milliseconds) { +#ifdef HOST_WIN32 return WaitForInputIdle (handle, milliseconds); +#else + /*TODO: Not implemented*/ + return WAIT_TIMEOUT; +#endif } ICALL_EXPORT MonoBoolean @@ -8218,6 +8090,16 @@ ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint3 return SetPriorityClass (handle, priorityClass); } +ICALL_EXPORT MonoBoolean +ves_icall_Mono_Btls_Provider_IsSupported (void) +{ +#if HAVE_BTLS + return TRUE; +#else + return FALSE; +#endif +} + #ifndef DISABLE_ICALL_TABLES #define ICALL_TYPE(id,name,first) @@ -8717,6 +8599,8 @@ mono_lookup_internal_call_full (MonoMethod *method, mono_bool *uses_handles) #else /* it wasn't found in the static call tables */ if (!imap) { + if (uses_handles) + *uses_handles = FALSE; mono_icall_unlock (); return NULL; }