#include <mono/metadata/threadpool-ms-io.h>
#include <mono/metadata/monitor.h>
#include <mono/metadata/reflection.h>
+#include <mono/metadata/image-internals.h>
#include <mono/metadata/assembly.h>
+#include <mono/metadata/assembly-internals.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/exception.h>
#include <mono/metadata/exception-internals.h>
#include <mono/metadata/runtime.h>
#include <mono/metadata/file-mmap.h>
#include <mono/metadata/seq-points-data.h>
+#include <mono/metadata/handle.h>
+#include <mono/metadata/w32mutex.h>
+#include <mono/metadata/w32semaphore.h>
+#include <mono/metadata/w32event.h>
#include <mono/io-layer/io-layer.h>
#include <mono/utils/monobitset.h>
#include <mono/utils/mono-time.h>
#include <sys/utsname.h>
#endif
+#if HAVE_BTLS
+#include <btls/btls-ssl.h>
+#include <btls/btls-bio.h>
+#include <btls/btls-error.h>
+#include <btls/btls-key.h>
+#include <btls/btls-pkcs12.h>
+#include <btls/btls-x509-crl.h>
+#include <btls/btls-x509-chain.h>
+#include <btls/btls-x509-lookup.h>
+#include <btls/btls-x509-lookup-mono.h>
+#include <btls/btls-x509-name.h>
+#include <btls/btls-x509-revoked.h>
+#include <btls/btls-x509-store-ctx.h>
+#include <btls/btls-x509-verify-param.h>
+#endif
+
extern MonoString* ves_icall_System_Environment_GetOSVersionString (void);
ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
/* 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)
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)
{
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
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)
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
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*
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;
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*
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
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));
return result;
}
-ICALL_EXPORT MonoString *
-ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
- gboolean assembly_qualified)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_RuntimeType_getFullName (MonoReflectionTypeHandle object, gboolean full_name,
+ gboolean assembly_qualified, MonoError *error)
{
- MonoDomain *domain = mono_object_domain (object);
+ MonoDomain *domain = mono_object_domain (MONO_HANDLE_RAW (object));
+ MonoType *type = MONO_HANDLE_RAW (object)->type;
MonoTypeNameFormat format;
- MonoString *res;
+ MonoStringHandle res;
gchar *name;
if (full_name)
else
format = MONO_TYPE_NAME_FORMAT_REFLECTION;
- name = mono_type_get_name_full (object->type, format);
+ name = mono_type_get_name_full (type, format);
if (!name)
- return NULL;
+ return NULL_HANDLE_STRING;
- if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR)) {
+ if (full_name && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR)) {
g_free (name);
- return NULL;
+ return NULL_HANDLE_STRING;
}
- res = mono_string_new (domain, name);
+ res = mono_string_new_handle (domain, name, error);
g_free (name);
return res;
/* 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;
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
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)
{
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))
}
}
+ 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;
#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);
}
/*
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*
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 [] = {
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);
}
}
-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
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 *
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) {
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);
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
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)
#define ICALL(id,name,func) Icall_ ## id,
+#define HANDLES(inner) inner
enum {
#include "metadata/icall-def.h"
#undef ICALL
#define ICALL_TYPE(id,name,first) Icall_type_ ## id,
#define ICALL(id,name,func)
+#undef HANDLES
+#define HANDLES(inner) inner
enum {
#include "metadata/icall-def.h"
Icall_type_num
#undef ICALL
#define ICALL_TYPE(id,name,firstic) {(Icall_ ## firstic)},
#define ICALL(id,name,func)
+#undef HANDLES
+#define HANDLES(inner) inner
typedef struct {
guint16 first_icall;
} IcallTypeDesc;
#define icall_desc_num_icalls(desc) ((desc) [1].first_icall - (desc) [0].first_icall)
+#undef HANDLES
+#define HANDLES(inner) inner
#undef ICALL_TYPE
#define ICALL_TYPE(id,name,first)
#undef ICALL
#endif /* !HAVE_ARRAY_ELEM_INIT */
+#undef HANDLES
+#define HANDLES(inner) inner
#undef ICALL_TYPE
#undef ICALL
#define ICALL_TYPE(id,name,first)
};
#ifdef ENABLE_ICALL_SYMBOL_MAP
+#undef HANDLES
+#define HANDLES(inner) inner
#undef ICALL_TYPE
#undef ICALL
#define ICALL_TYPE(id,name,first)
};
#endif
+#undef ICALL_TYPE
+#undef ICALL
+#define ICALL_TYPE(id,name,first)
+#define ICALL(id,name,func) 0,
+#undef HANDLES
+#define HANDLES(inner) 1,
+static const guchar
+icall_uses_handles [] = {
+#include "metadata/icall-def.h"
+#undef ICALL
+#undef HANDLES
+};
+
#endif /* DISABLE_ICALL_TABLES */
static mono_mutex_t icall_mutex;
return strcmp (key, method_name);
}
-static gpointer
-find_method_icall (const IcallTypeDesc *imap, const char *name)
+static gsize
+find_slot_icall (const IcallTypeDesc *imap, const char *name)
{
const guint16 *nameslot = (const guint16 *)mono_binary_search (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap);
if (!nameslot)
+ return -1;
+ return (nameslot - &icall_names_idx [0]);
+}
+
+static gboolean
+find_uses_handles_icall (const IcallTypeDesc *imap, const char *name)
+{
+ gsize slotnum = find_slot_icall (imap, name);
+ if (slotnum == -1)
+ return FALSE;
+ return (gboolean)icall_uses_handles [slotnum];
+}
+
+static gpointer
+find_method_icall (const IcallTypeDesc *imap, const char *name)
+{
+ gsize slotnum = find_slot_icall (imap, name);
+ if (slotnum == -1)
return NULL;
- return (gpointer)icall_functions [(nameslot - &icall_names_idx [0])];
+ return (gpointer)icall_functions [slotnum];
}
static int
return strcmp (key, *method_name);
}
-static gpointer
-find_method_icall (const IcallTypeDesc *imap, const char *name)
+static gsize
+find_slot_icall (const IcallTypeDesc *imap, const char *name)
{
const char **nameslot = mono_binary_search (name, icall_names + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names [0]), compare_method_imap);
if (!nameslot)
+ return -1;
+ return nameslot - icall_names;
+}
+
+static gpointer
+find_method_icall (const IcallTypeDesc *imap, const char *name)
+{
+ gsize slotnum = find_slot_icall (imap, name);
+ if (slotnum == -1)
return NULL;
- return (gpointer)icall_functions [(nameslot - icall_names)];
+ return (gpointer)icall_functions [slotnum];
+}
+
+static gboolean
+find_uses_handles_icall (const IcallTypeDesc *imap, const char *name)
+{
+ gsize slotnum = find_slot_icall (imap, name);
+ if (slotnum == -1)
+ return FALSE;
+ return (gboolean)icall_uses_handles [slotnum];
}
static int
}
#endif
+/**
+ * mono_lookup_internal_call_full:
+ * @method: the method to look up
+ * @uses_handles: out argument if method needs handles around managed objects.
+ *
+ * Returns a pointer to the icall code for the given method. If
+ * uses_handles is not NULL, it will be set to TRUE if the method
+ * needs managed objects wrapped using the infrastructure in handle.h
+ *
+ * If the method is not found, warns and returns NULL.
+ */
gpointer
-mono_lookup_internal_call (MonoMethod *method)
+mono_lookup_internal_call_full (MonoMethod *method, mono_bool *uses_handles)
{
char *sigstart;
char *tmpsig;
res = g_hash_table_lookup (icall_hash, mname);
if (res) {
+ if (uses_handles)
+ *uses_handles = FALSE;
mono_icall_unlock ();;
return res;
}
*sigstart = 0;
res = g_hash_table_lookup (icall_hash, mname);
if (res) {
+ if (uses_handles)
+ *uses_handles = FALSE;
mono_icall_unlock ();
return res;
}
#else
/* it wasn't found in the static call tables */
if (!imap) {
+ if (uses_handles)
+ *uses_handles = FALSE;
mono_icall_unlock ();
return NULL;
}
res = find_method_icall (imap, sigstart - mlen);
if (res) {
+ if (uses_handles)
+ *uses_handles = find_uses_handles_icall (imap, sigstart - mlen);
mono_icall_unlock ();
return res;
}
*sigstart = '(';
res = find_method_icall (imap, sigstart - mlen);
if (res) {
+ if (uses_handles)
+ *uses_handles = find_uses_handles_icall (imap, sigstart - mlen);
mono_icall_unlock ();
return res;
}
#endif
}
+gpointer
+mono_lookup_internal_call (MonoMethod *method)
+{
+ return mono_lookup_internal_call_full (method, NULL);
+}
+
#ifdef ENABLE_ICALL_SYMBOL_MAP
static int
func_cmp (gconstpointer key, gconstpointer p)
projects / mono.git / blobdiff