X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fobject-internals.h;h=46ebab02775d7889b5c63895ceebcd918c94a2b1;hb=17368ef6c47a97cff0c4f10ce2341cbe0009c970;hp=faa239ece27b6a5cecba3547a2a3cf8fad2690ce;hpb=82a1631ac4ccb2c0d8ae97acb5aa2821430bb9f5;p=mono.git diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index faa239ece27..46ebab02775 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -5,8 +5,11 @@ #include #include #include +#include +#include #include #include "mono/utils/mono-compiler.h" +#include "mono/utils/mono-error.h" /* * We should find a better place for this stuff. We can't put it in mono-compiler.h, @@ -25,7 +28,7 @@ */ #ifdef _G_BOOLEAN_EXPR #undef _G_BOOLEAN_EXPR -#define _G_BOOLEAN_EXPR(expr) (gsize)(expr) +#define _G_BOOLEAN_EXPR(expr) ((gsize)(expr) != 0) #endif #if 1 @@ -98,10 +101,97 @@ mono_raise_exception (ex); \ }; }G_STMT_END - /* 16 == default capacity */ #define mono_stringbuilder_capacity(sb) ((sb)->str ? ((sb)->str->length) : 16) +/* + * Macros which cache the results of lookups locally. + * These should be used instead of the original versions, if the __GNUC__ + * restriction is acceptable. + */ + +#ifdef __GNUC__ + +/* namespace and name should be a constant */ +/* image must be mscorlib since other assemblies can be unloaded */ +#define mono_class_from_name_cached(image,namespace,name) ({ \ + static MonoClass *tmp_klass; \ + if (!tmp_klass) { \ + g_assert (image == mono_defaults.corlib); \ + tmp_klass = mono_class_from_name ((image), (namespace), (name)); \ + g_assert (tmp_klass); \ + }; \ + tmp_klass; }) +/* name should be a compile-time constant */ +#define mono_class_get_field_from_name_cached(klass,name) ({ \ + static MonoClassField *tmp_field; \ + if (!tmp_field) { \ + tmp_field = mono_class_get_field_from_name ((klass), (name)); \ + g_assert (tmp_field); \ + }; \ + tmp_field; }) +/* eclass should be a run-time constant */ +#define mono_array_class_get_cached(eclass,rank) ({ \ + static MonoClass *tmp_klass; \ + if (!tmp_klass) { \ + tmp_klass = mono_array_class_get ((eclass), (rank)); \ + g_assert (tmp_klass); \ + }; \ + tmp_klass; }) +/* eclass should be a run-time constant */ +#define mono_array_new_cached(domain, eclass, size) mono_array_new_specific (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size)) + +#else + +#define mono_class_from_name_cached(image,namespace,name) mono_class_from_name ((image), (namespace), (name)) +#define mono_class_get_field_from_name_cached(klass,name) mono_class_get_field_from_name ((klass), (name)) +#define mono_array_class_get_cached(eclass,rank) mono_array_class_get ((eclass), (rank)) +#define mono_array_new_cached(domain, eclass, size) mono_array_new_specific (mono_class_vtable ((domain), mono_array_class_get_cached ((eclass), 1)), (size)) + +#endif + +#ifdef MONO_BIG_ARRAYS +typedef uint64_t mono_array_size_t; +typedef int64_t mono_array_lower_bound_t; +#define MONO_ARRAY_MAX_INDEX G_MAXINT64 +#define MONO_ARRAY_MAX_SIZE G_MAXUINT64 +#else +typedef uint32_t mono_array_size_t; +typedef int32_t mono_array_lower_bound_t; +#define MONO_ARRAY_MAX_INDEX ((int32_t) 0x7fffffff) +#define MONO_ARRAY_MAX_SIZE ((uint32_t) 0xffffffff) +#endif + +typedef struct { + mono_array_size_t length; + mono_array_lower_bound_t lower_bound; +} MonoArrayBounds; + +struct _MonoArray { + MonoObject obj; + /* bounds is NULL for szarrays */ + MonoArrayBounds *bounds; + /* total number of elements of the array */ + mono_array_size_t max_length; + /* we use double to ensure proper alignment on platforms that need it */ + double vector [MONO_ZERO_LEN_ARRAY]; +}; + +struct _MonoString { + MonoObject object; + int32_t length; + mono_unichar2 chars [MONO_ZERO_LEN_ARRAY]; +}; + +#define mono_object_class(obj) (((MonoObject*)(obj))->vtable->klass) +#define mono_object_domain(obj) (((MonoObject*)(obj))->vtable->domain) + +#define mono_string_chars_fast(s) ((mono_unichar2*)(s)->chars) +#define mono_string_length_fast(s) ((s)->length) + +#define mono_array_length_fast(array) ((array)->max_length) +#define mono_array_addr_with_size_fast(array,size,index) ( ((char*)(array)->vector) + (size) * (index) ) + typedef struct { MonoObject obj; MonoObject *identity; @@ -170,6 +260,11 @@ typedef struct { MonoString *type_name; } MonoTypeLoadException; +typedef struct { + MonoException base; + MonoObject *wrapped_exception; +} MonoRuntimeWrappedException; + typedef struct { MonoObject object; MonoObject *async_state; @@ -183,6 +278,7 @@ typedef struct { MonoObject *async_callback; MonoObject *execution_context; MonoObject *original_context; + gint64 add_time; } MonoAsyncResult; typedef struct { @@ -199,11 +295,17 @@ typedef enum { CallType_OneWay = 3 } MonoCallType; +/* This corresponds to System.Type */ struct _MonoReflectionType { MonoObject object; MonoType *type; }; +typedef struct { + MonoReflectionType type; + MonoObject *type_info; +} MonoReflectionMonoType; + typedef struct { MonoObject object; MonoReflectionType *class_to_proxy; @@ -259,9 +361,13 @@ typedef struct { MonoString *internal_method_name; } MonoStackFrame; -struct _MonoThread { +typedef enum { + MONO_THREAD_FLAG_DONT_MANAGE = 1, // Don't wait for or abort this thread +} MonoThreadFlags; + +struct _MonoInternalThread { MonoObject obj; - int lock_thread_id; /* to be used as the pre-shifted thread id in thin locks */ + 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; MonoArray *cached_culture_info; gpointer unused1; @@ -270,7 +376,7 @@ struct _MonoThread { guint32 name_len; guint32 state; MonoException *abort_exc; - MonoObject *abort_state; + 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; @@ -279,7 +385,6 @@ struct _MonoThread { gpointer lock_data; MonoAppContext *current_appcontext; int stack_size; - MonoObject *start_obj; GSList *appdomain_refs; /* This is modified using atomic ops, so keep it a gint32 */ gint32 interruption_requested; @@ -287,11 +392,6 @@ struct _MonoThread { gpointer suspended_event; gpointer resume_event; CRITICAL_SECTION *synch_cs; - guint8* serialized_culture_info; - guint32 serialized_culture_info_len; - guint8* serialized_ui_culture_info; - guint32 serialized_ui_culture_info_len; - MonoObject *execution_context; MonoBoolean thread_dump_requested; gpointer end_stack; /* This is only used when running in the debugger. */ MonoBoolean thread_interrupt_requested; @@ -300,17 +400,25 @@ struct _MonoThread { guint32 small_id; /* A small, unique id, used for the hazard pointer table. */ MonoThreadManageCallback manage_callback; MonoException *pending_exception; + MonoThread *root_domain_thread; + gpointer interrupt_on_stop; + gsize flags; + gpointer android_tid; /* * These fields are used to avoid having to increment corlib versions * when a new field is added to the unmanaged MonoThread structure. */ - gpointer unused2; - gpointer unused3; - gpointer unused4; gpointer unused5; gpointer unused6; }; +struct _MonoThread { + MonoObject obj; + struct _MonoInternalThread *internal_thread; + MonoObject *start_obj; + MonoObject *ec_to_set; +}; + typedef struct { MonoString *name; MonoReflectionType *type; @@ -449,6 +557,20 @@ typedef struct { guint32 intType; } MonoInterfaceTypeAttribute; +/* + * Callbacks supplied by the runtime and called by the modules in metadata/ + * This interface is easier to extend than adding a new function type + + * a new 'install' function for every callback. + */ +typedef struct { + gpointer (*create_ftnptr) (MonoDomain *domain, gpointer addr); + gpointer (*get_addr_from_ftnptr) (gpointer descr); + char* (*get_runtime_build_info) (void); + gpointer (*get_vtable_trampoline) (int slot_index); + gpointer (*get_imt_trampoline) (int imt_slot_index); + void (*set_cast_details) (MonoClass *from, MonoClass *to); +} MonoRuntimeCallbacks; + /* used to free a dynamic method */ typedef void (*MonoFreeMethodFunc) (MonoDomain *domain, MonoMethod *method); @@ -515,12 +637,21 @@ mono_install_compile_method (MonoCompileFunc func) MONO_INTERNAL; void mono_install_free_method (MonoFreeMethodFunc func) MONO_INTERNAL; +void +mono_install_callbacks (MonoRuntimeCallbacks *cbs) MONO_INTERNAL; + +MonoRuntimeCallbacks* +mono_get_runtime_callbacks (void) MONO_INTERNAL; + void mono_type_initialization_init (void) MONO_INTERNAL; void mono_type_initialization_cleanup (void) MONO_INTERNAL; +int +mono_thread_kill (MonoInternalThread *thread, int signal) MONO_INTERNAL; + guint32 mono_thread_get_tls_key (void) MONO_INTERNAL; @@ -535,6 +666,43 @@ mono_domain_get_tls_offset (void) MONO_INTERNAL; /* Reflection and Reflection.Emit support */ +/* + * Handling System.Type objects: + * + * Fields defined as System.Type in managed code should be defined as MonoObject* + * in unmanaged structures, and the monotype_cast () function should be used for + * casting them to MonoReflectionType* to avoid crashes/security issues when + * encountering instances of user defined subclasses of System.Type. + */ + +#define IS_MONOTYPE(obj) (!(obj) || (((MonoObject*)(obj))->vtable->klass->image == mono_defaults.corlib && ((MonoReflectionType*)(obj))->type != NULL)) + +/* + * Make sure the argument, which should be a System.Type is a System.MonoType object + * or equivalent, and not an instance of + * a user defined subclass of System.Type. This should be used in places were throwing + * an exception is safe. + */ +#define CHECK_MONOTYPE(obj) do { \ + if (!IS_MONOTYPE (obj)) \ + mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \ + } while (0) + +/* 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))) + +/* + * Cast an object to MonoReflectionType, making sure it is a System.MonoType or + * a subclass of it. + */ +static inline MonoReflectionType* +monotype_cast (MonoObject *obj) +{ + g_assert (IS_MONOTYPE (obj)); + + return (MonoReflectionType*)obj; +} + /* * The following structure must match the C# implementation in our corlib. */ @@ -591,11 +759,17 @@ struct _MonoReflectionProperty { MonoProperty *property; }; +/*This is System.EventInfo*/ struct _MonoReflectionEvent { MonoObject object; + MonoObject *cached_add_event; +}; + +typedef struct { + MonoReflectionEvent object; MonoClass *klass; MonoEvent *event; -}; +} MonoReflectionMonoEvent; typedef struct { MonoObject object; @@ -650,6 +824,7 @@ typedef struct { typedef struct { MonoReflectionType *parent; + MonoReflectionType *declaring_type; MonoString *name; MonoReflectionMethod *get; MonoReflectionMethod *set; @@ -702,7 +877,7 @@ typedef struct { } MonoILExceptionInfo; typedef struct { - MonoReflectionType *extype; + MonoObject *extype; gint32 type; gint32 start; gint32 len; @@ -711,7 +886,7 @@ typedef struct { typedef struct { MonoObject object; - MonoReflectionType *catch_type; + MonoObject *catch_type; gint32 filter_offset; gint32 flags; gint32 try_offset; @@ -733,7 +908,7 @@ typedef struct { * LocalBuilder inherits from it under net 2.0. */ MonoObject object; - MonoReflectionType *type; + MonoObject *type; MonoBoolean is_pinned; guint16 local_index; MonoString *name; @@ -747,7 +922,7 @@ typedef struct { MonoString *guid; MonoString *mcookie; MonoString *marshaltype; - MonoReflectionType *marshaltyperef; + MonoObject *marshaltyperef; gint32 param_num; MonoBoolean has_size; } MonoReflectionMarshal; @@ -785,7 +960,7 @@ typedef struct { typedef struct { MonoObject object; MonoMethod *mhandle; - MonoReflectionType *rtype; + MonoObject *rtype; MonoArray *parameters; guint32 attrs; guint32 iattrs; @@ -872,12 +1047,13 @@ typedef struct { gint32 machine; MonoBoolean corlib_internal; MonoArray *type_forwarders; + MonoArray *pktoken; /* as hexadecimal byte[] */ } MonoReflectionAssemblyBuilder; typedef struct { MonoObject object; guint32 attrs; - MonoReflectionType *type; + MonoObject *type; MonoString *name; MonoObject *def_value; gint32 offset; @@ -895,13 +1071,19 @@ typedef struct { MonoObject object; guint32 attrs; MonoString *name; - MonoReflectionType *type; + MonoObject *type; MonoArray *parameters; MonoArray *cattrs; MonoObject *def_value; MonoReflectionMethodBuilder *set_method; MonoReflectionMethodBuilder *get_method; gint32 table_idx; + MonoObject *type_builder; + MonoArray *returnModReq; + MonoArray *returnModOpt; + MonoArray *paramModReq; + MonoArray *paramModOpt; + guint32 call_conv; } MonoReflectionPropertyBuilder; struct _MonoReflectionModule { @@ -934,7 +1116,7 @@ typedef struct { MonoReflectionType type; MonoString *name; MonoString *nspace; - MonoReflectionType *parent; + MonoObject *parent; MonoReflectionType *nesting_type; MonoArray *interfaces; gint32 num_methods; @@ -957,6 +1139,17 @@ typedef struct { MonoReflectionType *created; } MonoReflectionTypeBuilder; +typedef struct { + MonoReflectionType type; + MonoReflectionType *element_type; + int rank; +} MonoReflectionArrayType; + +typedef struct { + MonoReflectionType type; + MonoReflectionType *element_type; +} MonoReflectionDerivedType; + typedef struct { MonoReflectionType type; MonoReflectionTypeBuilder *tbuilder; @@ -972,7 +1165,8 @@ typedef struct { typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass; struct _MonoReflectionGenericClass { MonoReflectionType type; - MonoReflectionTypeBuilder *generic_type; + MonoReflectionType *generic_type; /*Can be either a MonoType or a TypeBuilder*/ + MonoArray *type_arguments; guint32 initialized; }; @@ -1072,24 +1266,26 @@ typedef struct { typedef struct { MonoObject object; MonoReflectionGenericClass *inst; - MonoReflectionFieldBuilder *fb; + MonoObject *fb; /*can be either a MonoField or a FieldBuilder*/ } MonoReflectionFieldOnTypeBuilderInst; typedef struct { MonoObject object; MonoReflectionGenericClass *inst; - MonoReflectionCtorBuilder *cb; + MonoObject *cb; /*can be either a MonoCMethod or ConstructorBuilder*/ } MonoReflectionCtorOnTypeBuilderInst; typedef struct { MonoObject object; - MonoReflectionGenericClass *inst; - MonoReflectionMethodBuilder *mb; + MonoReflectionType *inst; + MonoObject *mb; /*can be either a MonoMethod or MethodBuilder*/ + MonoArray *method_args; + MonoReflectionMethodBuilder *generic_method_definition; } MonoReflectionMethodOnTypeBuilderInst; typedef struct { MonoObject object; - MonoBoolean *visible; + MonoBoolean visible; } MonoReflectionComVisibleAttribute; enum { @@ -1105,6 +1301,12 @@ typedef struct { guint32 location; } MonoManifestResourceInfo; +/* A boxed IntPtr */ +typedef struct { + MonoObject object; + gpointer m_value; +} MonoIntPtr; + /* Keep in sync with System.GenericParameterAttributes */ typedef enum { GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT = 0, @@ -1119,6 +1321,12 @@ typedef enum { GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK = 28 } GenericParameterAttributes; +typedef struct { + MonoType *type; + MonoClassField *field; + MonoProperty *prop; +} CattrNamedArg; + void mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file) MONO_INTERNAL; void mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly) MONO_INTERNAL; MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name) MONO_INTERNAL; @@ -1128,6 +1336,7 @@ guint32 mono_image_create_method_token (MonoDynamicImage *assembly, MonoOb void mono_image_module_basic_init (MonoReflectionModuleBuilder *module) MONO_INTERNAL; void mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj) MONO_INTERNAL; void mono_dynamic_image_free (MonoDynamicImage *image) MONO_INTERNAL; +void mono_image_set_wrappers_type (MonoReflectionModuleBuilder *mb, MonoReflectionType *type) MONO_INTERNAL; void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL; @@ -1145,6 +1354,13 @@ void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m) MONO void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb) MONO_INTERNAL; void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam) MONO_INTERNAL; +void mono_reflection_create_unmanaged_type (MonoReflectionType *type) MONO_INTERNAL; +void mono_reflection_register_with_runtime (MonoReflectionType *type) MONO_INTERNAL; + +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) MONO_INTERNAL; +MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token) MONO_INTERNAL; + +MonoArray* mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass) MONO_INTERNAL; MonoClass* mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic) MONO_INTERNAL; @@ -1172,6 +1388,15 @@ mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass) MONO gboolean mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token) MONO_INTERNAL; +void +mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args) MONO_INTERNAL; + +MonoType* +mono_reflection_type_get_handle (MonoReflectionType *ref) MONO_INTERNAL; + +void +mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass) MONO_INTERNAL; + void mono_image_build_metadata (MonoReflectionModuleBuilder *module) MONO_INTERNAL; @@ -1179,10 +1404,14 @@ int mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value) MONO_INTERNAL; void -mono_release_type_locks (MonoThread *thread) MONO_INTERNAL; +mono_release_type_locks (MonoInternalThread *thread) MONO_INTERNAL; + +char * +mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error) MONO_INTERNAL; char * -mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s) MONO_INTERNAL; +mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error) MONO_INTERNAL; + MonoArray* mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array) MONO_INTERNAL; @@ -1190,6 +1419,9 @@ mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array) MONO_INTERNAL; void mono_array_full_copy (MonoArray *src, MonoArray *dest) MONO_INTERNAL; +gboolean +mono_array_calc_byte_len (MonoClass *class, uintptr_t len, uintptr_t *res) MONO_INTERNAL; + gpointer mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy) MONO_INTERNAL; @@ -1208,7 +1440,11 @@ mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass) MONO_INTER MonoObject* mono_nullable_box (guint8 *buf, MonoClass *klass) MONO_INTERNAL; +#ifdef MONO_SMALL_CONFIG +#define MONO_IMT_SIZE 9 +#else #define MONO_IMT_SIZE 19 +#endif typedef union { int vtable_slot; @@ -1220,6 +1456,7 @@ typedef struct _MonoImtBuilderEntry { struct _MonoImtBuilderEntry *next; MonoImtItemValue value; int children; + guint8 has_target_code : 1; } MonoImtBuilderEntry; typedef struct _MonoIMTCheckItem MonoIMTCheckItem; @@ -1234,6 +1471,7 @@ struct _MonoIMTCheckItem { guint8 compare_done; guint8 chunk_size; guint8 short_branch; + guint8 has_target_code; }; typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain, @@ -1242,12 +1480,6 @@ typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain, void mono_install_imt_thunk_builder (MonoImtThunkBuilder func) MONO_INTERNAL; -void -mono_install_imt_trampoline (gpointer tramp) MONO_INTERNAL; - -void -mono_install_vtable_trampoline (gpointer tramp) MONO_INTERNAL; - void mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot) MONO_INTERNAL; @@ -1255,8 +1487,9 @@ guint32 mono_method_get_imt_slot (MonoMethod *method) MONO_INTERNAL; void -mono_method_add_generic_virtual_invocation (MonoDomain *domain, gpointer *vtable_slot, - MonoGenericInst *method_inst, gpointer code) MONO_INTERNAL; +mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable, + gpointer *vtable_slot, + MonoMethod *method, gpointer code) MONO_INTERNAL; gpointer mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size) MONO_INTERNAL; @@ -1277,5 +1510,48 @@ mono_class_try_get_vtable (MonoDomain *domain, MonoClass *class) MONO_INTERNAL; MonoException * mono_runtime_class_init_full (MonoVTable *vtable, gboolean raise_exception) MONO_INTERNAL; +void +mono_method_clear_object (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; + +void +mono_class_compute_gc_descriptor (MonoClass *class) MONO_INTERNAL; + +gsize* +mono_class_compute_bitmap (MonoClass *class, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields) MONO_INTERNAL; + +MonoObject* +mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoObject **exc) MONO_INTERNAL; + +gboolean +mono_class_is_reflection_method_or_constructor (MonoClass *class) MONO_INTERNAL; + +MonoObject * +mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob) MONO_INTERNAL; + +gpointer +mono_class_get_ref_info (MonoClass *klass) MONO_INTERNAL; + +void +mono_class_set_ref_info (MonoClass *klass, gpointer obj) MONO_INTERNAL; + +void +mono_class_free_ref_info (MonoClass *klass) MONO_INTERNAL; + +MonoObject * +mono_object_new_pinned (MonoDomain *domain, MonoClass *klass) MONO_INTERNAL; + +void +mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value) MONO_INTERNAL; + +char * +mono_string_to_utf8_ignore (MonoString *s) MONO_INTERNAL; + +char * +mono_string_to_utf8_image_ignore (MonoImage *image, MonoString *s) MONO_INTERNAL; + +char * +mono_string_to_utf8_mp_ignore (MonoMemPool *mp, MonoString *s) MONO_INTERNAL; + #endif /* __MONO_OBJECT_INTERNALS_H__ */ +