+/**
+ * \file
+ */
+
#ifndef __MONO_OBJECT_INTERNALS_H__
#define __MONO_OBJECT_INTERNALS_H__
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;
/* 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 {
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;
MonoObject *stub_data;
} MonoRealProxy;
+/* Safely access System.Runtime.Remoting.Proxies.RealProxy from native code */
+TYPED_HANDLE_DECL (MonoRealProxy);
+
typedef struct {
MonoMarshalByRefObject object;
gpointer iunknown;
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;
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 {
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;
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;
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
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;
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);
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);
#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)))
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;
MonoArray *permissions;
} MonoReflectionCtorBuilder;
+/* Safely access System.Reflection.Emit.ConstructorBuilder from native code */
+TYPED_HANDLE_DECL (MonoReflectionCtorBuilder);
+
typedef struct {
MonoObject object;
MonoMethod *mhandle;
MonoArray *permissions;
} MonoReflectionMethodBuilder;
+/* Safely access System.Reflection.Emit.MethodBuilder from native code */
+TYPED_HANDLE_DECL (MonoReflectionMethodBuilder);
+
typedef struct {
MonoObject object;
MonoMethod *mhandle;
guint32 call_conv;
} MonoReflectionArrayMethod;
+/* Safely access System.Reflection.Emit.MonoArrayMethod from native code */
+TYPED_HANDLE_DECL (MonoReflectionArrayMethod);
+
typedef struct {
MonoArray *data;
MonoString *name;
MonoArray *modopt;
} MonoReflectionFieldBuilder;
+/* Safely access System.Reflection.Emit.FieldBuilder from native code */
+TYPED_HANDLE_DECL (MonoReflectionFieldBuilder);
+
typedef struct {
MonoObject object;
guint32 attrs;
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;
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;
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;
MonoArray *type_arguments;
};
+/* Safely access System.Reflection.Emit.TypeBuilderInstantiation from native code */
+TYPED_HANDLE_DECL (MonoReflectionGenericClass);
+
typedef struct {
MonoObject obj;
MonoString *name;
MonoReflectionType *owner;
} MonoReflectionDynamicMethod;
+/* Safely access System.Reflection.Emit.DynamicMethod from native code */
+TYPED_HANDLE_DECL (MonoReflectionDynamicMethod);
+
typedef struct {
MonoObject object;
MonoReflectionModuleBuilder *module;
MonoArray *modopts;
} MonoReflectionSigHelper;
+/* Safely access System.Reflection.Emit.SignatureHelper from native code */
+TYPED_HANDLE_DECL (MonoReflectionSigHelper);
+
typedef struct {
MonoObject object;
MonoBoolean visible;
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);
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);
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);
void
mono_release_type_locks (MonoInternalThread *thread);
+int
+mono_string_handle_length (MonoStringHandle s);
+
char *
mono_string_handle_to_utf8 (MonoStringHandle s, MonoError *error);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
projects / mono.git / blobdiff