X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fobject-internals.h;h=26b11d77371cea4845516ba3b19805a7f4390335;hb=24e97e5c52d88408b1e323fe0b2d3a4b99f35302;hp=f45b54fd86180ce5afe32ab68998ea99888fbb7d;hpb=1003c4b19fddac13924c496ebe7ed0356dd63908;p=mono.git diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index f45b54fd861..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; @@ -352,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 { @@ -359,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; @@ -375,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; @@ -385,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 @@ -409,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; @@ -612,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); @@ -647,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); @@ -760,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; @@ -1055,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; @@ -1175,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; @@ -1205,6 +1251,7 @@ typedef struct { MonoArray *generic_params; MonoArray *permissions; MonoReflectionType *created; + gint32 state; } MonoReflectionTypeBuilder; /* Safely access System.Reflection.Emit.TypeBuilder from native code */ @@ -1213,14 +1260,20 @@ 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; @@ -1233,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; @@ -1245,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; @@ -1333,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; @@ -1345,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; @@ -1392,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); @@ -1420,18 +1495,18 @@ MonoArrayHandle mono_param_get_objects_internal (MonoDomain *domain, MonoMethod 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); MonoReflectionMarshalAsAttributeHandle mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec, MonoError *error); @@ -1445,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); @@ -1457,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); @@ -1464,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); @@ -1498,6 +1573,9 @@ ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n); 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); @@ -1531,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); @@ -1604,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); @@ -1628,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); @@ -1725,9 +1815,6 @@ 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); @@ -1755,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); @@ -1809,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); @@ -1827,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);