X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=mono%2Fmetadata%2Fclass-internals.h;h=46ea5ef635098895a28624e2a0dc101d5418e1da;hb=b711f7731b1861c25f673eb699df5d4000910b9f;hp=942b1f4d1029b4435a0470244fb8e7b3782d15a6;hpb=a2850fc7dae0cf969b5d680a20496ac16526dcb8;p=mono.git diff --git a/mono/metadata/class-internals.h b/mono/metadata/class-internals.h index 942b1f4d102..46ea5ef6350 100644 --- a/mono/metadata/class-internals.h +++ b/mono/metadata/class-internals.h @@ -11,6 +11,7 @@ #include #include "mono/utils/mono-compiler.h" #include "mono/utils/mono-error.h" +#include "mono/sgen/gc-internal-agnostic.h" #define MONO_CLASS_IS_ARRAY(c) ((c)->rank) @@ -19,6 +20,7 @@ #define MONO_DEFAULT_SUPERTABLE_SIZE 6 extern gboolean mono_print_vtable; +extern gboolean mono_align_small_structs; typedef struct _MonoMethodWrapper MonoMethodWrapper; typedef struct _MonoMethodInflated MonoMethodInflated; @@ -33,7 +35,7 @@ typedef struct _MonoMethodPInvoke MonoMethodPInvoke; #ifdef ENABLE_ICALL_EXPORT #pragma GCC diagnostic ignored "-Wmissing-prototypes" -#define ICALL_EXPORT +#define ICALL_EXPORT MONO_API #else #define ICALL_EXPORT static #endif @@ -80,8 +82,6 @@ struct _MonoMethod { unsigned int is_inflated:1; /* whether we're a MonoMethodInflated */ unsigned int skip_visibility:1; /* whenever to skip JIT visibility checks */ unsigned int verification_success:1; /* whether this method has been verified successfully.*/ - /* TODO we MUST get rid of this field, it's an ugly hack nobody is proud of. */ - unsigned int is_mb_open : 1; /* This is the fully open instantiation of a generic method_builder. Worse than is_tb_open, but it's temporary */ signed int slot : 16; /* @@ -195,8 +195,6 @@ struct _MonoEvent { /* type of exception being "on hold" for later processing (see exception_type) */ enum { MONO_EXCEPTION_NONE = 0, - MONO_EXCEPTION_SECURITY_LINKDEMAND = 1, - MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND = 2, MONO_EXCEPTION_INVALID_PROGRAM = 3, MONO_EXCEPTION_UNVERIFIABLE_IL = 4, MONO_EXCEPTION_MISSING_METHOD = 5, @@ -208,7 +206,9 @@ enum { MONO_EXCEPTION_GENERIC_SHARING_FAILED = 11, MONO_EXCEPTION_BAD_IMAGE = 12, MONO_EXCEPTION_OBJECT_SUPPLIED = 13, /*The exception object is already created.*/ - MONO_EXCEPTION_OUT_OF_MEMORY = 14 + MONO_EXCEPTION_OUT_OF_MEMORY = 14, + MONO_EXCEPTION_INLINE_FAILED = 15, + MONO_EXCEPTION_MONO_ERROR = 16, /* add other exception type */ }; @@ -291,21 +291,20 @@ struct _MonoClass { guint wastypebuilder : 1; /* class was created at runtime from a TypeBuilder */ /* next byte */ guint8 min_align; + /* next byte */ guint packing_size : 4; - /* still 4 bits free */ - /* next byte */ guint ghcimpl : 1; /* class has its own GetHashCode impl */ guint has_finalize : 1; /* class has its own Finalize impl */ #ifndef DISABLE_REMOTING guint marshalbyref : 1; /* class is a MarshalByRefObject */ guint contextbound : 1; /* class is a ContextBoundObject */ #endif + /* next byte */ guint delegate : 1; /* class is a Delegate */ guint gc_descr_inited : 1; /* gc_descr is initialized */ guint has_cctor : 1; /* class has a cctor */ guint has_references : 1; /* it has GC-tracked references in the instance */ - /* next byte */ guint has_static_refs : 1; /* it has static fields that are GC-tracked */ guint no_special_static_fields : 1; /* has no thread/context static fields */ /* directly or indirectly derives from ComImport attributed class. @@ -315,11 +314,12 @@ struct _MonoClass { */ guint is_com_object : 1; guint nested_classes_inited : 1; /* Whenever nested_class is initialized */ + + /* next byte*/ guint interfaces_inited : 1; /* interfaces is initialized */ guint simd_type : 1; /* class is a simd intrinsic type */ guint is_generic : 1; /* class is a generic type definition */ guint is_inflated : 1; /* class is a generic instance */ - /* next byte */ guint has_finalize_inited : 1; /* has_finalize is initialized */ guint fields_inited : 1; /* fields is initialized */ guint setup_fields_called : 1; /* to prevent infinite loops in setup_fields */ @@ -393,7 +393,7 @@ struct _MonoClass { MonoGenericClass *generic_class; MonoGenericContainer *generic_container; - void *gc_descr; + MonoGCDescriptor gc_descr; MonoClassRuntimeInfo *runtime_info; @@ -408,8 +408,8 @@ struct _MonoClass { }; #ifdef COMPRESSED_INTERFACE_BITMAP -int mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size) MONO_INTERNAL; -int mono_class_interface_match (const uint8_t *bitmap, int id) MONO_INTERNAL; +int mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size); +int mono_class_interface_match (const uint8_t *bitmap, int id); #else #define mono_class_interface_match(bmap,uiid) ((bmap) [(uiid) >> 3] & (1 << ((uiid)&7))) #endif @@ -440,7 +440,7 @@ int mono_class_interface_match (const uint8_t *bitmap, int id) MONO_INTERNAL; MONO_API int mono_class_interface_offset (MonoClass *klass, MonoClass *itf); -int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match) MONO_INTERNAL; +int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match); typedef gpointer MonoRuntimeGenericContext; @@ -451,7 +451,7 @@ struct MonoVTable { * According to comments in gc_gcj.h, this should be the second word in * the vtable. */ - void *gc_descr; + MonoGCDescriptor gc_descr; MonoDomain *domain; /* each object/vtable belongs to exactly one domain */ gpointer type; /* System.Type type for klass */ guint8 *interface_bitmap; @@ -520,6 +520,7 @@ struct _MonoMethodInflated { MonoMethodHeader *header; MonoMethod *declaring; /* the generic method definition. */ MonoGenericContext context; /* The current instantiation */ + MonoImageSet *owner; /* The image set that the inflated method belongs to. */ }; /* @@ -559,10 +560,16 @@ struct _MonoDynamicGenericClass { * A type parameter. */ struct _MonoGenericParam { - MonoGenericContainer *owner; /* Type or method this parameter was defined in. */ + /* + * Type or method this parameter was defined in. + */ + MonoGenericContainer *owner; guint16 num; - /* For internal runtime use, used to make different versions of the same param */ - guint16 serial; + /* + * If != NULL, this is a generated generic param used by the JIT to implement generic + * sharing. + */ + MonoType *gshared_constraint; /* * If owner is NULL, or owner is 'owned' by this gparam, * then this is the image whose mempool this struct was allocated from. @@ -621,6 +628,7 @@ struct _MonoGenericContainer { #define mono_generic_param_owner(p) ((p)->owner) #define mono_generic_param_num(p) ((p)->num) #define mono_generic_param_info(p) (mono_generic_param_owner (p) ? &((MonoGenericParamFull *) p)->info : NULL) +#define mono_generic_param_name(p) (((mono_generic_param_owner (p) || (p)->gshared_constraint)) ? ((MonoGenericParamFull *) p)->info.name : NULL) #define mono_type_get_generic_param_owner(t) (mono_generic_param_owner ((t)->data.generic_param)) #define mono_type_get_generic_param_num(t) (mono_generic_param_num ((t)->data.generic_param)) @@ -657,6 +665,8 @@ typedef struct { gconstpointer trampoline; MonoMethodSignature *sig; const char *c_symbol; + MonoMethod *wrapper_method; + gboolean no_raise; } MonoJitICallInfo; typedef struct { @@ -670,10 +680,10 @@ typedef struct { } MonoLoaderError; void -mono_class_setup_supertypes (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_supertypes (MonoClass *klass); void -mono_class_setup_fields_locking (MonoClass *class) MONO_INTERNAL; +mono_class_setup_fields_locking (MonoClass *klass); /* WARNING * Only call this function if you can ensure both @klass and @parent @@ -712,42 +722,38 @@ typedef struct { typedef struct { guint64 new_object_count; - gulong initialized_class_count; - gulong generic_vtable_count; - gulong used_class_count; - gulong method_count; - gulong class_vtable_size; - gulong class_static_data_size; - gulong generic_instance_count; - gulong generic_class_count; - gulong inflated_method_count; - gulong inflated_method_count_2; - gulong inflated_type_count; - gulong generics_metadata_size; - gulong dynamic_code_alloc_count; - gulong dynamic_code_bytes_count; - gulong dynamic_code_frees_count; - gulong delegate_creations; - gulong imt_tables_size; - gulong imt_number_of_tables; - gulong imt_number_of_methods; - gulong imt_used_slots; - gulong imt_slots_with_collisions; - gulong imt_max_collisions_in_slot; - gulong imt_method_count_when_max_collisions; - gulong imt_thunks_size; - gulong jit_info_table_insert_count; - gulong jit_info_table_remove_count; - gulong jit_info_table_lookup_count; - gulong hazardous_pointer_count; - gulong generics_sharable_methods; - gulong generics_unsharable_methods; - gulong generics_shared_methods; - gulong gsharedvt_methods; - gulong minor_gc_count; - gulong major_gc_count; - gulong minor_gc_time_usecs; - gulong major_gc_time_usecs; + size_t initialized_class_count; + size_t generic_vtable_count; + size_t used_class_count; + size_t method_count; + size_t class_vtable_size; + size_t class_static_data_size; + size_t generic_instance_count; + size_t generic_class_count; + size_t inflated_method_count; + size_t inflated_method_count_2; + size_t inflated_type_count; + size_t generics_metadata_size; + size_t delegate_creations; + size_t imt_tables_size; + size_t imt_number_of_tables; + size_t imt_number_of_methods; + size_t imt_used_slots; + size_t imt_slots_with_collisions; + size_t imt_max_collisions_in_slot; + size_t imt_method_count_when_max_collisions; + size_t imt_thunks_size; + size_t jit_info_table_insert_count; + size_t jit_info_table_remove_count; + size_t jit_info_table_lookup_count; + size_t generics_sharable_methods; + size_t generics_unsharable_methods; + size_t generics_shared_methods; + size_t gsharedvt_methods; + size_t minor_gc_count; + size_t major_gc_count; + size_t minor_gc_time_usecs; + size_t major_gc_time_usecs; gboolean enabled; } MonoStats; @@ -833,7 +839,7 @@ typedef struct { guint threadpool_iothreads; } MonoPerfCounters; -extern MonoPerfCounters *mono_perfcounters MONO_INTERNAL; +extern MonoPerfCounters *mono_perfcounters; MONO_API void mono_perfcounters_init (void); @@ -855,24 +861,7 @@ typedef struct { void *handle; } MonoHandleRef; -enum { - MONO_GENERIC_SHARING_NONE, - MONO_GENERIC_SHARING_COLLECTIONS, - MONO_GENERIC_SHARING_CORLIB, - MONO_GENERIC_SHARING_ALL -}; - -/* - * Flags for which contexts were used in inflating a generic. - */ -enum { - MONO_GENERIC_CONTEXT_USED_CLASS = 1, - MONO_GENERIC_CONTEXT_USED_METHOD = 2 -}; - -#define MONO_GENERIC_CONTEXT_USED_BOTH (MONO_GENERIC_CONTEXT_USED_CLASS | MONO_GENERIC_CONTEXT_USED_METHOD) - -extern MonoStats mono_stats MONO_INTERNAL; +extern MonoStats mono_stats; typedef gpointer (*MonoTrampoline) (MonoMethod *method); typedef gpointer (*MonoJumpTrampoline) (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper); @@ -885,160 +874,173 @@ typedef gboolean (*MonoGetCachedClassInfo) (MonoClass *klass, MonoCachedClassInf typedef gboolean (*MonoGetClassFromName) (MonoImage *image, const char *name_space, const char *name, MonoClass **res); +static inline gboolean +method_is_dynamic (MonoMethod *method) +{ +#ifdef DISABLE_REFLECTION_EMIT + return FALSE; +#else + return method->dynamic; +#endif +} + void -mono_classes_init (void) MONO_INTERNAL; +mono_classes_init (void); void -mono_classes_cleanup (void) MONO_INTERNAL; +mono_classes_cleanup (void); void -mono_class_layout_fields (MonoClass *klass) MONO_INTERNAL; +mono_class_layout_fields (MonoClass *klass); void -mono_class_setup_interface_offsets (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_interface_offsets (MonoClass *klass); void -mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum, GList *in_setup) MONO_INTERNAL; +mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum, GList *in_setup); void -mono_class_setup_vtable (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_vtable (MonoClass *klass); void -mono_class_setup_methods (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_methods (MonoClass *klass); void -mono_class_setup_mono_type (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_mono_type (MonoClass *klass); void -mono_class_setup_parent (MonoClass *klass, MonoClass *parent) MONO_INTERNAL; +mono_class_setup_parent (MonoClass *klass, MonoClass *parent); MonoMethod* -mono_class_get_method_by_index (MonoClass *class, int index) MONO_INTERNAL; +mono_class_get_method_by_index (MonoClass *klass, int index); MonoMethod* -mono_class_get_inflated_method (MonoClass *class, MonoMethod *method) MONO_INTERNAL; +mono_class_get_inflated_method (MonoClass *klass, MonoMethod *method); MonoMethod* -mono_class_get_vtable_entry (MonoClass *class, int offset) MONO_INTERNAL; +mono_class_get_vtable_entry (MonoClass *klass, int offset); GPtrArray* -mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error) MONO_INTERNAL; +mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error); int -mono_class_get_vtable_size (MonoClass *klass) MONO_INTERNAL; +mono_class_get_vtable_size (MonoClass *klass); gboolean -mono_class_is_open_constructed_type (MonoType *t) MONO_INTERNAL; +mono_class_is_open_constructed_type (MonoType *t); gboolean mono_class_get_overrides_full (MonoImage *image, guint32 type_token, MonoMethod ***overrides, gint32 *num_overrides, - MonoGenericContext *generic_context) MONO_INTERNAL; + MonoGenericContext *generic_context); MonoMethod* -mono_class_get_cctor (MonoClass *klass) MONO_INTERNAL; +mono_class_get_cctor (MonoClass *klass); MonoMethod* -mono_class_get_finalizer (MonoClass *klass) MONO_INTERNAL; +mono_class_get_finalizer (MonoClass *klass); gboolean -mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller) MONO_INTERNAL; +mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller); gboolean -mono_class_field_is_special_static (MonoClassField *field) MONO_INTERNAL; +mono_class_field_is_special_static (MonoClassField *field); guint32 -mono_class_field_get_special_static_type (MonoClassField *field) MONO_INTERNAL; +mono_class_field_get_special_static_type (MonoClassField *field); gboolean -mono_class_has_special_static_fields (MonoClass *klass) MONO_INTERNAL; +mono_class_has_special_static_fields (MonoClass *klass); const char* -mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type) MONO_INTERNAL; +mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type); const char* -mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def_type) MONO_INTERNAL; +mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def_type); void -mono_install_trampoline (MonoTrampoline func) MONO_INTERNAL; +mono_install_trampoline (MonoTrampoline func); void -mono_install_jump_trampoline (MonoJumpTrampoline func) MONO_INTERNAL; +mono_install_jump_trampoline (MonoJumpTrampoline func); void -mono_install_delegate_trampoline (MonoDelegateTrampoline func) MONO_INTERNAL; +mono_install_delegate_trampoline (MonoDelegateTrampoline func); gpointer -mono_lookup_dynamic_token (MonoImage *image, guint32 token, MonoGenericContext *context) MONO_INTERNAL; +mono_lookup_dynamic_token (MonoImage *image, guint32 token, MonoGenericContext *context); gpointer -mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean check_token, MonoClass **handle_class, MonoGenericContext *context) MONO_INTERNAL; +mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean check_token, MonoClass **handle_class, MonoGenericContext *context); void -mono_install_lookup_dynamic_token (MonoLookupDynamicToken func) MONO_INTERNAL; +mono_install_lookup_dynamic_token (MonoLookupDynamicToken func); gpointer -mono_runtime_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper) MONO_INTERNAL; +mono_runtime_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper); gpointer -mono_runtime_create_delegate_trampoline (MonoClass *klass) MONO_INTERNAL; +mono_runtime_create_delegate_trampoline (MonoClass *klass); void -mono_install_get_cached_class_info (MonoGetCachedClassInfo func) MONO_INTERNAL; +mono_install_get_cached_class_info (MonoGetCachedClassInfo func); void -mono_install_get_class_from_name (MonoGetClassFromName func) MONO_INTERNAL; +mono_install_get_class_from_name (MonoGetClassFromName func); MonoGenericContext* -mono_class_get_context (MonoClass *class) MONO_INTERNAL; +mono_class_get_context (MonoClass *klass); MonoMethodSignature* -mono_method_signature_checked (MonoMethod *m, MonoError *err) MONO_INTERNAL; +mono_method_signature_checked (MonoMethod *m, MonoError *err); MonoGenericContext* -mono_method_get_context_general (MonoMethod *method, gboolean uninflated) MONO_INTERNAL; +mono_method_get_context_general (MonoMethod *method, gboolean uninflated); MonoGenericContext* -mono_method_get_context (MonoMethod *method) MONO_INTERNAL; +mono_method_get_context (MonoMethod *method); /* Used by monodis, thus cannot be MONO_INTERNAL */ MONO_API MonoGenericContainer* mono_method_get_generic_container (MonoMethod *method); MonoGenericContext* -mono_generic_class_get_context (MonoGenericClass *gclass) MONO_INTERNAL; +mono_generic_class_get_context (MonoGenericClass *gclass); MonoClass* -mono_generic_class_get_class (MonoGenericClass *gclass) MONO_INTERNAL; +mono_generic_class_get_class (MonoGenericClass *gclass); void -mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* container) MONO_INTERNAL; +mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* container); MonoMethod* -mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context) MONO_INTERNAL; +mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context); MonoMethod* -mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error); + +MonoMethod * +mono_class_inflate_generic_method_checked (MonoMethod *method, MonoGenericContext *context, MonoError *error); -MonoMethodInflated* -mono_method_inflated_lookup (MonoMethodInflated* method, gboolean cache) MONO_INTERNAL; +MonoImageSet * +mono_metadata_get_image_set_for_method (MonoMethodInflated *method); MONO_API MonoMethodSignature * mono_metadata_get_inflated_signature (MonoMethodSignature *sig, MonoGenericContext *context); MonoType* -mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error); MonoClass* -mono_class_inflate_generic_class (MonoClass *gklass, MonoGenericContext *context) MONO_INTERNAL; +mono_class_inflate_generic_class (MonoClass *gklass, MonoGenericContext *context); MonoType* -mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error); MONO_API void mono_metadata_free_inflated_signature (MonoMethodSignature *sig); MonoMethodSignature* -mono_inflate_generic_signature (MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_inflate_generic_signature (MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error); typedef struct { MonoImage *corlib; @@ -1070,6 +1072,7 @@ typedef struct { MonoClass *methodhandle_class; MonoClass *systemtype_class; MonoClass *monotype_class; + MonoClass *runtimetype_class; MonoClass *exception_class; MonoClass *threadabortexception_class; MonoClass *thread_class; @@ -1103,6 +1106,8 @@ typedef struct { MonoClass *customattribute_data_class; MonoClass *critical_finalizer_object; MonoClass *generic_ireadonlylist_class; + MonoClass *threadpool_wait_callback_class; + MonoMethod *threadpool_perform_wait_callback_method; } MonoDefaults; #ifdef DISABLE_REMOTING @@ -1111,10 +1116,10 @@ typedef struct { #define mono_object_is_transparent_proxy(object) (FALSE) #else MonoRemoteClass* -mono_remote_class (MonoDomain *domain, MonoString *class_name, MonoClass *proxy_class) MONO_INTERNAL; +mono_remote_class (MonoDomain *domain, MonoString *class_name, MonoClass *proxy_class); void -mono_install_remoting_trampoline (MonoRemotingTrampoline func) MONO_INTERNAL; +mono_install_remoting_trampoline (MonoRemotingTrampoline func); #define mono_class_is_transparent_proxy(klass) ((klass) == mono_defaults.transparent_proxy_class) #define mono_class_is_real_proxy(klass) ((klass) == mono_defaults.real_proxy_class) @@ -1154,13 +1159,13 @@ GENERATE_GET_CLASS_WITH_CACHE_DECL (variant) #endif -extern MonoDefaults mono_defaults MONO_INTERNAL; +extern MonoDefaults mono_defaults; void -mono_loader_init (void) MONO_INTERNAL; +mono_loader_init (void); void -mono_loader_cleanup (void) MONO_INTERNAL; +mono_loader_cleanup (void); void mono_loader_lock (void) MONO_LLVM_INTERNAL; @@ -1169,78 +1174,77 @@ void mono_loader_unlock (void) MONO_LLVM_INTERNAL; void -mono_loader_lock_track_ownership (gboolean track) MONO_INTERNAL; +mono_loader_lock_track_ownership (gboolean track); gboolean -mono_loader_lock_is_owned_by_self (void) MONO_INTERNAL; +mono_loader_lock_is_owned_by_self (void); void -mono_loader_lock_if_inited (void) MONO_INTERNAL; +mono_loader_lock_if_inited (void); void -mono_loader_unlock_if_inited (void) MONO_INTERNAL; +mono_loader_unlock_if_inited (void); void -mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_only) MONO_INTERNAL; +mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_only); void -mono_loader_set_error_type_load (const char *class_name, const char *assembly_name) MONO_INTERNAL; +mono_loader_set_error_type_load (const char *class_name, const char *assembly_name); void -mono_loader_set_error_method_load (const char *class_name, const char *member_name) MONO_INTERNAL; +mono_loader_set_error_method_load (const char *class_name, const char *member_name); void -mono_loader_set_error_field_load (MonoClass *klass, const char *member_name) MONO_INTERNAL; +mono_loader_set_error_field_load (MonoClass *klass, const char *member_name); void -mono_loader_set_error_bad_image (char *msg) MONO_INTERNAL; +mono_loader_set_error_bad_image (char *msg); MonoException * -mono_loader_error_prepare_exception (MonoLoaderError *error) MONO_INTERNAL; +mono_loader_error_prepare_exception (MonoLoaderError *error); MonoLoaderError * -mono_loader_get_last_error (void) MONO_INTERNAL; +mono_loader_get_last_error (void); + +void +mono_loader_clear_error (void); void -mono_loader_clear_error (void) MONO_INTERNAL; +mono_loader_assert_no_error (void); void -mono_reflection_init (void) MONO_INTERNAL; +mono_reflection_init (void); void -mono_icall_init (void) MONO_INTERNAL; +mono_icall_init (void); void -mono_icall_cleanup (void) MONO_INTERNAL; +mono_icall_cleanup (void); gpointer -mono_method_get_wrapper_data (MonoMethod *method, guint32 id) MONO_INTERNAL; +mono_method_get_wrapper_data (MonoMethod *method, guint32 id); gboolean -mono_metadata_has_generic_params (MonoImage *image, guint32 token) MONO_INTERNAL; +mono_metadata_has_generic_params (MonoImage *image, guint32 token); MONO_API MonoGenericContainer * mono_metadata_load_generic_params (MonoImage *image, guint32 token, MonoGenericContainer *parent_container); -MONO_API void -mono_metadata_load_generic_param_constraints (MonoImage *image, guint32 token, - MonoGenericContainer *container); - -gboolean -mono_metadata_load_generic_param_constraints_full (MonoImage *image, guint32 token, - MonoGenericContainer *container) MONO_INTERNAL; +MONO_API gboolean +mono_metadata_load_generic_param_constraints_checked (MonoImage *image, guint32 token, + MonoGenericContainer *container, MonoError *error); MonoMethodSignature* -mono_create_icall_signature (const char *sigstr) MONO_INTERNAL; +mono_create_icall_signature (const char *sigstr); MonoJitICallInfo * -mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) MONO_INTERNAL; +mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save); MonoJitICallInfo * -mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, const char *c_symbol) MONO_INTERNAL; +mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, gboolean no_raise, const char *c_symbol); void -mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper) MONO_INTERNAL; +mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper); MonoJitICallInfo * mono_find_jit_icall_by_name (const char *name) MONO_LLVM_INTERNAL; @@ -1249,34 +1253,37 @@ MonoJitICallInfo * mono_find_jit_icall_by_addr (gconstpointer addr) MONO_LLVM_INTERNAL; GHashTable* -mono_get_jit_icall_info (void) MONO_INTERNAL; +mono_get_jit_icall_info (void); const char* -mono_lookup_jit_icall_symbol (const char *name) MONO_INTERNAL; +mono_lookup_jit_icall_symbol (const char *name); gboolean -mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) MONO_INTERNAL; +mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data); gpointer -mono_class_get_exception_data (MonoClass *klass) MONO_INTERNAL; +mono_class_get_exception_data (MonoClass *klass); MonoException* -mono_class_get_exception_for_failure (MonoClass *klass) MONO_INTERNAL; +mono_class_get_exception_for_failure (MonoClass *klass); char* -mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format) MONO_INTERNAL; +mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format); char* -mono_type_get_full_name (MonoClass *class) MONO_INTERNAL; +mono_type_get_full_name (MonoClass *klass); + +char * +mono_method_get_name_full (MonoMethod *method, gboolean signature, MonoTypeNameFormat format); -MonoArrayType *mono_dup_array_type (MonoImage *image, MonoArrayType *a) MONO_INTERNAL; -MonoMethodSignature *mono_metadata_signature_deep_dup (MonoImage *image, MonoMethodSignature *sig) MONO_INTERNAL; +MonoArrayType *mono_dup_array_type (MonoImage *image, MonoArrayType *a); +MonoMethodSignature *mono_metadata_signature_deep_dup (MonoImage *image, MonoMethodSignature *sig); MONO_API void mono_image_init_name_cache (MonoImage *image); -gboolean mono_class_is_nullable (MonoClass *klass) MONO_INTERNAL; -MonoClass *mono_class_get_nullable_param (MonoClass *klass) MONO_INTERNAL; +gboolean mono_class_is_nullable (MonoClass *klass); +MonoClass *mono_class_get_nullable_param (MonoClass *klass); /* object debugging functions, for use inside gdb */ MONO_API void mono_object_describe (MonoObject *obj); @@ -1284,6 +1291,9 @@ MONO_API void mono_object_describe_fields (MonoObject *obj); MONO_API void mono_value_describe_fields (MonoClass* klass, const char* addr); MONO_API void mono_class_describe_statics (MonoClass* klass); +/* method debugging functions, for use inside gdb */ +MONO_API void mono_method_print_code (MonoMethod *method); + /*Enum validation related functions*/ MONO_API gboolean mono_type_is_valid_enum_basetype (MonoType * type); @@ -1292,92 +1302,113 @@ MONO_API gboolean mono_class_is_valid_enum (MonoClass *klass); MonoType * -mono_type_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context) MONO_INTERNAL; +mono_type_get_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error); gboolean -mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass) MONO_INTERNAL; +mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass); MonoMethod* -mono_class_get_method_generic (MonoClass *klass, MonoMethod *method) MONO_INTERNAL; +mono_class_get_method_generic (MonoClass *klass, MonoMethod *method); MonoType* -mono_type_get_basic_type_from_generic (MonoType *type) MONO_INTERNAL; +mono_type_get_basic_type_from_generic (MonoType *type); gboolean -mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass) MONO_INTERNAL; +mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass); gboolean -mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass) MONO_INTERNAL; +mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass); gboolean -mono_class_can_access_class (MonoClass *access_class, MonoClass *target_class) MONO_INTERNAL; +mono_class_can_access_class (MonoClass *access_class, MonoClass *target_class); MonoClass * -mono_class_get_generic_type_definition (MonoClass *klass) MONO_INTERNAL; +mono_class_get_generic_type_definition (MonoClass *klass); gboolean -mono_class_has_parent_and_ignore_generics (MonoClass *klass, MonoClass *parent) MONO_INTERNAL; +mono_class_has_parent_and_ignore_generics (MonoClass *klass, MonoClass *parent); int -mono_method_get_vtable_slot (MonoMethod *method) MONO_INTERNAL; +mono_method_get_vtable_slot (MonoMethod *method); int -mono_method_get_vtable_index (MonoMethod *method) MONO_INTERNAL; +mono_method_get_vtable_index (MonoMethod *method); MonoMethod* -mono_method_search_in_array_class (MonoClass *klass, const char *name, MonoMethodSignature *sig) MONO_INTERNAL; +mono_method_search_in_array_class (MonoClass *klass, const char *name, MonoMethodSignature *sig); void -mono_class_setup_interface_id (MonoClass *class) MONO_INTERNAL; +mono_class_setup_interface_id (MonoClass *klass); MonoGenericContainer* -mono_class_get_generic_container (MonoClass *klass) MONO_INTERNAL; +mono_class_get_generic_container (MonoClass *klass); MonoGenericClass* -mono_class_get_generic_class (MonoClass *klass) MONO_INTERNAL; +mono_class_get_generic_class (MonoClass *klass); void -mono_class_alloc_ext (MonoClass *klass) MONO_INTERNAL; +mono_class_alloc_ext (MonoClass *klass); void -mono_class_setup_interfaces (MonoClass *klass, MonoError *error) MONO_INTERNAL; +mono_class_setup_interfaces (MonoClass *klass, MonoError *error); MonoClassField* -mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type) MONO_INTERNAL; +mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type); MonoVTable* -mono_class_vtable_full (MonoDomain *domain, MonoClass *class, gboolean raise_on_error) MONO_INTERNAL; +mono_class_vtable_full (MonoDomain *domain, MonoClass *klass, gboolean raise_on_error); gboolean -mono_class_is_assignable_from_slow (MonoClass *target, MonoClass *candidate) MONO_INTERNAL; +mono_class_is_assignable_from_slow (MonoClass *target, MonoClass *candidate); gboolean -mono_class_has_variant_generic_params (MonoClass *klass) MONO_INTERNAL; +mono_class_has_variant_generic_params (MonoClass *klass); gboolean -mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean check_for_reference_conv) MONO_INTERNAL; +mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean check_for_reference_conv); -gboolean mono_is_corlib_image (MonoImage *image) MONO_INTERNAL; +gboolean mono_is_corlib_image (MonoImage *image); MonoType* -mono_field_get_type_checked (MonoClassField *field, MonoError *error) MONO_INTERNAL; +mono_field_get_type_checked (MonoClassField *field, MonoError *error); MonoClassField* -mono_class_get_fields_lazy (MonoClass* klass, gpointer *iter) MONO_INTERNAL; +mono_class_get_fields_lazy (MonoClass* klass, gpointer *iter); gboolean -mono_class_check_vtable_constraints (MonoClass *class, GList *in_setup) MONO_INTERNAL; +mono_class_check_vtable_constraints (MonoClass *klass, GList *in_setup); gboolean -mono_class_has_finalizer (MonoClass *klass) MONO_INTERNAL; +mono_class_has_finalizer (MonoClass *klass); void -mono_unload_interface_id (MonoClass *class) MONO_INTERNAL; +mono_unload_interface_id (MonoClass *klass); GPtrArray* -mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, MonoException **ex) MONO_INTERNAL; +mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, MonoException **ex); char* -mono_class_full_name (MonoClass *klass) MONO_INTERNAL; +mono_class_full_name (MonoClass *klass); + +MonoClass* +mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext *context, MonoError *error); + +MonoClass * +mono_class_get_checked (MonoImage *image, guint32 type_token, MonoError *error); + +MonoClass * +mono_class_get_and_inflate_typespec_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error); + +MonoClass * +mono_class_from_name_checked (MonoImage *image, const char* name_space, const char *name, MonoError *error); + +MonoClass * +mono_class_from_name_case_checked (MonoImage *image, const char* name_space, const char *name, MonoError *error); + +MonoClassField* +mono_field_from_token_checked (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context, MonoError *error); + +gpointer +mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error); #endif /* __MONO_METADATA_CLASS_INTERBALS_H__ */