X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fobject-internals.h;h=26b11d77371cea4845516ba3b19805a7f4390335;hb=24e97e5c52d88408b1e323fe0b2d3a4b99f35302;hp=9ad68f46a1540eaefe5a6c19bb438c1f7196a846;hpb=a1cabeee67e60ce0a2399edfae7a3def696e7272;p=mono.git diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index 9ad68f46a15..26b11d77371 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -160,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; @@ -266,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; @@ -359,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 { @@ -417,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; @@ -620,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); @@ -655,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); @@ -768,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; @@ -1432,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); @@ -1465,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); @@ -1536,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); @@ -1569,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); @@ -1772,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); @@ -1880,14 +1920,14 @@ 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); -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); @@ -1899,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); @@ -1909,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);