*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
+ * Copyright 2011-2012 Xamarin Inc (http://www.xamarin.com).
*/
#include <config.h>
#include <mono/metadata/mono-debug.h>
#include <mono/metadata/mono-ptr-array.h>
#include <mono/metadata/verify-internals.h>
+#include <mono/metadata/runtime.h>
#include <mono/io-layer/io-layer.h>
#include <mono/utils/strtod.h>
#include <mono/utils/monobitset.h>
#include <mono/utils/mono-error-internals.h>
#include <mono/utils/mono-mmap.h>
#include <mono/utils/mono-io-portability.h>
+#include <mono/utils/mono-digest.h>
#if defined (HOST_WIN32)
#include <windows.h>
extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL;
-static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
+ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
static MonoArray*
type_array_from_modifiers (MonoImage *image, MonoType *type, int optional);
/*
* We expect a pointer to a char, not a string
*/
-static gboolean
+ICALL_EXPORT gboolean
mono_double_ParseImpl (char *ptr, double *result)
{
gchar *endptr = NULL;
return TRUE;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Array_GetValueImpl (MonoObject *this, guint32 pos)
{
MonoClass *ac;
return *ea;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Array_GetValue (MonoObject *this, MonoObject *idxs)
{
MonoClass *ac, *ic;
return ves_icall_System_Array_GetValueImpl (this, pos);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 pos)
{
MonoClass *ac, *vc, *ec;
#undef ASSIGN_REAL
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_SetValue (MonoArray *this, MonoObject *value,
MonoArray *idxs)
{
ves_icall_System_Array_SetValueImpl (this, value, pos);
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
MonoClass *aklass, *klass;
for (i = 0; i < aklass->rank; ++i) {
sizes [i] = mono_array_get (lengths, guint32, i);
if (bounds)
- sizes [i + aklass->rank] = mono_array_get (bounds, guint32, i);
+ sizes [i + aklass->rank] = mono_array_get (bounds, gint32, i);
else
sizes [i + aklass->rank] = 0;
}
return array;
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
MonoClass *aklass, *klass;
return array;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Array_GetRank (MonoObject *this)
{
MONO_ARCH_SAVE_REGS;
return this->vtable->klass->rank;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Array_GetLength (MonoArray *this, gint32 dimension)
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
return length;
}
-static gint64
+ICALL_EXPORT gint64
ves_icall_System_Array_GetLongLength (MonoArray *this, gint32 dimension)
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
return this->bounds [dimension].length;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Array_GetLowerBound (MonoArray *this, gint32 dimension)
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
return this->bounds [dimension].lower_bound;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
{
int sz = mono_array_element_size (mono_object_class (arr));
mono_gc_bzero (mono_array_addr_with_size (arr, sz, idx), length * sz);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
{
int element_size;
return TRUE;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_GetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
{
MonoClass *ac;
mono_gc_memmove (value, ea, esize);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
{
MonoClass *ac, *ec;
}
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
{
MonoClass *klass = array->obj.vtable->klass;
#endif
}
-static gint
+ICALL_EXPORT gint
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
{
MONO_ARCH_SAVE_REGS;
return offsetof (MonoString, chars);
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
{
MONO_ARCH_SAVE_REGS;
return mono_object_clone (obj);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
{
MonoClass *klass;
mono_runtime_class_init (vtable);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage *image)
{
MONO_ARCH_SAVE_REGS;
}
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack (void)
{
guint8 *stack_addr;
return TRUE;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Object_MemberwiseClone (MonoObject *this)
{
MONO_ARCH_SAVE_REGS;
return mono_object_clone (this);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fields)
{
MonoClass *klass;
return result;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray **fields)
{
MonoClass *klass;
}
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_System_Object_GetType (MonoObject *obj)
{
MONO_ARCH_SAVE_REGS;
- if (obj->vtable->klass != mono_defaults.transparent_proxy_class)
- return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
- else
+#ifndef DISABLE_REMOTING
+ if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
+ else
+#endif
+ return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
}
-static void
+ICALL_EXPORT void
mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
{
MONO_ARCH_SAVE_REGS;
g_assert (mtype->type->type);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance)
{
MONO_ARCH_SAVE_REGS;
return mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb,
MonoReflectionMethod *method,
MonoArray *opt_param_types)
mb->dynamic_image, (MonoObject *) method, opt_param_types);
}
-static void
+ICALL_EXPORT void
ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
{
MONO_ARCH_SAVE_REGS;
mono_image_create_pefile (mb, file);
}
-static void
+ICALL_EXPORT void
ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
{
MONO_ARCH_SAVE_REGS;
mono_image_build_metadata (mb);
}
-static void
+ICALL_EXPORT void
ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token)
{
MONO_ARCH_SAVE_REGS;
}
#endif
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_type_from_name (MonoString *name,
MonoBoolean throwOnError,
MonoBoolean ignoreCase)
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_type_from_handle (MonoType *handle)
{
MonoDomain *domain = mono_domain_get ();
return mono_type_get_object (domain, handle);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Type_EqualsInternal (MonoReflectionType *type, MonoReflectionType *c)
{
MONO_ARCH_SAVE_REGS;
TYPECODE_STRING = 18
} TypeCode;
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_GetTypeCodeInternal (MonoReflectionType *type)
{
int t = type->type->type;
return 0;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces)
{
MonoDomain *domain;
return type;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
{
MonoDomain *domain;
return mono_class_is_assignable_from (klass, klassc);
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_type_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return mono_object_isinst (obj, klass) != NULL;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_get_attributes (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return klass->flags;
}
-static MonoReflectionMarshal*
-ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *field)
+ICALL_EXPORT MonoReflectionMarshalAsAttribute*
+ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionField *field)
{
MonoClass *klass = field->field->parent;
MonoMarshalType *info;
if (!info->fields [i].mspec)
return NULL;
else
- return mono_reflection_marshal_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
+ return mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
}
}
return NULL;
}
-static MonoReflectionField*
+ICALL_EXPORT MonoReflectionField*
ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type)
{
gboolean found = FALSE;
return mono_field_get_object (mono_domain_get (), klass, handle);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
{
MonoError error;
return type_array_from_modifiers (field->field->parent->image, type, optional);
}
-static int
+ICALL_EXPORT int
vell_icall_get_method_attributes (MonoMethod *method)
{
return method->flags;
}
-static void
+ICALL_EXPORT void
ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
{
MonoError error;
info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
{
MonoDomain *domain = mono_domain_get ();
return mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL);
}
-static MonoReflectionMarshal*
+ICALL_EXPORT MonoReflectionMarshalAsAttribute*
ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
{
MonoDomain *domain = mono_domain_get ();
- MonoReflectionMarshal* res = NULL;
+ MonoReflectionMarshalAsAttribute* res = NULL;
MonoMarshalSpec **mspecs;
int i;
mono_method_get_marshal_info (method, mspecs);
if (mspecs [0])
- res = mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [0]);
+ res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0]);
for (i = mono_method_signature (method)->param_count; i >= 0; i--)
if (mspecs [i])
return res;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
{
MonoClass *parent = field->field->parent;
return field->field->offset - sizeof (MonoObject);
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
{
MonoClass *parent;
return mono_type_get_object (mono_object_domain (field), &parent->byval_arg);
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
{
MonoClass *fklass = field->klass;
return mono_field_get_value_object (domain, cf, obj);
}
-static void
+ICALL_EXPORT void
ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *obj, MonoObject *value)
{
MonoError error;
}
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *this)
{
MonoObject *o = NULL;
return o;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoField_ResolveType (MonoReflectionField *ref_field)
{
MonoError error;
return mono_type_get_object (mono_object_domain (ref_field), type);
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod *rmethod)
{
MonoMethod *method = rmethod->method.method;
PInfo_Name = 1 << 5
} PInfo;
-static void
+ICALL_EXPORT void
ves_icall_get_property_info (MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
{
MonoDomain *domain = mono_object_domain (property);
*/
}
-static void
+ICALL_EXPORT void
ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
{
MonoDomain *domain = mono_object_domain (event);
mono_metadata_free_type (inflated);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetInterfaces (MonoReflectionType* type)
{
MonoError error;
return NULL;
}
-static void
+ICALL_EXPORT void
ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
{
gboolean variance_used;
}
}
-static void
+ICALL_EXPORT void
ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
}
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoType_GetElementType (MonoReflectionType *type)
{
MonoClass *class;
return NULL;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_get_type_parent (MonoReflectionType *type)
{
MonoClass *class = mono_class_from_mono_type (type->type);
return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_ispointer (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return type->type->type == MONO_TYPE_PTR;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_isprimitive (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_isbyref (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return type->type->byref;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_type_iscomobject (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return (klass && klass->is_com_object);
}
-static MonoReflectionModule*
+ICALL_EXPORT MonoReflectionModule*
ves_icall_MonoType_get_Module (MonoReflectionType *type)
{
MonoClass *class = mono_class_from_mono_type (type->type);
return mono_module_get_object (mono_object_domain (type), class->image);
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
return mono_assembly_get_object (domain, class->image->assembly);
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
return class ? mono_type_get_object (domain, &class->byval_arg) : NULL;
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_MonoType_get_Name (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
}
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_MonoType_get_Namespace (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
return mono_string_new (domain, class->name_space);
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_MonoType_GetArrayRank (MonoReflectionType *type)
{
MonoClass *class;
return class->rank;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type)
{
MonoArray *res;
return res;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
{
MonoClass *klass;
return klass->generic_container != NULL;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
{
MonoClass *klass;
return NULL;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
{
MonoClass *class;
return mono_type_get_object (mono_object_domain (type), geninst);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type)
{
MonoClass *klass;
return klass->generic_class != NULL;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
{
MonoClass *klass;
return klass->generic_class != NULL || klass->generic_container != NULL;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return -1;
}
-static GenericParameterAttributes
+ICALL_EXPORT GenericParameterAttributes
ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return mono_generic_param_info (type->type->data.generic_param)->flags;
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
{
MonoGenericParamInfo *param_info;
return res;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
return is_generic_parameter (type->type);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb)
{
MONO_ARCH_SAVE_REGS;
return is_generic_parameter (tb->type.type);
}
-static void
+ICALL_EXPORT void
ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
MonoReflectionType *t)
{
enumtype->type = t->type;
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
MonoReflectionMethod* generic)
{
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type)
{
MonoMethod *method;
return mono_method_get_object (mono_object_domain (ref_type), method, method->klass);
}
-static MonoReflectionDllImportAttribute*
+ICALL_EXPORT MonoReflectionDllImportAttribute*
ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method)
{
static MonoClass *DllImportAttributeClass = NULL;
return attr;
}
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
{
MonoMethodInflated *imethod;
return mono_method_get_object (mono_object_domain (method), result, NULL);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
return mono_method_signature (method->method)->generic_param_count != 0;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
return method->method->is_generic;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
{
MonoArray *res;
return res;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoException **exc)
{
/*
* greater flexibility.
*/
MonoMethod *m = method->method;
+ MonoMethodSignature *sig = mono_method_signature (m);
int pcount;
void *obj = this;
if (this) {
if (!mono_object_isinst (this, m->klass)) {
- mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Object does not match target type."));
+ char *this_name = mono_type_get_full_name (mono_object_get_class (this));
+ char *target_name = mono_type_get_full_name (m->klass);
+ char *msg = g_strdup_printf ("Object of type '%s' doesn't match target type '%s'", this_name, target_name);
+ mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", msg));
+ g_free (msg);
+ g_free (target_name);
+ g_free (this_name);
return NULL;
}
m = mono_object_get_virtual_method (this, m);
}
}
+ if (sig->ret->byref) {
+ mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection"));
+ return NULL;
+ }
+
pcount = params? mono_array_length (params): 0;
- if (pcount != mono_method_signature (m)->param_count) {
+ if (pcount != sig->param_count) {
mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException"));
return NULL;
}
return mono_runtime_invoke_array (m, obj, params, NULL);
}
-static MonoObject *
+#ifndef DISABLE_REMOTING
+ICALL_EXPORT MonoObject *
ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoArray **outArgs)
{
MonoDomain *domain = mono_object_domain (method);
return result;
}
+#endif
static guint64
read_enum_value (char *mem, int type)
return;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, MonoObject *value)
{
MonoDomain *domain;
return res;
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Enum_get_value (MonoObject *this)
{
MonoObject *res;
return res;
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
{
MonoType *etype;
return mono_type_get_object (mono_object_domain (type), etype);
}
-static int
+ICALL_EXPORT int
ves_icall_System_Enum_compare_value_to (MonoObject *this, MonoObject *other)
{
gpointer tdata = (char *)this + sizeof (MonoObject);
return 0;
}
-static int
+ICALL_EXPORT int
ves_icall_System_Enum_get_hashcode (MonoObject *this)
{
gpointer data = (char *)this + sizeof (MonoObject);
return 0;
}
-static void
+ICALL_EXPORT void
ves_icall_get_enum_info (MonoReflectionType *type, MonoEnumInfo *info)
{
MonoDomain *domain = mono_object_domain (type);
BFLAGS_OptionalParamBinding = 0x40000
};
-static MonoReflectionField *
+ICALL_EXPORT MonoReflectionField *
ves_icall_Type_GetField (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
}
}
-static MonoArray*
-ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
+GPtrArray*
+mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, MonoException **ex)
{
- static MonoClass *MethodInfo_array;
- MonoDomain *domain;
- MonoClass *startklass, *klass, *refklass;
- MonoArray *res;
+ GPtrArray *array;
+ MonoClass *startklass;
MonoMethod *method;
gpointer iter;
- MonoObject *member;
- int i, len, match, nslots;
+ int len, match, nslots;
/*FIXME, use MonoBitSet*/
guint32 method_slots_default [8];
guint32 *method_slots = NULL;
- gchar *mname = NULL;
int (*compare_func) (const char *s1, const char *s2) = NULL;
- MonoVTable *array_vtable;
- MonoException *ex;
- MonoPtrArray tmp_array;
- mono_ptr_array_init (tmp_array, 4);
-
- if (!MethodInfo_array) {
- MonoClass *klass = mono_array_class_get (mono_defaults.method_info_class, 1);
- mono_memory_barrier ();
- MethodInfo_array = klass;
- }
-
- domain = ((MonoObject *)type)->vtable->domain;
- array_vtable = mono_class_vtable_full (domain, MethodInfo_array, TRUE);
- if (type->type->byref)
- return mono_array_new_specific (array_vtable, 0);
- klass = startklass = mono_class_from_mono_type (type->type);
- refklass = mono_class_from_mono_type (reftype->type);
+ array = g_ptr_array_new ();
+ startklass = klass;
+ *ex = NULL;
len = 0;
- if (name != NULL) {
- mname = mono_string_to_utf8 (name);
+ if (name != NULL)
compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
- }
/* An optimization for calls made from Delegate:CreateDelegate () */
- if (klass->delegate && mname && !strcmp (mname, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) {
+ if (klass->delegate && name && !strcmp (name, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) {
method = mono_get_delegate_invoke (klass);
if (mono_loader_get_last_error ())
goto loader_error;
- member = (MonoObject*)mono_method_get_object (domain, method, refklass);
-
- res = mono_array_new_specific (array_vtable, 1);
- mono_array_setref (res, 0, member);
- g_free (mname);
- return res;
+ g_ptr_array_add (array, method);
+ return array;
}
mono_class_setup_vtable (klass);
if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
goto loader_error;
- if (is_generic_parameter (type->type))
+ if (is_generic_parameter (&klass->byval_arg))
nslots = mono_class_get_vtable_size (klass->parent);
else
nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : mono_class_get_vtable_size (klass);
method_slots [method->slot >> 5] |= 1 << (method->slot & 0x1f);
}
- if (method->name [0] == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0))
+ if (!allow_ctors && method->name [0] == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0))
continue;
if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
if (bflags & BFLAGS_Public)
continue;
if (name != NULL) {
- if (compare_func (mname, method->name))
+ if (compare_func (name, method->name))
continue;
}
match = 0;
-
- member = (MonoObject*)mono_method_get_object (domain, method, refklass);
-
- mono_ptr_array_append (tmp_array, member);
+ g_ptr_array_add (array, method);
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
-
- g_free (mname);
if (method_slots != method_slots_default)
g_free (method_slots);
- res = mono_array_new_specific (array_vtable, mono_ptr_array_size (tmp_array));
-
- for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
- mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
-
- mono_ptr_array_destroy (tmp_array);
- return res;
+ return array;
loader_error:
- g_free (mname);
if (method_slots != method_slots_default)
g_free (method_slots);
- mono_ptr_array_destroy (tmp_array);
+ g_ptr_array_free (array, TRUE);
+
if (klass->exception_type != MONO_EXCEPTION_NONE) {
- ex = mono_class_get_exception_for_failure (klass);
+ *ex = mono_class_get_exception_for_failure (klass);
} else {
- ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
+ *ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
mono_loader_clear_error ();
}
- mono_raise_exception (ex);
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
+ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
+{
+ static MonoClass *MethodInfo_array;
+ MonoDomain *domain;
+ MonoArray *res;
+ MonoVTable *array_vtable;
+ MonoException *ex = NULL;
+ const char *mname = NULL;
+ GPtrArray *method_array;
+ MonoClass *klass, *refklass;
+ int i;
+
+ if (!MethodInfo_array) {
+ MonoClass *klass = mono_array_class_get (mono_defaults.method_info_class, 1);
+ mono_memory_barrier ();
+ MethodInfo_array = klass;
+ }
+
+ klass = mono_class_from_mono_type (type->type);
+ refklass = mono_class_from_mono_type (reftype->type);
+ domain = ((MonoObject *)type)->vtable->domain;
+ array_vtable = mono_class_vtable_full (domain, MethodInfo_array, TRUE);
+ if (type->type->byref)
+ return mono_array_new_specific (array_vtable, 0);
+
+ if (name)
+ mname = mono_string_to_utf8 (name);
+
+ method_array = mono_class_get_methods_by_name (klass, mname, bflags, ignore_case, FALSE, &ex);
+ g_free ((char*)mname);
+ if (ex)
+ mono_raise_exception (ex);
+
+ res = mono_array_new_specific (array_vtable, method_array->len);
+
+
+ for (i = 0; i < method_array->len; ++i) {
+ MonoMethod *method = g_ptr_array_index (method_array, i);
+ mono_array_setref (res, i, mono_method_get_object (domain, method, refklass));
+ }
+
+ g_ptr_array_free (method_array, TRUE);
+ return res;
+}
+
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
return method_nonpublic (accessor, start_klass);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
MonoException *ex;
return NULL;
}
-static MonoReflectionEvent *
+ICALL_EXPORT MonoReflectionEvent *
ves_icall_MonoType_GetEvent (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoException *ex;
return NULL;
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_GetNestedType (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoDomain *domain;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags)
{
MonoDomain *domain;
return res;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
gchar *str;
return FALSE;
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly, MonoBoolean escaped)
{
MonoDomain *domain = mono_object_domain (assembly);
return res;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssembly *assembly)
{
MonoAssembly *mass = assembly->assembly;
return mass->in_gac;
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
{
gchar *name;
return mono_assembly_get_object (mono_domain_get (), res);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_object_domain (assembly);
return res;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly)
{
MONO_ARCH_SAVE_REGS;
return assembly->assembly->ref_only;
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_object_domain (assembly);
return mono_string_new (domain, assembly->assembly->image->version);
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
{
guint32 token = mono_image_get_entry_point (assembly->assembly->image);
return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL);
}
-static MonoReflectionModule*
+ICALL_EXPORT MonoReflectionModule*
ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly)
{
return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
{
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
return result;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
{
static MonoClass *System_Reflection_AssemblyName;
return result;
}
-typedef struct {
- MonoArray *res;
- int idx;
-} NameSpaceInfo;
-
-static void
-foreach_namespace (const char* key, gconstpointer val, NameSpaceInfo *info)
-{
- MonoString *name = mono_string_new (mono_object_domain (info->res), key);
-
- mono_array_setref (info->res, info->idx, name);
- info->idx++;
-}
-
-static MonoArray*
-ves_icall_System_Reflection_Assembly_GetNamespaces (MonoReflectionAssembly *assembly)
-{
- MonoImage *img = assembly->assembly->image;
- MonoArray *res;
- NameSpaceInfo info;
- int len;
-
- MONO_ARCH_SAVE_REGS;
-
- mono_image_lock (img);
- mono_image_init_name_cache (img);
-
-RETRY_LEN:
- len = g_hash_table_size (img->name_cache);
- mono_image_unlock (img);
-
- /*we can't create objects holding the image lock */
- res = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, len);
-
- mono_image_lock (img);
- /*len might have changed, create a new array*/
- if (len != g_hash_table_size (img->name_cache))
- goto RETRY_LEN;
-
- info.res = res;
- info.idx = 0;
- g_hash_table_foreach (img->name_cache, (GHFunc)foreach_namespace, &info);
- mono_image_unlock (img);
-
- return res;
-}
-
/* move this in some file in mono/util/ */
static char *
g_concat_dir_and_file (const char *dir, const char *file)
return g_strconcat (dir, file, NULL);
}
-static void *
+ICALL_EXPORT void *
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
{
char *n = mono_string_to_utf8 (name);
return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info)
{
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
return TRUE;
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
{
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
return (MonoObject*)result;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_domain_get();
return res;
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_GetCurrentMethod (void)
{
MonoMethod *m = mono_method_get_last_managed ();
return klass->methods [offset];
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
{
MonoClass *klass;
return mono_method_get_object (mono_domain_get (), method, klass);
}
-static MonoReflectionMethod*
+ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method)
{
return mono_method_get_object (mono_domain_get (), method, NULL);
}
-static MonoReflectionMethodBody*
+ICALL_EXPORT MonoReflectionMethodBody*
ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
{
return mono_method_body_get_object (mono_domain_get (), method);
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
{
MonoMethod *dest = NULL;
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
{
MonoDomain* domain = mono_domain_get ();
return mono_assembly_get_object (domain, domain->entry_assembly);
}
-static MonoReflectionAssembly*
+ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
{
MonoMethod *m;
return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
gboolean assembly_qualified)
{
return res;
}
-static int
+ICALL_EXPORT int
vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *this)
{
MonoClass *klass = mono_class_from_mono_type (this->type);
}
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly *assembly)
{
MonoDomain *domain = mono_object_domain (assembly);
return res;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
{
gchar *absolute;
g_free (absolute);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
{
char *filename;
mono_image_close (image);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly *assembly,
char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength)
{
return res;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
{
MonoArray *res = NULL;
return res;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
{
MonoAssemblyName aname;
return TRUE;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
{
MonoDomain *domain = mono_object_domain (module);
return mono_type_get_object (domain, &klass->byval_arg);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module)
{
/*if (module->image)
mono_image_close (module->image);*/
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module)
{
MonoDomain *domain = mono_object_domain (module);
return mono_string_new (domain, module->image->guid);
}
-static gpointer
+ICALL_EXPORT gpointer
ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule *module)
{
#ifdef HOST_WIN32
return (gpointer) (-1);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine)
{
if (image->dynamic) {
}
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image)
{
return (image->md_version_major << 16) | (image->md_version_minor);
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
MonoArray *exceptions;
context->method_inst = NULL;
}
-static MonoType*
+ICALL_EXPORT MonoType*
ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
MonoClass *klass;
return NULL;
}
-static MonoMethod*
+ICALL_EXPORT MonoMethod*
ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
return method;
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
{
int index = mono_metadata_token_index (token);
return mono_ldstr (mono_domain_get (), image, index);
}
-static MonoClassField*
+ICALL_EXPORT MonoClassField*
ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
MonoClass *klass;
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
return res;
}
-static MonoReflectionType*
+ICALL_EXPORT MonoReflectionType*
ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
{
MonoClass *klass;
return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_Type_IsArrayImpl (MonoReflectionType *t)
{
MonoType *type;
mono_raise_exception ((MonoException*)mono_get_exception_type_load (str, NULL));
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
{
MonoClass *klass, *aklass;
return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_make_byref_type (MonoReflectionType *type)
{
MonoClass *klass;
return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Type_MakePointerType (MonoReflectionType *type)
{
MonoClass *klass, *pklass;
return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
}
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
{
return delegate;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate *this)
{
/* Reset the invoke impl to the default one */
*
* Returns true on success and zero on failure.
*/
-static guint32
+ICALL_EXPORT guint32
ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
{
#ifndef HOST_WIN32
mono_array_set ((*data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
return 1;
} else {
+ struct tm end;
+ time_t te;
+
+ memset (&end, 0, sizeof (end));
+ end.tm_year = year-1900 + 1;
+ end.tm_mday = 1;
+
+ te = mktime (&end);
+
mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
mono_array_set ((*data), gint64, 0, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
+ mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
+ mono_array_set ((*data), gint64, 1, ((gint64)te + EPOCH_ADJUST) * 10000000L);
is_daylight = 1;
}
#endif
}
-static gpointer
+ICALL_EXPORT gpointer
ves_icall_System_Object_obj_address (MonoObject *this)
{
MONO_ARCH_SAVE_REGS;
}
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
{
MONO_ARCH_SAVE_REGS;
return mono_array_get_byte_length (array);
}
-static gint8
+ICALL_EXPORT gint8
ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
{
MONO_ARCH_SAVE_REGS;
return mono_array_get (array, gint8, idx);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
{
MONO_ARCH_SAVE_REGS;
mono_array_set (array, gint8, idx, value);
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count)
{
guint8 *src_buf, *dest_buf;
MONO_ARCH_SAVE_REGS;
+ /* This is called directly from the class libraries without going through the managed wrapper */
+ MONO_CHECK_ARG_NULL (src);
+ MONO_CHECK_ARG_NULL (dest);
+
/* watch out for integer overflow */
if ((src_offset > mono_array_get_byte_length (src) - count) || (dest_offset > mono_array_get_byte_length (dest) - count))
return FALSE;
return TRUE;
}
-static MonoObject *
+#ifndef DISABLE_REMOTING
+ICALL_EXPORT MonoObject *
ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this, MonoString *class_name)
{
MonoDomain *domain = mono_object_domain (this);
return res;
}
-static MonoReflectionType *
+ICALL_EXPORT MonoReflectionType *
ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
{
return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg);
}
+#endif
/* System.Environment */
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_get_MachineName (void)
{
#if defined (HOST_WIN32)
#endif
}
-static int
+ICALL_EXPORT int
ves_icall_System_Environment_get_Platform (void)
{
#if defined (TARGET_WIN32)
#endif
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_get_NewLine (void)
{
MONO_ARCH_SAVE_REGS;
#endif
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
{
const gchar *value;
#endif
#endif
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
{
#ifdef HOST_WIN32
#define g_unsetenv(a) unsetenv(a)
#endif
-static void
+ICALL_EXPORT void
ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
{
MonoError error;
#endif
}
-static void
+ICALL_EXPORT void
ves_icall_System_Environment_Exit (int result)
{
MONO_ARCH_SAVE_REGS;
+#ifndef MONO_CROSS_COMPILE
+ mono_runtime_shutdown ();
+#endif
+
mono_threads_set_shutting_down ();
mono_runtime_set_shutting_down ();
exit (result);
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Environment_GetGacPath (void)
{
return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ());
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Environment_GetWindowsFolderPath (int folder)
{
#if defined (HOST_WIN32)
return mono_string_new (mono_domain_get (), "");
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetLogicalDrives (void)
{
gunichar2 buf [256], *ptr, *dname;
return result;
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path)
{
gunichar2 volume_name [MAX_PATH + 1];
return mono_string_from_utf16 (volume_name);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Environment_InternalGetHome (void)
{
MONO_ARCH_SAVE_REGS;
* 1 at entry, and we can not compute a suitable code page number,
* returns the code page as a string
*/
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page)
{
const char *cset;
return NULL;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Environment_get_HasShutdownStarted (void)
{
if (mono_runtime_is_shutting_down ())
return FALSE;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Environment_BroadcastSettingChange (void)
{
#ifdef HOST_WIN32
#endif
}
-static void
+ICALL_EXPORT void
ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this,
MonoReflectionMethod *method,
MonoArray *out_args)
mono_message_init (mono_object_domain (this), this, method, out_args);
}
-static MonoBoolean
+#ifndef DISABLE_REMOTING
+ICALL_EXPORT MonoBoolean
ves_icall_IsTransparentProxy (MonoObject *proxy)
{
MONO_ARCH_SAVE_REGS;
return 0;
}
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_Remoting_RemotingServices_GetVirtualMethod (
MonoReflectionType *rtype, MonoReflectionMethod *rmethod)
{
return mono_method_get_object (mono_domain_get (), res, NULL);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
{
MonoClass *klass;
if (enable) vtable->remote = 1;
else vtable->remote = 0;
}
+#endif
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType *type)
{
MonoClass *klass;
}
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_IO_get_temp_path (void)
{
MONO_ARCH_SAVE_REGS;
}
#ifndef PLATFORM_NO_DRIVEINFO
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 *free_bytes_avail,
guint64 *total_number_of_bytes, guint64 *total_number_of_free_bytes,
gint32 *error)
return result;
}
-static guint32
+ICALL_EXPORT guint32
ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name)
{
MONO_ARCH_SAVE_REGS;
}
#endif
-static gpointer
+ICALL_EXPORT gpointer
ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
{
MONO_ARCH_SAVE_REGS;
return mono_compile_method (method);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
{
MonoString *mcpath;
return mono_string_new (mono_domain_get (), machine_config);
}
-static MonoString *
+ICALL_EXPORT MonoString *
ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void)
{
MonoString *ipath;
return ipath;
}
-static gboolean
+ICALL_EXPORT gboolean
ves_icall_get_resources_ptr (MonoReflectionAssembly *assembly, gpointer *result, gint32 *size)
{
MonoPEResourceDataEntry *entry;
return TRUE;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Diagnostics_Debugger_IsAttached_internal (void)
{
return mono_debug_using_mono_debugger () || mono_is_debugger_attached ();
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
ves_icall_System_Diagnostics_Debugger_IsLogging (void)
{
if (mono_get_runtime_callbacks ()->debug_log_is_enabled)
return FALSE;
}
-static void
+ICALL_EXPORT void
ves_icall_System_Diagnostics_Debugger_Log (int level, MonoString *category, MonoString *message)
{
if (mono_get_runtime_callbacks ()->debug_log)
mono_get_runtime_callbacks ()->debug_log (level, category, message);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoString *message)
{
#if defined (HOST_WIN32)
}
/* Only used for value types */
-static MonoObject *
+ICALL_EXPORT MonoObject *
ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
{
MonoClass *klass;
return mono_object_new (domain, klass);
}
-static MonoReflectionMethod *
+ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definition)
{
MonoClass *klass, *parent;
return mono_method_get_object (mono_domain_get (), result, NULL);
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
{
MonoMethod *method = m->method;
return m->name;
}
-static void
+ICALL_EXPORT void
mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
{
MONO_ARCH_SAVE_REGS;
/* g_print ("sig %p, param_count: %d, sent: %d\n", iter->sig, iter->sig->param_count, iter->sig->sentinelpos); */
}
-static MonoTypedRef
+ICALL_EXPORT MonoTypedRef
mono_ArgIterator_IntGetNextArg (MonoArgIterator *iter)
{
guint32 i, arg_size;
res.type = iter->sig->params [i];
res.klass = mono_class_from_mono_type (res.type);
arg_size = mono_type_stack_size (res.type, &align);
-#if defined(__arm__)
+#if defined(__arm__) || defined(__mips__)
iter->args = (guint8*)(((gsize)iter->args + (align) - 1) & ~(align - 1));
#endif
res.value = iter->args;
return res;
}
-static MonoTypedRef
+ICALL_EXPORT MonoTypedRef
mono_ArgIterator_IntGetNextArgT (MonoArgIterator *iter, MonoType *type)
{
guint32 i, arg_size;
res.klass = mono_class_from_mono_type (res.type);
/* FIXME: endianess issue... */
arg_size = mono_type_stack_size (res.type, &align);
-#if defined(__arm__)
+#if defined(__arm__) || defined(__mips__)
iter->args = (guint8*)(((gsize)iter->args + (align) - 1) & ~(align - 1));
#endif
res.value = iter->args;
return res;
}
-static MonoType*
+ICALL_EXPORT MonoType*
mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter)
{
gint i;
return iter->sig->params [i];
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
mono_TypedReference_ToObject (MonoTypedRef tref)
{
MONO_ARCH_SAVE_REGS;
return mono_value_box (mono_domain_get (), tref.klass, tref.value);
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
mono_TypedReference_ToObjectInternal (MonoType *type, gpointer value, MonoClass *klass)
{
MONO_ARCH_SAVE_REGS;
/* create the wrapper, too? */
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
prelink_method (method->method);
}
-static void
+ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
}
/* These parameters are "readonly" in corlib/System/NumberFormatter.cs */
-static void
+ICALL_EXPORT void
ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas,
gint32 const **exponents,
gunichar2 const **digitLowerTable,
*decHexDigits = Formatter_DecHexDigits;
}
-static void
+ICALL_EXPORT void
get_category_data (int version,
guint8 const **category_data,
guint16 const **category_astral_index)
}
/* These parameters are "readonly" in corlib/System/Char.cs */
-static void
+ICALL_EXPORT void
ves_icall_System_Char_GetDataTablePointers (int category_data_version,
guint8 const **category_data,
guint16 const **category_astral_index,
*to_upper_data_high = ToUpperDataHigh;
}
-static gint32
+ICALL_EXPORT gint32
ves_icall_MonoDebugger_GetMethodToken (MonoReflectionMethod *method)
{
return method->method->token;
return res;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
param_info_get_type_modifiers (MonoReflectionParameter *param, MonoBoolean optional)
{
MonoType *type = param->ClassImpl->type;
return NULL;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
property_info_get_type_modifiers (MonoReflectionProperty *property, MonoBoolean optional)
{
MonoType *type = get_property_type (property->property);
type->data.klass = mono_class_from_mono_type (real_type);
}
-static MonoObject*
+ICALL_EXPORT MonoObject*
property_info_get_default_value (MonoReflectionProperty *property)
{
MonoType blob_type;
return o;
}
-static MonoBoolean
+ICALL_EXPORT MonoBoolean
custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type)
{
MonoClass *attr_class = mono_class_from_mono_type (attr_type->type);
return found;
}
-static MonoArray*
+ICALL_EXPORT MonoArray*
custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
{
MonoClass *attr_class = attr_type ? mono_class_from_mono_type (attr_type->type) : NULL;
}
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_Mono_Runtime_GetDisplayName (void)
{
char *info;
return display_name;
}
-static MonoString*
+ICALL_EXPORT MonoString*
ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
MonoString *message;
gint a [4], b [4];
MonoException *exc;
+ int havePadding = 0;
ignored = 0;
last = prev_last = 0, prev2_last = 0;
for (i = 0; i < ilength; i++) {
mono_raise_exception (exc);
} else if (isspace (c)) {
ignored++;
+ } else if (havePadding && c != '=') {
+ exc = mono_exception_from_name_msg (mono_get_corlib (),
+ "System", "FormatException",
+ "Invalid character found.");
+ mono_raise_exception (exc);
} else {
+ if (c == '=') havePadding = 1;
prev2_last = prev_last;
prev_last = last;
last = c;
return result;
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
InternalFromBase64String (MonoString *str, MonoBoolean allowWhitespaceOnly)
{
MONO_ARCH_SAVE_REGS;
mono_string_length (str), allowWhitespaceOnly);
}
-static MonoArray *
+ICALL_EXPORT MonoArray *
InternalFromBase64CharArray (MonoArray *input, gint offset, gint length)
{
MONO_ARCH_SAVE_REGS;
length, FALSE);
}
+#ifndef DISABLE_ICALL_TABLES
+
#define ICALL_TYPE(id,name,first)
#define ICALL(id,name,func) Icall_ ## id,
NULL
};
+#ifdef ENABLE_ICALL_SYMBOL_MAP
+#undef ICALL_TYPE
+#undef ICALL
+#define ICALL_TYPE(id,name,first)
+#define ICALL(id,name,func) #func,
+static const gconstpointer
+icall_symbols [] = {
+#include "metadata/icall-def.h"
+ NULL
+};
+#endif
+
+#endif /* DISABLE_ICALL_TABLES */
+
static GHashTable *icall_hash = NULL;
static GHashTable *jit_icall_hash_name = NULL;
static GHashTable *jit_icall_hash_addr = NULL;
void
mono_icall_init (void)
{
+#ifndef DISABLE_ICALL_TABLES
int i = 0;
/* check that tables are sorted: disable in release */
}
}
}
+#endif
icall_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
}
mono_loader_unlock ();
}
+#ifndef DISABLE_ICALL_TABLES
+
#ifdef HAVE_ARRAY_ELEM_INIT
static int
compare_method_imap (const void *key, const void *elem)
return &icall_type_descs [nameslot - &icall_type_names_idx [0]];
}
-#else
+#else /* HAVE_ARRAY_ELEM_INIT */
+
static int
compare_method_imap (const void *key, const void *elem)
{
return &icall_type_descs [nameslot - icall_type_names];
}
-#endif
+#endif /* HAVE_ARRAY_ELEM_INIT */
+
+#endif /* DISABLE_ICALL_TABLES */
/*
* we should probably export this as an helper (handle nested types).
return nspacelen + cnamelen;
}
+#ifdef DISABLE_ICALL_TABLES
+static void
+no_icall_table (void)
+{
+ g_assert_not_reached ();
+}
+#endif
+
gpointer
mono_lookup_internal_call (MonoMethod *method)
{
char mname [2048];
int typelen = 0, mlen, siglen;
gpointer res;
- const IcallTypeDesc *imap;
+#ifndef DISABLE_ICALL_TABLES
+ const IcallTypeDesc *imap = NULL;
+#endif
g_assert (method != NULL);
return NULL;
}
+#ifndef DISABLE_ICALL_TABLES
imap = find_class_icalls (mname);
+#endif
mname [typelen] = ':';
mname [typelen + 1] = ':';
return res;
}
+#ifdef DISABLE_ICALL_TABLES
+ mono_loader_unlock ();
+ /* Fail only when the result is actually used */
+ /* mono_marshal_get_native_wrapper () depends on this */
+ if (method->klass == mono_defaults.string_class && !strcmp (method->name, ".ctor"))
+ return ves_icall_System_String_ctor_RedirectToCreateString;
+ else
+ return no_icall_table;
+#else
/* it wasn't found in the static call tables */
if (!imap) {
mono_loader_unlock ();
mono_loader_unlock ();
return NULL;
+#endif
+}
+
+#ifdef ENABLE_ICALL_SYMBOL_MAP
+static int
+func_cmp (gconstpointer key, gconstpointer p)
+{
+ return (gsize)key - (gsize)*(gsize*)p;
+}
+#endif
+
+/*
+ * mono_lookup_icall_symbol:
+ *
+ * Given the icall METHOD, returns its C symbol.
+ */
+const char*
+mono_lookup_icall_symbol (MonoMethod *m)
+{
+#ifdef DISABLE_ICALL_TABLES
+ g_assert_not_reached ();
+ return NULL;
+#else
+#ifdef ENABLE_ICALL_SYMBOL_MAP
+ gpointer func;
+ int i;
+ gpointer slot;
+ static gconstpointer *functions_sorted;
+ static const char**symbols_sorted;
+ static gboolean inited;
+
+ if (!inited) {
+ gboolean changed;
+
+ functions_sorted = g_malloc (G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
+ memcpy (functions_sorted, icall_functions, G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
+ symbols_sorted = g_malloc (G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
+ memcpy (symbols_sorted, icall_symbols, G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
+ /* Bubble sort the two arrays */
+ changed = TRUE;
+ while (changed) {
+ changed = FALSE;
+ for (i = 0; i < G_N_ELEMENTS (icall_functions) - 1; ++i) {
+ if (functions_sorted [i] > functions_sorted [i + 1]) {
+ gconstpointer tmp;
+
+ tmp = functions_sorted [i];
+ functions_sorted [i] = functions_sorted [i + 1];
+ functions_sorted [i + 1] = tmp;
+ tmp = symbols_sorted [i];
+ symbols_sorted [i] = symbols_sorted [i + 1];
+ symbols_sorted [i + 1] = tmp;
+ changed = TRUE;
+ }
+ }
+ }
+ }
+
+ func = mono_lookup_internal_call (m);
+ if (!func)
+ return NULL;
+ slot = bsearch (func, functions_sorted, G_N_ELEMENTS (icall_functions), sizeof (gpointer), func_cmp);
+ if (!slot)
+ return NULL;
+ g_assert (slot);
+ return symbols_sorted [(gpointer*)slot - (gpointer*)functions_sorted];
+#else
+ fprintf (stderr, "icall symbol maps not enabled, pass --enable-icall-symbol-map to configure.\n");
+ g_assert_not_reached ();
+ return 0;
+#endif
+#endif
}
static MonoType*
return jit_icall_hash_name;
}
+/*
+ * mono_lookup_jit_icall_symbol:
+ *
+ * Given the jit icall NAME, returns its C symbol if possible, or NULL.
+ */
+const char*
+mono_lookup_jit_icall_symbol (const char *name)
+{
+ MonoJitICallInfo *info;
+ const char *res = NULL;
+
+ mono_loader_lock ();
+ info = g_hash_table_lookup (jit_icall_hash_name, name);
+ if (info)
+ res = info->c_symbol;
+ mono_loader_unlock ();
+ return res;
+}
+
void
mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
{
}
MonoJitICallInfo *
-mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, const char *c_symbol)
{
MonoJitICallInfo *info;
info->name = name;
info->func = func;
info->sig = sig;
+ info->c_symbol = c_symbol;
if (is_save) {
info->wrapper = func;
mono_loader_unlock ();
return info;
}
+
+MonoJitICallInfo *
+mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+{
+ return mono_register_jit_icall_full (func, name, sig, is_save, NULL);
+}
+
projects / mono.git / blobdiff