X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fobject-internals.h;h=26b11d77371cea4845516ba3b19805a7f4390335;hb=24e97e5c52d88408b1e323fe0b2d3a4b99f35302;hp=f0e024c1d4f1d137a2a94bab73d88d7eade6178f;hpb=b1f867e4e54ce055ea8550c934ed24e6f143bd9b;p=mono.git diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index f0e024c1d4f..26b11d77371 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -1,3 +1,7 @@ +/** + * \file + */ + #ifndef __MONO_OBJECT_INTERNALS_H__ #define __MONO_OBJECT_INTERNALS_H__ @@ -156,6 +160,19 @@ struct _MonoString { mono_gc_wbarrier_arrayref_copy (__p, __s, (count)); \ } while (0) +static inline gboolean +mono_handle_array_has_bounds (MonoArrayHandle arr) +{ + return MONO_HANDLE_GETVAL (arr, bounds) != NULL; +} + +static inline void +mono_handle_array_get_bounds_dim (MonoArrayHandle arr, gint32 dim, MonoArrayBounds *bounds) +{ + MonoArrayBounds *src = MONO_HANDLE_GETVAL (arr, bounds); + memcpy (bounds, &src[dim], sizeof (MonoArrayBounds)); +} + typedef struct { MonoObject obj; @@ -171,6 +188,9 @@ struct _MonoAppDomain { /* Safely access System.AppDomain from native code */ TYPED_HANDLE_DECL (MonoAppDomain); +/* Safely access System.AppDomainSetup from native code. (struct is in domain-internals.h) */ +TYPED_HANDLE_DECL (MonoAppDomainSetup); + typedef struct _MonoStringBuilder MonoStringBuilder; struct _MonoStringBuilder { @@ -259,6 +279,10 @@ typedef enum { CallType_OneWay = 3 } MonoCallType; +/* MonoSafeHandle is in class-internals.h. */ +/* Safely access System.Net.Sockets.SafeSocketHandle from native code */ +TYPED_HANDLE_DECL (MonoSafeHandle); + /* This corresponds to System.Type */ struct _MonoReflectionType { MonoObject object; @@ -286,6 +310,9 @@ typedef struct { MonoObject *stub_data; } MonoRealProxy; +/* Safely access System.Runtime.Remoting.Proxies.RealProxy from native code */ +TYPED_HANDLE_DECL (MonoRealProxy); + typedef struct { MonoMarshalByRefObject object; gpointer iunknown; @@ -306,6 +333,9 @@ typedef struct { MonoBoolean custom_type_info; } MonoTransparentProxy; +/* Safely access System.Runtime.Remoting.Proxies.TransparentProxy from native code */ +TYPED_HANDLE_DECL (MonoTransparentProxy); + typedef struct { MonoObject obj; MonoReflectionMethod *method; @@ -346,6 +376,7 @@ typedef struct { typedef enum { MONO_THREAD_FLAG_DONT_MANAGE = 1, // Don't wait for or abort this thread MONO_THREAD_FLAG_NAME_SET = 2, // Thread name set from managed code + MONO_THREAD_FLAG_APPDOMAIN_ABORT = 4, // Current requested abort originates from appdomain unload } MonoThreadFlags; struct _MonoInternalThread { @@ -353,14 +384,14 @@ struct _MonoInternalThread { volatile int lock_thread_id; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */ MonoThreadHandle *handle; gpointer native_handle; - MonoArray *cached_culture_info; + gpointer unused3; gunichar2 *name; guint32 name_len; guint32 state; MonoException *abort_exc; int abort_state_handle; guint64 tid; /* This is accessed as a gsize in the code (so it can hold a 64bit pointer on systems that need it), but needs to reserve 64 bits of space on all machines as it corresponds to a field in managed code */ - gpointer stack_ptr; + gsize debugger_thread; // FIXME switch to bool as soon as CI testing with corlib version bump works gpointer *static_data; void *thread_info; /*This is MonoThreadInfo*, but to simplify dependencies, let's make it a void* here. */ MonoAppContext *current_appcontext; @@ -369,7 +400,7 @@ struct _MonoInternalThread { int _serialized_principal_version; gpointer appdomain_refs; /* This is modified using atomic ops, so keep it a gint32 */ - gint32 interruption_requested; + gint32 __interruption_requested; MonoCoopMutex *synch_cs; MonoBoolean threadpool_thread; MonoBoolean thread_interrupt_requested; @@ -379,21 +410,22 @@ struct _MonoInternalThread { gint32 managed_id; guint32 small_id; MonoThreadManageCallback manage_callback; - gpointer interrupt_on_stop; + gpointer unused4; gsize flags; gpointer thread_pinning_ref; - gsize abort_protected_block_count; + gsize __abort_protected_block_count; gint32 priority; GPtrArray *owned_mutexes; MonoOSEvent *suspended; gint32 self_suspended; // TRUE | FALSE + + gsize thread_state; /* * These fields are used to avoid having to increment corlib versions * when a new field is added to this structure. * Please synchronize any changes with InternalThread in Thread.cs, i.e. add the * same field there. */ - gsize unused1; gsize unused2; /* This is used only to check that we are in sync between the representation @@ -403,6 +435,12 @@ struct _MonoInternalThread { gpointer last; }; +/* It's safe to access System.Threading.InternalThread from native code via a + * raw pointer because all instances should be pinned. But for uniformity of + * icall wrapping, let's declare a MonoInternalThreadHandle anyway. + */ +TYPED_HANDLE_DECL (MonoInternalThread); + struct _MonoThread { MonoObject obj; struct _MonoInternalThread *internal_thread; @@ -582,7 +620,6 @@ typedef struct { void (*set_cast_details) (MonoClass *from, MonoClass *to); void (*debug_log) (int level, MonoString *category, MonoString *message); gboolean (*debug_log_is_enabled) (void); - gboolean (*tls_key_supported) (MonoTlsKey key); void (*init_delegate) (MonoDelegate *del); MonoObject* (*runtime_invoke) (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error); void* (*compile_method) (MonoMethod *method, MonoError *error); @@ -607,6 +644,7 @@ typedef struct { gboolean (*mono_current_thread_has_handle_block_guard) (void); gboolean (*mono_above_abort_threshold) (void); void (*mono_clear_abort_threshold) (void); + void (*mono_reraise_exception) (MonoException *ex); } MonoRuntimeExceptionHandlingCallbacks; MONO_COLD void mono_set_pending_exception (MonoException *exc); @@ -642,13 +680,10 @@ void mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args, MonoError *error); gboolean -mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method, MonoError *error); +mono_delegate_ctor_with_method (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoMethod *method, MonoError *error); gboolean -mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoError *error); - -void* -mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words); +mono_delegate_ctor (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error); void mono_runtime_free_method (MonoDomain *domain, MonoMethod *method); @@ -702,6 +737,8 @@ mono_domain_get_tls_offset (void); #define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL)) +#define IS_MONOTYPE_HANDLE(obj) IS_MONOTYPE (MONO_HANDLE_RAW (obj)) + /* This should be used for accessing members of Type[] arrays */ #define mono_type_array_get(arr,index) monotype_cast (mono_array_get ((arr), gpointer, (index))) @@ -731,11 +768,6 @@ struct _MonoReflectionMethod { /* Safely access System.Reflection.MonoMethod from native code */ TYPED_HANDLE_DECL (MonoReflectionMethod); -typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod; -struct _MonoReflectionGenericMethod { - MonoReflectionMethod method; -}; - struct _MonoDelegate { MonoObject object; /* The compiled code of the target method */ @@ -758,12 +790,18 @@ struct _MonoDelegate { MonoBoolean method_is_virtual; }; +/* Safely access System.Delegate from native code */ +TYPED_HANDLE_DECL (MonoDelegate); + typedef struct _MonoMulticastDelegate MonoMulticastDelegate; struct _MonoMulticastDelegate { MonoDelegate delegate; MonoArray *delegates; }; +/* Safely access System.MulticastDelegate from native code */ +TYPED_HANDLE_DECL (MonoMulticastDelegate); + struct _MonoReflectionField { MonoObject object; MonoClass *klass; @@ -773,24 +811,36 @@ struct _MonoReflectionField { guint32 attrs; }; +/* Safely access System.Reflection.MonoField from native code */ +TYPED_HANDLE_DECL (MonoReflectionField); + struct _MonoReflectionProperty { MonoObject object; MonoClass *klass; MonoProperty *property; }; +/* Safely access System.Reflection.MonoProperty from native code */ +TYPED_HANDLE_DECL (MonoReflectionProperty); + /*This is System.EventInfo*/ struct _MonoReflectionEvent { MonoObject object; MonoObject *cached_add_event; }; +/* Safely access System.Reflection.EventInfo from native code */ +TYPED_HANDLE_DECL (MonoReflectionEvent); + typedef struct { MonoReflectionEvent object; MonoClass *klass; MonoEvent *event; } MonoReflectionMonoEvent; +/* Safely access Systme.Reflection.MonoEvent from native code */ +TYPED_HANDLE_DECL (MonoReflectionMonoEvent); + typedef struct { MonoObject object; MonoReflectionType *ClassImpl; @@ -802,6 +852,9 @@ typedef struct { MonoObject *MarshalAsImpl; } MonoReflectionParameter; +/* Safely access System.Reflection.ParameterInfo from native code */ +TYPED_HANDLE_DECL (MonoReflectionParameter); + struct _MonoReflectionMethodBody { MonoObject object; MonoArray *clauses; @@ -812,6 +865,9 @@ struct _MonoReflectionMethodBody { guint32 max_stack; }; +/* Safely access System.Reflection.MethodBody from native code */ +TYPED_HANDLE_DECL (MonoReflectionMethodBody); + struct _MonoReflectionAssembly { MonoObject object; MonoAssembly *assembly; @@ -918,6 +974,10 @@ typedef struct { gint32 handler_length; } MonoReflectionExceptionHandlingClause; + +/* Safely access System.Reflection.ExceptionHandlingClause from native code */ +TYPED_HANDLE_DECL (MonoReflectionExceptionHandlingClause); + typedef struct { MonoObject object; MonoReflectionType *local_type; @@ -925,6 +985,9 @@ typedef struct { guint16 local_index; } MonoReflectionLocalVariableInfo; +/* Safely access System.Reflection.LocalVariableInfo from native code */ +TYPED_HANDLE_DECL (MonoReflectionLocalVariableInfo); + typedef struct { /* * Must have the same layout as MonoReflectionLocalVariableInfo, since @@ -980,6 +1043,9 @@ typedef struct { MonoArray *permissions; } MonoReflectionCtorBuilder; +/* Safely access System.Reflection.Emit.ConstructorBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionCtorBuilder); + typedef struct { MonoObject object; MonoMethod *mhandle; @@ -1011,6 +1077,9 @@ typedef struct { MonoArray *permissions; } MonoReflectionMethodBuilder; +/* Safely access System.Reflection.Emit.MethodBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionMethodBuilder); + typedef struct { MonoObject object; MonoMethod *mhandle; @@ -1022,6 +1091,9 @@ typedef struct { guint32 call_conv; } MonoReflectionArrayMethod; +/* Safely access System.Reflection.Emit.MonoArrayMethod from native code */ +TYPED_HANDLE_DECL (MonoReflectionArrayMethod); + typedef struct { MonoArray *data; MonoString *name; @@ -1093,6 +1165,9 @@ typedef struct { MonoArray *modopt; } MonoReflectionFieldBuilder; +/* Safely access System.Reflection.Emit.FieldBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionFieldBuilder); + typedef struct { MonoObject object; guint32 attrs; @@ -1139,11 +1214,18 @@ typedef struct { MonoArray *global_fields; gboolean is_main; MonoArray *resources; + GHashTable *unparented_classes; } MonoReflectionModuleBuilder; /* Safely acess System.Reflection.Emit.ModuleBuidler from native code */ TYPED_HANDLE_DECL (MonoReflectionModuleBuilder); +typedef enum { + MonoTypeBuilderNew = 0, + MonoTypeBuilderEntered = 1, + MonoTypeBuilderFinished = 2 +} MonoTypeBuilderState; + typedef struct { MonoReflectionType type; MonoString *name; @@ -1169,19 +1251,29 @@ typedef struct { MonoArray *generic_params; MonoArray *permissions; MonoReflectionType *created; + gint32 state; } MonoReflectionTypeBuilder; +/* Safely access System.Reflection.Emit.TypeBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionTypeBuilder); + typedef struct { MonoReflectionType type; MonoReflectionType *element_type; - int rank; + gint32 rank; } MonoReflectionArrayType; +/* Safely access System.Reflection.Emit.ArrayType (in DerivedTypes.cs) from native code */ +TYPED_HANDLE_DECL (MonoReflectionArrayType); + typedef struct { MonoReflectionType type; MonoReflectionType *element_type; } MonoReflectionDerivedType; +/* Safely access System.Reflection.Emit.SymbolType and subclasses (in DerivedTypes.cs) from native code */ +TYPED_HANDLE_DECL (MonoReflectionDerivedType); + typedef struct { MonoReflectionType type; MonoReflectionTypeBuilder *tbuilder; @@ -1194,11 +1286,17 @@ typedef struct { guint32 attrs; } MonoReflectionGenericParam; +/* Safely access System.Reflection.Emit.GenericTypeParameterBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionGenericParam); + typedef struct { MonoReflectionType type; MonoReflectionTypeBuilder *tb; } MonoReflectionEnumBuilder; +/* Safely access System.Reflection.Emit.EnumBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionEnumBuilder); + typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass; struct _MonoReflectionGenericClass { MonoReflectionType type; @@ -1206,6 +1304,9 @@ struct _MonoReflectionGenericClass { MonoArray *type_arguments; }; +/* Safely access System.Reflection.Emit.TypeBuilderInstantiation from native code */ +TYPED_HANDLE_DECL (MonoReflectionGenericClass); + typedef struct { MonoObject obj; MonoString *name; @@ -1259,6 +1360,9 @@ typedef struct { gint16 size_param_index; } MonoReflectionMarshalAsAttribute; +/* Safely access System.Runtime.InteropServices.MarshalAsAttribute */ +TYPED_HANDLE_DECL (MonoReflectionMarshalAsAttribute); + typedef struct { MonoObject object; gint32 call_conv; @@ -1291,6 +1395,9 @@ typedef struct { MonoReflectionType *owner; } MonoReflectionDynamicMethod; +/* Safely access System.Reflection.Emit.DynamicMethod from native code */ +TYPED_HANDLE_DECL (MonoReflectionDynamicMethod); + typedef struct { MonoObject object; MonoReflectionModuleBuilder *module; @@ -1303,6 +1410,9 @@ typedef struct { MonoArray *modopts; } MonoReflectionSigHelper; +/* Safely access System.Reflection.Emit.SignatureHelper from native code */ +TYPED_HANDLE_DECL (MonoReflectionSigHelper); + typedef struct { MonoObject object; MonoBoolean visible; @@ -1350,11 +1460,18 @@ typedef struct { MonoProperty *prop; } CattrNamedArg; +/* All MonoInternalThread instances should be pinned, so it's safe to use the raw ptr. However + * for uniformity, icall wrapping will make handles anyway. So this is the method for getting the payload. + */ +static inline MonoInternalThread* +mono_internal_thread_handle_ptr (MonoInternalThreadHandle h) +{ + return MONO_HANDLE_RAW (h); /* Safe */ +} + gboolean mono_image_create_pefile (MonoReflectionModuleBuilder *module, gpointer file, MonoError *error); -guint32 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str); -guint32 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec, gboolean register_token, MonoError *error); -guint32 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types, MonoError *error); -void mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj); +guint32 mono_image_insert_string (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error); +guint32 mono_image_create_token (MonoDynamicImage *assembly, MonoObjectHandle obj, gboolean create_methodspec, gboolean register_token, MonoError *error); void mono_dynamic_image_free (MonoDynamicImage *image); void mono_dynamic_image_free_image (MonoDynamicImage *image); void mono_dynamic_image_release_gc_roots (MonoDynamicImage *image); @@ -1373,25 +1490,26 @@ void mono_reflection_register_with_runtime (MonoReflectionType *type); void mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args, MonoArray **named_args, CattrNamedArg **named_arg_info, MonoError *error); MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error); -MonoArray* mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error); +MonoArrayHandle mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error); MonoClass* mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic); MonoType* -mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types, MonoError *error); +mono_reflection_bind_generic_parameters (MonoReflectionTypeHandle type, int type_argc, MonoType **types, MonoError *error); void mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields); MonoReflectionEvent * ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb); -MonoArray * -ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper *sig); +MonoArrayHandle +ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelperHandle sig, MonoError *error); -MonoArray * -ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig); +MonoArrayHandle +ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelperHandle sig, MonoError *error); -MonoReflectionMarshalAsAttribute* mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error); +MonoReflectionMarshalAsAttributeHandle +mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error); gpointer mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error); @@ -1402,9 +1520,6 @@ mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, Mono void ves_icall_System_Reflection_CustomAttributeData_ResolveArgumentsInternal (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args); -MonoType* -mono_reflection_type_get_handle (MonoReflectionType *ref, MonoError *error); - gboolean mono_image_build_metadata (MonoReflectionModuleBuilder *module, MonoError *error); @@ -1414,6 +1529,9 @@ mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const void mono_release_type_locks (MonoInternalThread *thread); +int +mono_string_handle_length (MonoStringHandle s); + char * mono_string_handle_to_utf8 (MonoStringHandle s, MonoError *error); @@ -1421,11 +1539,11 @@ char * mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error); char * -mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error); +mono_string_to_utf8_image (MonoImage *image, MonoStringHandle s, MonoError *error); -MonoArray* -mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array, MonoError *error); +MonoArrayHandle +mono_array_clone_in_domain (MonoDomain *domain, MonoArrayHandle array, MonoError *error); MonoArray* mono_array_clone_checked (MonoArray *array, MonoError *error); @@ -1452,14 +1570,20 @@ MonoArray* ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n); #ifndef DISABLE_REMOTING +MonoRemoteClass* +mono_remote_class (MonoDomain *domain, MonoStringHandle class_name, MonoClass *proxy_class, MonoError *error); + +gboolean +mono_remote_class_is_interface_proxy (MonoRemoteClass *remote_class); + MonoObject * mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, MonoObject **exc, MonoArray **out_args, MonoError *error); gpointer -mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy, MonoError *error); +mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxyHandle real_proxy, MonoError *error); gboolean -mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass, MonoError *error); +mono_upgrade_remote_class (MonoDomain *domain, MonoObjectHandle tproxy, MonoClass *klass, MonoError *error); void* mono_load_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res, MonoError *error); @@ -1485,6 +1609,9 @@ mono_get_addr_from_ftnptr (gpointer descr); void mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass); +void +mono_nullable_init_from_handle (guint8 *buf, MonoObjectHandle value, MonoClass *klass); + MonoObject * mono_value_box_checked (MonoDomain *domain, MonoClass *klass, void* val, MonoError *error); @@ -1558,6 +1685,9 @@ mono_runtime_unhandled_exception_policy_get (void); void mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy); +void +mono_unhandled_exception_checked (MonoObjectHandle exc, MonoError *error); + MonoVTable * mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass); @@ -1582,11 +1712,17 @@ mono_class_is_reflection_method_or_constructor (MonoClass *klass); MonoObject * mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob, MonoError *error); -gpointer +MonoObjectHandle mono_class_get_ref_info (MonoClass *klass); +gboolean +mono_class_has_ref_info (MonoClass *klass); + +MonoObject* +mono_class_get_ref_info_raw (MonoClass *klass); + void -mono_class_set_ref_info (MonoClass *klass, gpointer obj); +mono_class_set_ref_info (MonoClass *klass, MonoObjectHandle obj); void mono_class_free_ref_info (MonoClass *klass); @@ -1612,6 +1748,9 @@ mono_field_static_get_value_checked (MonoVTable *vt, MonoClassField *field, void void mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value, MonoError *error); +MonoMethod* +mono_object_handle_get_virtual_method (MonoObjectHandle obj, MonoMethod *method, MonoError *error); + /* exported, used by the debugger */ MONO_API void * mono_vtable_get_static_field_data (MonoVTable *vt); @@ -1676,17 +1815,17 @@ mono_object_new_mature (MonoVTable *vtable, MonoError *error); MonoObject* mono_object_new_fast_checked (MonoVTable *vtable, MonoError *error); -MonoObject * -ves_icall_object_new_fast (MonoVTable *vtable); - MonoObject * mono_object_clone_checked (MonoObject *obj, MonoError *error); MonoObject * mono_object_isinst_checked (MonoObject *obj, MonoClass *klass, MonoError *error); -MonoObject * -mono_object_isinst_mbyref_checked (MonoObject *obj, MonoClass *klass, MonoError *error); +MonoObjectHandle +mono_object_handle_isinst (MonoObjectHandle obj, MonoClass *klass, MonoError *error); + +MonoObjectHandle +mono_object_handle_isinst_mbyref (MonoObjectHandle obj, MonoClass *klass, MonoError *error); MonoString * mono_string_new_size_checked (MonoDomain *domain, gint32 len, MonoError *error); @@ -1703,6 +1842,9 @@ mono_string_new_checked (MonoDomain *domain, const char *text, MonoError *merror MonoString * mono_string_new_utf16_checked (MonoDomain *domain, const guint16 *text, gint32 len, MonoError *error); +MonoStringHandle +mono_string_new_utf16_handle (MonoDomain *domain, const guint16 *text, gint32 len, MonoError *error); + MonoString * mono_string_from_utf16_checked (mono_unichar2 *data, MonoError *error); @@ -1757,16 +1899,17 @@ mono_runtime_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError * int mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc); -MonoReflectionMethod* -ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethod *rmethod, MonoArray *types); +MonoReflectionMethodHandle +ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethodHandle rmethod, MonoArrayHandle types, MonoError *error); gint32 -ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance); +ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, gboolean create_open_instance, MonoError *error); gint32 -ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb, - MonoReflectionMethod *method, - MonoArray *opt_param_types); +ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilderHandle mb, + MonoReflectionMethodHandle method, + MonoArrayHandle opt_param_types, + MonoError *error); void ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, gpointer file); @@ -1775,38 +1918,39 @@ void ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb); void -ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token); +ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, guint32 token, MonoError *error); -MonoObject* -ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilder *mb, guint32 token); +MonoObjectHandle +ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilderHandle mb, guint32 token, MonoError *error); void ves_icall_AssemblyBuilder_basic_init (MonoReflectionAssemblyBuilder *assemblyb); -MonoReflectionModule* -ves_icall_AssemblyBuilder_InternalAddModule (MonoReflectionAssemblyBuilder *ab, MonoString *fileName); +void +ves_icall_AssemblyBuilder_UpdateNativeCustomAttributes (MonoReflectionAssemblyBuilderHandle assemblyb, MonoError *error); MonoArray* ves_icall_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues); void -ves_icall_DynamicMethod_create_dynamic_method (MonoReflectionDynamicMethod *mb); +ves_icall_DynamicMethod_create_dynamic_method (MonoReflectionDynamicMethodHandle mb, MonoError *error); -MonoReflectionType* -ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilder *tb); +MonoReflectionTypeHandle +ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilderHandle tb, MonoError *error); void -ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype, - MonoReflectionType *t); +ves_icall_EnumBuilder_setup_enum_type (MonoReflectionTypeHandle enumtype, + MonoReflectionTypeHandle t, + MonoError *error); void -ves_icall_ModuleBuilder_basic_init (MonoReflectionModuleBuilder *moduleb); +ves_icall_ModuleBuilder_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error); guint32 -ves_icall_ModuleBuilder_getUSIndex (MonoReflectionModuleBuilder *module, MonoString *str); +ves_icall_ModuleBuilder_getUSIndex (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error); void -ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflectionType *type); +ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilderHandle moduleb, MonoReflectionTypeHandle type, MonoError *error); MonoAssembly* mono_try_assembly_resolve_handle (MonoDomain *domain, MonoStringHandle fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);