X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fobject-internals.h;h=3b4db614bba06297be0e6e70e2a96e35f4e9a21a;hb=ed1884bb9b43ddd69daba52302494ad2d02bbbd9;hp=2d175ae3a0636efddf89afb88330c2c4587c1c0a;hpb=843d3c063309076fde7d39259d31efbd848edce2;p=mono.git diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index 2d175ae3a06..3b4db614bba 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; @@ -385,7 +410,7 @@ 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; @@ -410,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; @@ -613,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); @@ -648,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); @@ -761,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; @@ -1179,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; @@ -1209,6 +1251,7 @@ typedef struct { MonoArray *generic_params; MonoArray *permissions; MonoReflectionType *created; + gint32 state; } MonoReflectionTypeBuilder; /* Safely access System.Reflection.Emit.TypeBuilder from native code */ @@ -1417,6 +1460,15 @@ 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 (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error); guint32 mono_image_create_token (MonoDynamicImage *assembly, MonoObjectHandle obj, gboolean create_methodspec, gboolean register_token, MonoError *error); @@ -1450,11 +1502,11 @@ mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, Mono 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); @@ -1468,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); @@ -1480,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); @@ -1490,8 +1542,8 @@ char * 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); @@ -1521,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); @@ -1554,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); @@ -1627,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); @@ -1754,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); @@ -1784,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); @@ -1838,8 +1899,8 @@ 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 (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, gboolean create_open_instance, MonoError *error); @@ -1859,8 +1920,8 @@ ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb); void 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); @@ -1878,8 +1939,9 @@ 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 (MonoReflectionModuleBuilderHandle moduleb, MonoError *error); @@ -1888,7 +1950,7 @@ guint32 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);