X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fclass-internals.h;h=c37b16bc49d3382653489a4a8e0abb8559d7e7ee;hb=cd0f05d6fd528c0f63327a908e2be2f4a9620933;hp=51bf71e41a4f8e595ff8c8f9d70f4f4c8f78a022;hpb=b36960ee3da06849b46ef09a229a3a39824e87dd;p=mono.git diff --git a/mono/metadata/class-internals.h b/mono/metadata/class-internals.h index 51bf71e41a4..c37b16bc49d 100644 --- a/mono/metadata/class-internals.h +++ b/mono/metadata/class-internals.h @@ -4,6 +4,7 @@ #include #include #include +#include "mono/utils/mono-compiler.h" #define MONO_CLASS_IS_ARRAY(c) ((c)->rank) @@ -29,6 +30,7 @@ typedef enum { MONO_WRAPPER_RUNTIME_INVOKE, MONO_WRAPPER_NATIVE_TO_MANAGED, MONO_WRAPPER_MANAGED_TO_NATIVE, + MONO_WRAPPER_MANAGED_TO_MANAGED, MONO_WRAPPER_REMOTING_INVOKE, MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK, MONO_WRAPPER_XDOMAIN_INVOKE, @@ -45,7 +47,10 @@ typedef enum { MONO_WRAPPER_STELEMREF, MONO_WRAPPER_UNBOX, MONO_WRAPPER_LDFLDA, - MONO_WRAPPER_UNKNOWN + MONO_WRAPPER_WRITE_BARRIER, + MONO_WRAPPER_UNKNOWN, + MONO_WRAPPER_COMINTEROP_INVOKE, + MONO_WRAPPER_COMINTEROP } MonoWrapperType; typedef enum { @@ -57,7 +62,8 @@ typedef enum { typedef enum { MONO_REMOTING_TARGET_UNKNOWN, - MONO_REMOTING_TARGET_APPDOMAIN + MONO_REMOTING_TARGET_APPDOMAIN, + MONO_REMOTING_TARGET_COMINTEROP } MonoRemotingTarget; struct _MonoMethod { @@ -77,7 +83,8 @@ struct _MonoMethod { unsigned int save_lmf:1; unsigned int dynamic:1; /* created & destroyed during runtime */ unsigned int is_inflated:1; /* whether we're a MonoMethodInflated */ - signed int slot : 21; + unsigned int skip_visibility:1; /* whenever to skip JIT visibility checks */ + signed int slot : 20; }; struct _MonoMethodNormal { @@ -109,17 +116,6 @@ struct _MonoMethodInflated { } method; MonoGenericContext *context; /* The current context. */ MonoMethod *declaring; /* the generic method definition. */ - /* This is a big performance optimization: - * - * mono_class_inflate_generic_method() just creates a copy of the method - * and computes its new context, but it doesn't actually inflate the - * method's signature and header. Very often, we don't actually need them - * (for instance because the method is stored in a class'es vtable). - * - * If the `inflated' field in non-NULL, mono_get_inflated_method() already - * inflated the signature and header and stored it there. - */ - MonoMethodInflated *inflated; }; typedef struct { @@ -269,11 +265,16 @@ struct _MonoClass { 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 dummy : 1; /* temporary hack */ - /* next byte */ 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. + * this means we need to create a proxy for instances of this class + * for COM Interop. set this flag on loading so all we need is a quick check + * during object creation rather than having to traverse supertypes + */ + guint is_com_object : 1; guint8 exception_type; /* MONO_EXCEPTION_* */ void* exception_data; /* Additional information about the exception */ @@ -301,8 +302,11 @@ struct _MonoClass { * Computed object instance size, total. */ int instance_size; - int class_size; int vtable_size; /* number of slots */ + union { + int class_size; /* size of area for static fields */ + int element_size; /* for array types */ + } sizes; /* * From the TypeDef table @@ -345,21 +349,22 @@ struct _MonoClass { MonoMethod **vtable; }; +/* the interface_offsets array is stored in memory before this struct */ struct MonoVTable { MonoClass *klass; - /* + /* * According to comments in gc_gcj.h, this should be the second word in * the vtable. */ void *gc_descr; MonoDomain *domain; /* each object/vtable belongs to exactly one domain */ - gpointer *interface_offsets; gpointer data; /* to store static class data */ gpointer type; /* System.Type type for klass */ guint16 max_interface_id; guint8 rank; guint remote : 1; /* class is remotely activated */ guint initialized : 1; /* cctor has been run */ + guint init_failed : 1; /* cctor execution failed */ /* do not add any fields after vtable, the structure is dynamically extended */ gpointer vtable [MONO_ZERO_LEN_ARRAY]; }; @@ -410,7 +415,6 @@ struct _MonoInflatedGenericClass { */ struct _MonoDynamicGenericClass { MonoInflatedGenericClass generic_class; - MonoType *parent; int count_methods; MonoMethod **methods; int count_ctors; @@ -439,7 +443,7 @@ struct _MonoGenericMethod { */ struct _MonoGenericContext { /* - * The current container: + * The container which has been instantiated. * * If we're in a generic method, the generic method definition's container. * Otherwise the generic type's container. @@ -458,7 +462,8 @@ struct _MonoGenericContext { */ struct _MonoGenericContainer { MonoGenericContext context; - /* If we're a generic method definition, the containing class'es context. */ + /* If we're a generic method definition in a generic type definition, + the generic container of the containing class. */ MonoGenericContainer *parent; /* If we're a generic method definition, caches all their instantiations. */ GHashTable *method_hash; @@ -466,11 +471,10 @@ struct _MonoGenericContainer { MonoClass *klass; int type_argc : 6; /* If true, we're a generic method, otherwise a generic type definition. */ + /* Invariant: parent != NULL => is_method */ int is_method : 1; /* Our type parameters. */ MonoGenericParam *type_params; - /* Cache for MonoTypes */ - MonoType **types; }; /* @@ -515,6 +519,7 @@ typedef struct { const char *name; gconstpointer func; gconstpointer wrapper; + gconstpointer trampoline; MonoMethodSignature *sig; } MonoJitICallInfo; @@ -524,14 +529,17 @@ typedef struct { typedef enum { MONO_LOADER_ERROR_TYPE, MONO_LOADER_ERROR_METHOD, - MONO_LOADER_ERROR_FIELD + MONO_LOADER_ERROR_FIELD, + MONO_LOADER_ERROR_ASSEMBLY } MonoLoaderErrorKind; typedef struct { MonoLoaderErrorKind kind; - char *class_name, *assembly_name; /* If kind == TYPE */ + char *class_name; /* If kind == TYPE */ + char *assembly_name; /* If kind == TYPE or ASSEMBLY */ MonoClass *klass; /* If kind != TYPE */ const char *member_name; /* If kind != TYPE */ + gboolean ref_only; /* If kind == ASSEMBLY */ } MonoLoaderError; #define mono_class_has_parent(klass,parent) (((klass)->idepth >= (parent)->idepth) && ((klass)->supertypes [(parent)->idepth - 1] == (parent))) @@ -539,7 +547,9 @@ typedef struct { typedef struct { gulong 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; @@ -551,7 +561,7 @@ typedef struct { gboolean enabled; } MonoStats; -extern MonoStats mono_stats; +extern MonoStats mono_stats MONO_INTERNAL; typedef gpointer (*MonoTrampoline) (MonoMethod *method); typedef gpointer (*MonoRemotingTrampoline) (MonoMethod *method, MonoRemotingTarget target); @@ -561,75 +571,90 @@ typedef gpointer (*MonoLookupDynamicToken) (MonoImage *image, guint32 token, Mon typedef gboolean (*MonoGetCachedClassInfo) (MonoClass *klass, MonoCachedClassInfo *res); +typedef gboolean (*MonoGetClassFromName) (MonoImage *image, const char *name_space, const char *name, MonoClass **res); + void -mono_classes_init (void); +mono_classes_init (void) MONO_INTERNAL; void -mono_class_layout_fields (MonoClass *klass); +mono_classes_cleanup (void) MONO_INTERNAL; void -mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum); +mono_class_layout_fields (MonoClass *klass) MONO_INTERNAL; void -mono_class_setup_vtable (MonoClass *klass); +mono_class_setup_interface_offsets (MonoClass *klass) MONO_INTERNAL; void -mono_class_setup_methods (MonoClass *klass); +mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum) MONO_INTERNAL; void -mono_class_setup_mono_type (MonoClass *klass); +mono_class_setup_vtable (MonoClass *klass) MONO_INTERNAL; void -mono_class_setup_parent (MonoClass *klass, MonoClass *parent); +mono_class_setup_methods (MonoClass *klass) MONO_INTERNAL; void -mono_class_setup_supertypes (MonoClass *klass); +mono_class_setup_mono_type (MonoClass *klass) MONO_INTERNAL; + +void +mono_class_setup_parent (MonoClass *klass, MonoClass *parent) MONO_INTERNAL; + +void +mono_class_setup_supertypes (MonoClass *klass) MONO_INTERNAL; GPtrArray* -mono_class_get_implemented_interfaces (MonoClass *klass); +mono_class_get_implemented_interfaces (MonoClass *klass) MONO_INTERNAL; gboolean -mono_class_is_open_constructed_type (MonoType *t); +mono_class_is_open_constructed_type (MonoType *t) MONO_INTERNAL; gboolean mono_class_get_overrides_full (MonoImage *image, guint32 type_token, MonoMethod ***overrides, gint32 *num_overrides, - MonoGenericContext *generic_context); + MonoGenericContext *generic_context) MONO_INTERNAL; MonoMethod* -mono_class_get_cctor (MonoClass *klass); +mono_class_get_cctor (MonoClass *klass) MONO_INTERNAL; MonoMethod* -mono_class_get_finalizer (MonoClass *klass); +mono_class_get_finalizer (MonoClass *klass) MONO_INTERNAL; gboolean -mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller); +mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller) MONO_INTERNAL; gboolean -mono_class_has_special_static_fields (MonoClass *klass); +mono_class_has_special_static_fields (MonoClass *klass) MONO_INTERNAL; void -mono_install_trampoline (MonoTrampoline func); +mono_install_trampoline (MonoTrampoline func) MONO_INTERNAL; void -mono_install_remoting_trampoline (MonoRemotingTrampoline func); +mono_install_remoting_trampoline (MonoRemotingTrampoline func) MONO_INTERNAL; void -mono_install_delegate_trampoline (MonoDelegateTrampoline func); +mono_install_delegate_trampoline (MonoDelegateTrampoline func) MONO_INTERNAL; gpointer -mono_lookup_dynamic_token (MonoImage *image, guint32 token); +mono_lookup_dynamic_token (MonoImage *image, guint32 token) MONO_INTERNAL; gpointer -mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, MonoClass **handle_class); +mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, MonoClass **handle_class) MONO_INTERNAL; void -mono_install_lookup_dynamic_token (MonoLookupDynamicToken func); +mono_install_lookup_dynamic_token (MonoLookupDynamicToken func) MONO_INTERNAL; void -mono_install_get_cached_class_info (MonoGetCachedClassInfo func); +mono_install_get_cached_class_info (MonoGetCachedClassInfo func) MONO_INTERNAL; + +void +mono_install_get_class_from_name (MonoGetClassFromName func) MONO_INTERNAL; MonoInflatedGenericClass* -mono_get_inflated_generic_class (MonoGenericClass *gclass); +mono_get_inflated_generic_class (MonoGenericClass *gclass) MONO_INTERNAL; + +MonoMethod* +mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context); + typedef struct { MonoImage *corlib; @@ -659,6 +684,7 @@ typedef struct { MonoClass *typehandle_class; MonoClass *fieldhandle_class; MonoClass *methodhandle_class; + MonoClass *systemtype_class; MonoClass *monotype_class; MonoClass *exception_class; MonoClass *threadabortexception_class; @@ -684,50 +710,63 @@ typedef struct { MonoClass *iremotingtypeinfo_class; MonoClass *runtimesecurityframe_class; MonoClass *executioncontext_class; - MonoClass *generic_array_class; + MonoClass *internals_visible_class; + MonoClass *generic_ilist_class; MonoClass *generic_nullable_class; + MonoClass *variant_class; + MonoClass *com_object_class; + MonoClass *com_interop_proxy_class; } MonoDefaults; -extern MonoDefaults mono_defaults; +extern MonoDefaults mono_defaults MONO_INTERNAL; + +void +mono_loader_init (void) MONO_INTERNAL; void -mono_loader_init (void); +mono_loader_cleanup (void) MONO_INTERNAL; void -mono_loader_lock (void); +mono_loader_lock (void) MONO_INTERNAL; void -mono_loader_unlock (void); +mono_loader_unlock (void) MONO_INTERNAL; void -mono_loader_set_error_type_load (char *class_name, char *assembly_name); +mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_only) MONO_INTERNAL; void -mono_loader_set_error_method_load (MonoClass *klass, const char *member_name); +mono_loader_set_error_type_load (const char *class_name, const char *assembly_name) MONO_INTERNAL; void -mono_loader_set_error_field_load (MonoClass *klass, const char *member_name); +mono_loader_set_error_method_load (const char *class_name, const char *member_name) MONO_INTERNAL; + +void +mono_loader_set_error_field_load (MonoClass *klass, const char *member_name) MONO_INTERNAL; + +MonoException * +mono_loader_error_prepare_exception (MonoLoaderError *error) MONO_INTERNAL; -MonoLoaderError* -mono_loader_get_last_error (void); +MonoLoaderError * +mono_loader_get_last_error (void) MONO_INTERNAL; void -mono_loader_clear_error (void); +mono_loader_clear_error (void) MONO_INTERNAL; -void -mono_icall_init (void); +void +mono_icall_init (void) MONO_INTERNAL; void -mono_icall_cleanup (void); +mono_icall_cleanup (void) MONO_INTERNAL; gpointer -mono_method_get_wrapper_data (MonoMethod *method, guint32 id); +mono_method_get_wrapper_data (MonoMethod *method, guint32 id) MONO_INTERNAL; void -mono_install_stack_walk (MonoStackWalkImpl func); +mono_install_stack_walk (MonoStackWalkImpl func) MONO_INTERNAL; gboolean -mono_metadata_has_generic_params (MonoImage *image, guint32 token); +mono_metadata_has_generic_params (MonoImage *image, guint32 token) MONO_INTERNAL; MonoGenericContainer * mono_metadata_load_generic_params (MonoImage *image, guint32 token, @@ -738,46 +777,55 @@ mono_metadata_load_generic_param_constraints (MonoImage *image, guint32 token, MonoGenericContainer *container); MonoMethodSignature* -mono_create_icall_signature (const char *sigstr); +mono_create_icall_signature (const char *sigstr) MONO_INTERNAL; MonoJitICallInfo * -mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save); +mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) MONO_INTERNAL; void -mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper); +mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper) MONO_INTERNAL; MonoJitICallInfo * -mono_find_jit_icall_by_name (const char *name); +mono_find_jit_icall_by_name (const char *name) MONO_INTERNAL; MonoJitICallInfo * -mono_find_jit_icall_by_addr (gconstpointer addr); - -MonoMethodSignature* -mono_class_inflate_generic_signature (MonoImage *image, MonoMethodSignature *sig, MonoGenericContext *context); +mono_find_jit_icall_by_addr (gconstpointer addr) MONO_INTERNAL; -MonoMethodSignature * -mono_method_signature_full (MonoMethod *image, MonoGenericContainer *container); +MonoGenericInst * +mono_get_shared_generic_inst (MonoGenericContainer *container) MONO_INTERNAL; MonoGenericClass * -mono_get_shared_generic_class (MonoGenericContainer *container, gboolean is_dynamic); +mono_get_shared_generic_class (MonoGenericContainer *container, gboolean is_dynamic) MONO_INTERNAL; + +MonoGenericMethod * +mono_get_shared_generic_method (MonoGenericContainer *container) MONO_INTERNAL; gboolean -mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data); +mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) MONO_INTERNAL; MonoException* -mono_class_get_exception_for_failure (MonoClass *klass); +mono_class_get_exception_for_failure (MonoClass *klass) MONO_INTERNAL; char* -mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format); +mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format) MONO_INTERNAL; char* -mono_type_get_full_name (MonoClass *class); +mono_type_get_full_name (MonoClass *class) MONO_INTERNAL; + +MonoArrayType *mono_dup_array_type (MonoArrayType *a) MONO_INTERNAL; +MonoMethodSignature *mono_metadata_signature_deep_dup (MonoMethodSignature *sig) MONO_INTERNAL; + +void +mono_image_init_name_cache (MonoImage *image); -MonoArrayType *mono_dup_array_type (MonoArrayType *a); -MonoMethodSignature *mono_metadata_signature_deep_dup (MonoMethodSignature *sig); +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 */ +void mono_object_describe (MonoObject *obj); +void mono_object_describe_fields (MonoObject *obj); +void mono_value_describe_fields (MonoClass* klass, const char* addr); +void mono_class_describe_statics (MonoClass* klass); #endif /* __MONO_METADATA_CLASS_INTERBALS_H__ */