#include <mono/metadata/mempool.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/threads-types.h>
-#include <mono/io-layer/io-layer.h>
+#include <mono/metadata/handle.h>
#include "mono/utils/mono-compiler.h"
#include "mono/utils/mono-error.h"
#include "mono/utils/mono-error-internals.h"
MonoDomain *data;
};
+/* Safely access System.AppDomain from native code */
+TYPED_HANDLE_DECL (MonoAppDomain);
+
typedef struct _MonoStringBuilder MonoStringBuilder;
struct _MonoStringBuilder {
MonoType *type;
};
+/* Safely access System.Type from native code */
+TYPED_HANDLE_DECL (MonoReflectionType);
+
/* This corresponds to System.RuntimeType */
typedef struct {
MonoReflectionType type;
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;
struct _MonoInternalThread {
MonoObject obj;
volatile int lock_thread_id; /* to be used as the pre-shifted thread id in thin locks. Used for appdomain_ref push/pop */
- HANDLE handle;
+ MonoThreadHandle *handle;
+ gpointer native_handle;
MonoArray *cached_culture_info;
gunichar2 *name;
guint32 name_len;
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 */
- HANDLE start_notify;
gpointer stack_ptr;
gpointer *static_data;
void *thread_info; /*This is MonoThreadInfo*, but to simplify dependencies, let's make it a void* here. */
gpointer interrupt_on_stop;
gsize flags;
gpointer thread_pinning_ref;
+ gsize abort_protected_block_count;
+ gint32 priority;
+ GPtrArray *owned_mutexes;
+ MonoOSEvent *suspended;
+ gint32 self_suspended; // TRUE | FALSE
/*
* 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.
*/
- gpointer unused1;
- gpointer unused2;
+ gsize unused1;
+ gsize unused2;
+
+ /* This is used only to check that we are in sync between the representation
+ * of MonoInternalThread in native and InternalThread in managed
+ *
+ * DO NOT RENAME! DO NOT ADD FIELDS AFTER! */
+ gpointer last;
};
struct _MonoThread {
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);
gpointer (*create_jump_trampoline) (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error);
gpointer (*create_jit_trampoline) (MonoDomain *domain, MonoMethod *method, MonoError *error);
+ /* used to free a dynamic method */
+ void (*free_method) (MonoDomain *domain, MonoMethod *method);
+ gpointer (*create_remoting_trampoline) (MonoDomain *domain, MonoMethod *method, MonoRemotingTarget target, MonoError *error);
+ gpointer (*create_delegate_trampoline) (MonoDomain *domain, MonoClass *klass);
} MonoRuntimeCallbacks;
typedef gboolean (*MonoInternalStackWalk) (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data);
void (*mono_raise_exception_with_ctx) (MonoException *ex, MonoContext *ctx);
gboolean (*mono_exception_walk_trace) (MonoException *ex, MonoInternalExceptionFrameWalk func, gpointer user_data);
gboolean (*mono_install_handler_block_guard) (MonoThreadUnwindState *unwind_state);
+ gboolean (*mono_current_thread_has_handle_block_guard) (void);
+ gboolean (*mono_above_abort_threshold) (void);
+ void (*mono_clear_abort_threshold) (void);
} MonoRuntimeExceptionHandlingCallbacks;
-/* used to free a dynamic method */
-typedef void (*MonoFreeMethodFunc) (MonoDomain *domain, MonoMethod *method);
-
MONO_COLD void mono_set_pending_exception (MonoException *exc);
/* remoting and async support */
MonoAsyncResult *
-mono_async_result_new (MonoDomain *domain, HANDLE handle,
+mono_async_result_new (MonoDomain *domain, gpointer handle,
MonoObject *state, gpointer data, MonoObject *object_data, MonoError *error);
MonoObject *
ves_icall_System_Runtime_Remoting_Messaging_AsyncResult_Invoke (MonoAsyncResult *ares);
MonoWaitHandle *
-mono_wait_handle_new (MonoDomain *domain, HANDLE handle, MonoError *error);
+mono_wait_handle_new (MonoDomain *domain, gpointer handle, MonoError *error);
-HANDLE
+gpointer
mono_wait_handle_get_handle (MonoWaitHandle *handle);
gboolean
void
mono_runtime_free_method (MonoDomain *domain, MonoMethod *method);
-void
-mono_install_free_method (MonoFreeMethodFunc func);
-
void
mono_install_callbacks (MonoRuntimeCallbacks *cbs);
#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)))
MonoReflectionType *reftype;
};
-typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod;
-struct _MonoReflectionGenericMethod {
- MonoReflectionMethod method;
-};
+/* Safely access System.Reflection.MonoMethod from native code */
+TYPED_HANDLE_DECL (MonoReflectionMethod);
struct _MonoDelegate {
MonoObject object;
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;
MonoObject *MarshalAsImpl;
} MonoReflectionParameter;
+/* Safely access System.Reflection.ParameterInfo from native code */
+TYPED_HANDLE_DECL (MonoReflectionParameter);
+
struct _MonoReflectionMethodBody {
MonoObject object;
MonoArray *clauses;
guint32 max_stack;
};
+/* Safely access System.Reflection.MethodBody from native code */
+TYPED_HANDLE_DECL (MonoReflectionMethodBody);
+
struct _MonoReflectionAssembly {
MonoObject object;
MonoAssembly *assembly;
MonoString *name;
};
+/* Safely access System.Reflection.Assembly from native code */
+TYPED_HANDLE_DECL (MonoReflectionAssembly);
+
typedef struct {
MonoReflectionType *utype;
MonoArray *values;
gint32 handler_length;
} MonoReflectionExceptionHandlingClause;
+
+/* Safely access System.Reflection.ExceptionHandlingClause from native code */
+TYPED_HANDLE_DECL (MonoReflectionExceptionHandlingClause);
+
typedef struct {
MonoObject object;
MonoReflectionType *local_type;
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
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 *pktoken; /* as hexadecimal byte[] */
} MonoReflectionAssemblyBuilder;
+/* Safely access System.Reflection.Emit.AssemblyBuilder from native code */
+TYPED_HANDLE_DECL (MonoReflectionAssemblyBuilder);
+
typedef struct {
MonoObject object;
guint32 attrs;
MonoArray *modopt;
} MonoReflectionFieldBuilder;
+/* Safely access System.Reflection.Emit.FieldBuilder from native code */
+TYPED_HANDLE_DECL (MonoReflectionFieldBuilder);
+
typedef struct {
MonoObject object;
guint32 attrs;
guint32 token;
};
+/* Safely access System.Reflection.Module from native code */
+TYPED_HANDLE_DECL (MonoReflectionModule);
+
typedef struct {
MonoReflectionModule module;
MonoDynamicImage *dynamic_image;
MonoArray *resources;
} MonoReflectionModuleBuilder;
+/* Safely acess System.Reflection.Emit.ModuleBuidler from native code */
+TYPED_HANDLE_DECL (MonoReflectionModuleBuilder);
+
typedef struct {
MonoReflectionType type;
MonoString *name;
MonoReflectionType *created;
} 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;
MonoReflectionType *generic_type; /*Can be either a MonoType or a TypeBuilder*/
MonoArray *type_arguments;
- guint32 initialized;
};
+/* Safely access System.Reflection.Emit.TypeBuilderInstantiation from native code */
+TYPED_HANDLE_DECL (MonoReflectionGenericClass);
+
typedef struct {
MonoObject obj;
MonoString *name;
guint32 processor_architecture;
} MonoReflectionAssemblyName;
+/* Safely access System.Reflection.AssemblyName from native code */
+TYPED_HANDLE_DECL (MonoReflectionAssemblyName);
+
typedef struct {
MonoObject obj;
MonoString *name;
gint16 size_param_index;
} MonoReflectionMarshalAsAttribute;
+/* Safely access System.Runtime.InteropServices.MarshalAsAttribute */
+TYPED_HANDLE_DECL (MonoReflectionMarshalAsAttribute);
+
typedef struct {
MonoObject object;
gint32 call_conv;
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;
-typedef struct {
- MonoObject object;
- MonoReflectionGenericClass *inst;
- MonoObject *fb; /*can be either a MonoField or a FieldBuilder*/
-} MonoReflectionFieldOnTypeBuilderInst;
-
-typedef struct {
- MonoObject object;
- MonoReflectionGenericClass *inst;
- MonoObject *cb; /*can be either a MonoCMethod or ConstructorBuilder*/
-} MonoReflectionCtorOnTypeBuilderInst;
-
-typedef struct {
- MonoObject object;
- MonoReflectionType *inst;
- MonoObject *mb; /*can be either a MonoMethod or MethodBuilder*/
- MonoArray *method_args;
- MonoReflectionMethodBuilder *generic_method_definition;
-} MonoReflectionMethodOnTypeBuilderInst;
+/* Safely access System.Reflection.Emit.SignatureHelper from native code */
+TYPED_HANDLE_DECL (MonoReflectionSigHelper);
typedef struct {
MonoObject object;
guint32 location;
} MonoManifestResourceInfo;
+/* Safely access System.Reflection.ManifestResourceInfo from native code */
+TYPED_HANDLE_DECL (MonoManifestResourceInfo);
+
/* A boxed IntPtr */
typedef struct {
MonoObject object;
MonoProperty *prop;
} CattrNamedArg;
-gboolean mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file, MonoError *error);
-void mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
-MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name, 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_module_basic_init (MonoReflectionModuleBuilder *module);
-void mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj);
+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);
void mono_dynamic_image_free (MonoDynamicImage *image);
void mono_dynamic_image_free_image (MonoDynamicImage *image);
-void mono_image_set_wrappers_type (MonoReflectionModuleBuilder *mb, MonoReflectionType *type);
void mono_dynamic_image_release_gc_roots (MonoDynamicImage *image);
void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb);
-void mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
-
-void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb);
-
-gboolean mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb, MonoError *error);
-
-MonoReflectionType* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb);
-
void mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error);
-void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb);
-void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
-void mono_reflection_create_unmanaged_type (MonoReflectionType *type);
+void
+ves_icall_SymbolType_create_unmanaged_type (MonoReflectionType *type);
+
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);
-MonoReflectionMethod*
-mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
+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 *
-mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
+ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
-MonoArray *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
+MonoArray *
+ves_icall_SignatureHelper_get_signature_local (MonoReflectionSigHelper *sig);
-MonoArray *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
+MonoArray *
+ves_icall_SignatureHelper_get_signature_field (MonoReflectionSigHelper *sig);
-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);
gboolean
mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, MonoError *error);
-gboolean
-mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token);
-
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);
-void
-mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass);
-
gboolean
mono_image_build_metadata (MonoReflectionModuleBuilder *module, MonoError *error);
void
mono_release_type_locks (MonoInternalThread *thread);
+char *
+mono_string_handle_to_utf8 (MonoStringHandle s, MonoError *error);
+
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*
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);
+
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);
-MonoObject *
-mono_load_remote_field_new_icall (MonoObject *this_obj, MonoClass *klass, MonoClassField *field);
-
MonoObject *
mono_load_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoError *error);
gboolean
mono_store_remote_field_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val, MonoError *error);
-void
-mono_store_remote_field_new_icall (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg);
-
gboolean
mono_store_remote_field_new_checked (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg, MonoError *error);
guint8 has_target_code;
};
-typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain,
+typedef gpointer (*MonoImtTrampolineBuilder) (MonoVTable *vtable, MonoDomain *domain,
MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk);
void
-mono_install_imt_thunk_builder (MonoImtThunkBuilder func);
+mono_install_imt_trampoline_builder (MonoImtTrampolineBuilder func);
void
-mono_set_always_build_imt_thunks (gboolean value);
+mono_set_always_build_imt_trampolines (gboolean value);
void
mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot);
MonoMethod *method, gpointer code);
gpointer
-mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size);
+mono_method_alloc_generic_virtual_trampoline (MonoDomain *domain, int size);
typedef enum {
MONO_UNHANDLED_POLICY_LEGACY,
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);
mono_string_intern_checked (MonoString *str, MonoError *error);
char *
-mono_exception_get_native_backtrace (MonoException *exc);
+mono_exception_handle_get_native_backtrace (MonoExceptionHandle exc);
-MonoString *
-ves_icall_Mono_Runtime_GetNativeStackTrace (MonoException *exc);
+MonoStringHandle
+ves_icall_Mono_Runtime_GetNativeStackTrace (MonoExceptionHandle exc, MonoError *erro);
char *
mono_exception_get_managed_backtrace (MonoException *exc);
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);
int
mono_runtime_try_run_main (MonoMethod *method, int argc, char* argv[],
- MonoObject **exc, MonoError *error);
+ MonoObject **exc);
int
mono_runtime_exec_main_checked (MonoMethod *method, MonoArray *args, MonoError *error);
int
-mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc, MonoError *error);
+mono_runtime_try_exec_main (MonoMethod *method, MonoArray *args, MonoObject **exc);
+MonoReflectionMethodHandle
+ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethodHandle rmethod, MonoArrayHandle types, MonoError *error);
-#endif /* __MONO_OBJECT_INTERNALS_H__ */
+gint32
+ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, gboolean create_open_instance, MonoError *error);
+gint32
+ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilderHandle mb,
+ MonoReflectionMethodHandle method,
+ MonoArrayHandle opt_param_types,
+ MonoError *error);
+void
+ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, gpointer file);
+
+void
+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);
+
+void
+ves_icall_AssemblyBuilder_basic_init (MonoReflectionAssemblyBuilder *assemblyb);
+
+MonoReflectionModule*
+ves_icall_AssemblyBuilder_InternalAddModule (MonoReflectionAssemblyBuilder *ab, MonoString *fileName);
+
+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 (MonoReflectionDynamicMethodHandle mb, MonoError *error);
+
+MonoReflectionTypeHandle
+ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilderHandle tb, MonoError *error);
+
+void
+ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
+ MonoReflectionType *t);
+
+void
+ves_icall_ModuleBuilder_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error);
+
+guint32
+ves_icall_ModuleBuilder_getUSIndex (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error);
+
+void
+ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflectionType *type);
+
+MonoAssembly*
+mono_try_assembly_resolve_handle (MonoDomain *domain, MonoStringHandle fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);
+
+#endif /* __MONO_OBJECT_INTERNALS_H__ */
projects / mono.git / blobdiff