#define __MONO_METADATA_CLASS_INTERBALS_H__
#include <mono/metadata/class.h>
+#include <mono/metadata/object.h>
#include <mono/io-layer/io-layer.h>
#define MONO_CLASS_IS_ARRAY(c) ((c)->rank)
typedef struct _MonoMethodInflated MonoMethodInflated;
typedef struct _MonoMethodPInvoke MonoMethodPInvoke;
+/*
+ * remember to update wrapper_type_names if you change something here
+ */
typedef enum {
MONO_WRAPPER_NONE,
MONO_WRAPPER_DELEGATE_INVOKE,
MONO_WRAPPER_MANAGED_TO_NATIVE,
MONO_WRAPPER_REMOTING_INVOKE,
MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK,
+ MONO_WRAPPER_XDOMAIN_INVOKE,
+ MONO_WRAPPER_XDOMAIN_DISPATCH,
MONO_WRAPPER_LDFLD,
MONO_WRAPPER_STFLD,
+ MONO_WRAPPER_LDFLD_REMOTE,
+ MONO_WRAPPER_STFLD_REMOTE,
MONO_WRAPPER_SYNCHRONIZED,
MONO_WRAPPER_DYNAMIC_METHOD,
MONO_WRAPPER_ISINST,
MONO_WRAPPER_CASTCLASS,
MONO_WRAPPER_PROXY_ISINST,
MONO_WRAPPER_STELEMREF,
+ MONO_WRAPPER_UNBOX,
MONO_WRAPPER_UNKNOWN
} MonoWrapperType;
+typedef enum {
+ MONO_REMOTING_TARGET_UNKNOWN,
+ MONO_REMOTING_TARGET_APPDOMAIN
+} MonoRemotingTarget;
+
struct _MonoMethod {
guint16 flags; /* method flags */
guint16 iflags; /* method implementation flags */
guint32 token;
MonoClass *klass;
MonoMethodSignature *signature;
- gpointer addr;
- gpointer info; /* runtime info */
- gpointer remoting_tramp;
- gint slot;
/* name is useful mostly for debugging */
const char *name;
/* this is used by the inlining algorithm */
unsigned int string_ctor:1;
unsigned int save_lmf:1;
unsigned int dynamic:1; /* created & destroyed during runtime */
- gint16 inline_count;
+ unsigned int is_inflated:1;
+ signed int slot : 21;
};
struct _MonoMethodNormal {
MonoMethod method;
- MonoGenericParam *gen_params;
+ MonoGenericContainer *generic_container;
MonoMethodHeader *header;
};
struct _MonoMethodWrapper {
MonoMethodNormal method;
- GList *data;
+ void *method_data;
};
struct _MonoMethodInflated {
MonoMethodNormal nmethod;
MonoGenericContext *context;
MonoMethod *declaring;
+ MonoMethodInflated *inflated;
};
struct _MonoMethodPInvoke {
MonoMethod method;
- void (*code) (void);
+ gpointer addr;
/* add marshal info */
guint16 piflags; /* pinvoke flags */
guint16 implmap_idx; /* index into IMPLMAP */
typedef struct {
guint32 native_size;
guint32 num_fields;
+ MonoMethod *ptr_to_str;
+ MonoMethod *str_to_ptr;
MonoMarshalField fields [MONO_ZERO_LEN_ARRAY];
} MonoMarshalType;
guint32 attrs;
};
+/* 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
+ /* add other exception type */
+};
+
+/* This struct collects the info needed for the runtime use of a class,
+ * like the vtables for a domain, the GC descriptor, etc.
+ */
+typedef struct {
+ guint16 max_domain;
+ /* domain_vtables is indexed by the domain id and the size is max_domain + 1 */
+ MonoVTable *domain_vtables [MONO_ZERO_LEN_ARRAY];
+} MonoClassRuntimeInfo;
+
struct _MonoClass {
MonoImage *image;
/* used for subtype checks */
MonoClass *cast_class;
/* array dimension */
- guint32 rank;
+ guint8 rank;
guint inited : 1;
/* We use init_pending to detect cyclic calls to mono_class_init */
guint contextbound : 1; /* class is a ContextBoundObject */
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 */
+ guint has_static_refs : 1; /* it has static fields that are GC-tracked */
+
+ guint32 declsec_flags; /* declarative security attributes flags */
+ guint32 exception_type; /* MONO_EXCEPTION_* */
+ void* exception_data; /* Additional information about the exception */
MonoClass *parent;
MonoClass *nested_in;
const char *name;
const char *name_space;
- guint interface_count;
- guint interface_id; /* unique inderface id (for interfaces) */
- guint max_interface_id;
- gint *interface_offsets;
- MonoClass **interfaces;
-
/* for fast subtype checks */
- guint idepth;
MonoClass **supertypes;
+ guint16 idepth;
+
+ guint16 interface_count;
+ guint16 interface_id; /* unique inderface id (for interfaces) */
+ guint16 max_interface_id;
+ gint *interface_offsets;
+ MonoClass **interfaces;
/*
* Computed object instance size, total.
*/
MonoClassField *fields;
+ /* Initialized by a call to mono_class_setup_properties () */
MonoProperty *properties;
-
+
+ /* Initialized by a call to mono_class_setup_events () */
MonoEvent *events;
MonoMethod **methods;
MonoType this_arg;
MonoType byval_arg;
- MonoGenericInst *generic_inst;
- MonoGenericParam *gen_params;
- guint16 num_gen_params;
+ MonoGenericClass *generic_class;
+ MonoGenericContainer *generic_container;
void *reflection_info;
void *gc_descr;
- guint64 gc_bitmap;
- MonoMethod *ptr_to_str;
- MonoMethod *str_to_ptr;
+ MonoClassRuntimeInfo *runtime_info;
- MonoVTable *cached_vtable;
- MonoMethod **vtable;
+ /* Generic vtable. Initialized by a call to mono_class_setup_vtable () */
+ MonoMethod **vtable;
};
struct MonoVTable {
*/
void *gc_descr;
MonoDomain *domain; /* each object/vtable belongs to exactly one domain */
- guint32 max_interface_id;
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 */
/* do not add any fields after vtable, the structure is dynamically extended */
* Generic instantiation data type encoding.
*/
struct _MonoGenericInst {
+ guint id;
+ guint type_argc : 22;
+ guint is_open : 1;
+ guint is_reference : 1;
+ MonoType **type_argv;
+};
+
+struct _MonoGenericClass {
+ MonoGenericInst *inst;
+ MonoClass *container_class;
MonoGenericContext *context;
MonoClass *klass;
MonoType *parent;
- int count_ifaces;
+ guint count_ifaces : 29;
+ guint is_dynamic : 1;
MonoType **ifaces;
- MonoType *generic_type;
- MonoDynamicGenericInst *dynamic_info;
- int type_argc;
- MonoType **type_argv;
- guint is_open : 1;
- guint initialized : 1;
- guint init_pending : 1;
- guint is_dynamic : 1;
};
-struct _MonoDynamicGenericInst {
+struct _MonoDynamicGenericClass {
+ MonoGenericClass generic_class;
int count_methods;
MonoMethod **methods;
int count_ctors;
MonoProperty *properties;
int count_events;
MonoEvent *events;
+ guint initialized;
};
struct _MonoGenericMethod {
+ MonoGenericInst *inst;
+ MonoGenericContainer *container;
gpointer reflection_info;
- int mtype_argc;
- MonoType **mtype_argv;
- guint is_open : 1;
};
struct _MonoGenericContext {
- MonoGenericInst *ginst;
+ MonoGenericContainer *container;
+ MonoGenericClass *gclass;
MonoGenericMethod *gmethod;
};
+struct _MonoGenericContainer {
+ MonoGenericContext context;
+ MonoGenericContainer *parent;
+ GHashTable *method_hash;
+ MonoClass *klass;
+ int type_argc : 6;
+ int is_method : 1;
+ int is_signature : 1;
+ MonoGenericParam *type_params;
+};
+
struct _MonoGenericParam {
+ MonoGenericContainer *owner;
MonoClass *pklass;
MonoMethod *method;
const char *name;
MonoClass** constraints; /* NULL means end of list */
};
+/*
+ * Class information which might be cached by the runtime in the AOT file for
+ * example. Caching this allows us to avoid computing a generic vtable
+ * (class->vtable) in most cases, saving time and avoiding creation of lots of
+ * MonoMethod structures.
+ */
+typedef struct MonoCachedClassInfo {
+ guint32 vtable_size;
+ guint has_finalize : 1;
+ guint ghcimpl : 1;
+ guint has_cctor : 1;
+ guint32 cctor_token;
+ MonoImage *finalize_image;
+ guint32 finalize_token;
+} MonoCachedClassInfo;
+
typedef struct {
const char *name;
gconstpointer func;
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;
gboolean enabled;
extern MonoStats mono_stats;
typedef gpointer (*MonoTrampoline) (MonoMethod *method);
+typedef gpointer (*MonoRemotingTrampoline) (MonoMethod *method, MonoRemotingTarget target);
typedef gpointer (*MonoLookupDynamicToken) (MonoImage *image, guint32 token);
+typedef gboolean (*MonoGetCachedClassInfo) (MonoClass *klass, MonoCachedClassInfo *res);
+
void
mono_classes_init (void);
mono_class_layout_fields (MonoClass *klass);
void
-mono_class_setup_vtable (MonoClass *klass, MonoMethod **overrides, int onum);
+mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum);
+
+void
+mono_class_setup_vtable (MonoClass *klass);
+
+void
+mono_class_setup_methods (MonoClass *klass);
void
mono_class_setup_mono_type (MonoClass *klass);
void
mono_class_setup_supertypes (MonoClass *klass);
+GPtrArray*
+mono_class_get_implemented_interfaces (MonoClass *klass);
+
gboolean
mono_class_is_open_constructed_type (MonoType *t);
MonoMethod**
mono_class_get_overrides (MonoImage *image, guint32 type_token, gint32 *num_overrides);
+MonoMethod*
+mono_class_get_cctor (MonoClass *klass);
+
+MonoMethod*
+mono_class_get_finalizer (MonoClass *klass);
+
gboolean
mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller);
mono_install_trampoline (MonoTrampoline func);
void
-mono_install_remoting_trampoline (MonoTrampoline func);
+mono_install_remoting_trampoline (MonoRemotingTrampoline func);
gpointer
mono_lookup_dynamic_token (MonoImage *image, guint32 token);
void
mono_install_lookup_dynamic_token (MonoLookupDynamicToken func);
+void
+mono_install_get_cached_class_info (MonoGetCachedClassInfo func);
+
+void
+mono_class_create_generic (MonoGenericClass *gclass);
+
typedef struct {
MonoImage *corlib;
MonoClass *object_class;
MonoClass *marshalbyrefobject_class;
MonoClass *monitor_class;
MonoClass *iremotingtypeinfo_class;
+ MonoClass *runtimesecurityframe_class;
} MonoDefaults;
extern MonoDefaults mono_defaults;
mono_loader_lock (void);
void
-mono_loader_unlock (void);
+mono_loader_unlock (void);
void
-mono_init_icall (void);
+mono_icall_init (void);
+
+void
+mono_icall_cleanup (void);
gpointer
mono_method_get_wrapper_data (MonoMethod *method, guint32 id);
void
mono_install_stack_walk (MonoStackWalkImpl func);
-MonoGenericParam *mono_metadata_load_generic_params (MonoImage *image, guint32 token, guint32 *num);
+gboolean
+mono_metadata_has_generic_params (MonoImage *image, guint32 token);
+
+MonoGenericContainer *mono_metadata_load_generic_params (MonoImage *image, guint32 token,
+ MonoGenericContainer *parent_container);
MonoMethodSignature*
mono_create_icall_signature (const char *sigstr);
MonoJitICallInfo *
mono_find_jit_icall_by_addr (gconstpointer addr);
+MonoMethodSignature*
+mono_class_inflate_generic_signature (MonoImage *image, MonoMethodSignature *sig, MonoGenericContext *context);
+
+MonoGenericClass *
+mono_get_shared_generic_class (MonoGenericContainer *container, gboolean is_dynamic);
+
+gboolean
+mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data);
+
+MonoException*
+mono_class_get_exception_for_failure (MonoClass *klass);
+
#endif /* __MONO_METADATA_CLASS_INTERBALS_H__ */
projects / mono.git / blobdiff