mono/metadata/class.h

   1 #ifndef _MONO_CLI_CLASS_H_
   2 #define _MONO_CLI_CLASS_H_
   3
   4 #include <mono/metadata/metadata.h>
   5 #include <mono/metadata/image.h>
   6 #include <mono/metadata/loader.h>
   7
   8 #define MONO_CLASS_IS_ARRAY(c) ((c)->rank)
   9
  10 #define MONO_DEFAULT_SUPERTABLE_SIZE 6
  11
  12 extern gboolean mono_print_vtable;
  13 typedef struct MonoVTable MonoVTable;
  14
  15 typedef struct {
  16         MonoTypeEnum type;
  17         gpointer value;
  18 } MonoConstant;
  19
  20 /*
  21  * MonoClassField is just a runtime representation of the metadata for
  22  * field, it doesn't contain the data directly.  Static fields are
  23  * stored in MonoVTable->data.  Instance fields are allocated in the
  24  * objects after the object header.
  25  */
  26 typedef struct {
  27         /* Type of the field */
  28         MonoType        *type;
  29
  30         /*
  31          * Offset where this field is stored; if it is an instance
  32          * field, it's the offset from the start of the object, if
  33          * it's static, it's from the start of the memory chunk
  34          * allocated for statics for the class.
  35          */
  36         int              offset;
  37
  38         const char      *name;
  39
  40         /*
  41          * Pointer to the data (from the RVA address, valid only for
  42          * fields with the has rva flag).
  43          */
  44         const char      *data;
  45
  46         /* Type where the field was defined */
  47         MonoClass       *parent;
  48
  49         /*
  50          * If the field is constant, pointer to the metadata where the
  51          * constant value can be loaded. Initialized lazily during vtable creation.
  52          */
  53         MonoConstant    *def_value;
  54 } MonoClassField;
  55
  56 /* a field is ignored if it's named "_Deleted" and it has the specialname and rtspecialname flags set */
  57 #define mono_field_is_deleted(field) ((field)->name[0] == '_' && ((field)->type->attrs & 0x600) && (strcmp ((field)->name, "_Deleted") == 0))
  58
  59 typedef struct {
  60         MonoClassField *field;
  61         guint32 offset;
  62         MonoMarshalSpec *mspec;
  63 } MonoMarshalField;
  64
  65 typedef struct {
  66         guint32 native_size;
  67         guint32 num_fields;
  68         MonoMarshalField fields [MONO_ZERO_LEN_ARRAY];
  69 } MonoMarshalType;
  70
  71 typedef struct {
  72         const char *name;
  73         MonoMethod *get;
  74         MonoMethod *set;
  75         guint32 attrs;
  76 } MonoProperty;
  77
  78 typedef struct {
  79         const char *name;
  80         MonoMethod *add;
  81         MonoMethod *remove;
  82         MonoMethod *raise;
  83         MonoMethod **other;
  84         guint32 attrs;
  85 } MonoEvent;
  86
  87 struct _MonoClass {
  88         MonoImage *image;
  89
  90         /* The underlying type of the enum */
  91         MonoType *enum_basetype;
  92         /* element class for arrays and enum */
  93         MonoClass *element_class;
  94         /* used for subtype checks */
  95         MonoClass *cast_class;
  96         /* array dimension */
  97         guint32    rank;
  98
  99         guint inited          : 1;
 100         /* We use init_pending to detect cyclic calls to mono_class_init */
 101         guint init_pending    : 1;
 102
 103         /* A class contains static and non static data. Static data can be
 104          * of the same type as the class itselfs, but it does not influence
 105          * the instance size of the class. To avoid cyclic calls to
 106          * mono_class_init (from mono_class_instance_size ()) we first
 107          * initialise all non static fields. After that we set size_inited
 108          * to 1, because we know the instance size now. After that we
 109          * initialise all static fields.
 110          */
 111         guint size_inited     : 1;
 112         guint valuetype       : 1; /* derives from System.ValueType */
 113         guint enumtype        : 1; /* derives from System.Enum */
 114         guint blittable       : 1; /* class is blittable */
 115         guint unicode         : 1; /* class uses unicode char when marshalled */
 116         guint wastypebuilder  : 1; /* class was created at runtime from a TypeBuilder */
 117         /* next byte */
 118         guint min_align       : 4;
 119         guint packing_size    : 4;
 120         /* next byte */
 121         guint ghcimpl         : 1; /* class has its own GetHashCode impl */
 122         guint has_finalize    : 1; /* class has its own Finalize impl */
 123         guint marshalbyref    : 1; /* class is a MarshalByRefObject */
 124         guint contextbound    : 1; /* class is a ContextBoundObject */
 125         guint delegate        : 1; /* class is a Delegate */
 126         guint gc_descr_inited : 1; /* gc_descr is initialized */
 127         guint dummy           : 1; /* temporary hack */
 128
 129         MonoClass  *parent;
 130         MonoClass  *nested_in;
 131         GList      *nested_classes;
 132
 133         guint32    type_token;
 134         const char *name;
 135         const char *name_space;
 136
 137         guint       interface_count;
 138         guint       interface_id;        /* unique inderface id (for interfaces) */
 139         guint       max_interface_id;
 140         gint       *interface_offsets;
 141         MonoClass **interfaces;
 142
 143         /* for fast subtype checks */
 144         guint       idepth;
 145         MonoClass **supertypes;
 146
 147         /*
 148          * Computed object instance size, total.
 149          */
 150         int        instance_size;
 151         int        class_size;
 152         int        vtable_size; /* number of slots */
 153
 154         /*
 155          * From the TypeDef table
 156          */
 157         guint32    flags;
 158         struct {
 159                 guint32 first, last;
 160                 int count;
 161         } field, method, property, event;
 162
 163         /* loaded on demand */
 164         MonoMarshalType *marshal_info;
 165
 166         /*
 167          * Field information: Type and location from object base
 168          */
 169         MonoClassField *fields;
 170
 171         MonoProperty *properties;
 172
 173         MonoEvent *events;
 174
 175         MonoMethod **methods;
 176
 177         /* used as the type of the this argument and when passing the arg by value */
 178         MonoType this_arg;
 179         MonoType byval_arg;
 180
 181         MonoType *generic_inst;
 182         MonoGenericParam *gen_params;
 183         guint16 num_gen_params;
 184
 185         void *reflection_info;
 186
 187         void *gc_descr;
 188         guint64 gc_bitmap;
 189
 190         MonoMethod *ptr_to_str;
 191         MonoMethod *str_to_ptr;
 192
 193         MonoVTable *cached_vtable;
 194         MonoMethod **vtable;
 195 };
 196
 197 struct MonoVTable {
 198         MonoClass  *klass;
 199     /*
 200          * According to comments in gc_gcj.h, this should be the second word in
 201          * the vtable.
 202          */
 203         void *gc_descr;
 204         MonoDomain *domain;  /* each object/vtable belongs to exactly one domain */
 205         guint       max_interface_id;
 206         gpointer   *interface_offsets;
 207         gpointer    data; /* to store static class data */
 208         guint remote          : 1; /* class is remotely activated */
 209         guint initialized     : 1; /* cctor has been run */
 210         guint initializing    : 1; /* cctor is running */
 211         /* do not add any fields after vtable, the structure is dynamically extended */
 212         gpointer    vtable [MONO_ZERO_LEN_ARRAY];
 213 };
 214
 215 /*
 216  * Generic instantiation data type encoding.
 217  */
 218 struct _MonoGenericInst {
 219         MonoClass *klass;
 220         MonoType *generic_type;
 221         MonoMethod *generic_method;
 222         int type_argc;
 223         MonoType **type_argv;
 224         guint32 is_open;
 225 };
 226
 227 struct _MonoGenericParam {
 228         MonoClass *pklass;
 229         MonoMethod *method;
 230         const char *name;
 231         guint16 flags;
 232         guint16 num;
 233         MonoClass** constraints; /* NULL means end of list */
 234 };
 235
 236 #define mono_class_has_parent(klass,parent) ((klass)->idepth >= (parent)->idepth) && ((klass)->supertypes [(parent)->idepth - 1] == (parent))
 237
 238 typedef struct {
 239         gulong new_object_count;
 240         gulong initialized_class_count;
 241         gulong used_class_count;
 242         gulong class_vtable_size;
 243         gulong class_static_data_size;
 244 } MonoStats;
 245
 246 extern MonoStats mono_stats;
 247
 248 typedef gpointer (*MonoTrampoline)       (MonoMethod *method);
 249
 250 typedef gpointer (*MonoLookupDynamicToken) (MonoImage *image, guint32 token);
 251
 252 void
 253 mono_classes_init (void);
 254
 255 MonoClass *
 256 mono_class_get             (MonoImage *image, guint32 type_token);
 257
 258 void
 259 mono_class_init            (MonoClass *klass);
 260
 261 void
 262 mono_class_layout_fields   (MonoClass *klass);
 263
 264 void
 265 mono_class_setup_vtable    (MonoClass *klass, MonoMethod **overrides, int onum);
 266
 267 MonoVTable *
 268 mono_class_vtable          (MonoDomain *domain, MonoClass *klass);
 269
 270 MonoVTable *
 271 mono_class_proxy_vtable    (MonoDomain *domain, MonoClass *klass);
 272
 273 void
 274 mono_class_setup_mono_type (MonoClass *klass);
 275
 276 void
 277 mono_class_setup_parent    (MonoClass *klass, MonoClass *parent);
 278
 279 void
 280 mono_class_setup_supertypes (MonoClass *klass);
 281
 282 MonoClass *
 283 mono_class_from_name       (MonoImage *image, const char* name_space, const char *name);
 284
 285 MonoClass *
 286 mono_class_from_name_case  (MonoImage *image, const char* name_space, const char *name);
 287
 288 MonoClass *
 289 mono_class_from_typeref    (MonoImage *image, guint32 type_token);
 290
 291 gboolean
 292 mono_class_is_open_constructed_type (MonoType *t);
 293
 294 MonoClass *
 295 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar);
 296
 297 MonoClass*
 298 mono_class_from_generic    (MonoType *gtype, gboolean inflate_methods);
 299
 300 MonoType*
 301 mono_class_inflate_generic_type (MonoType *type, MonoGenericInst *ginst);
 302
 303 MonoMethodSignature*
 304 mono_class_inflate_generic_signature (MonoImage *image, MonoMethodSignature *sig, MonoGenericInst *ginst);
 305
 306 MonoMethod*
 307 mono_class_inflate_generic_method (MonoMethod *method, MonoGenericInst *ginst);
 308
 309 void
 310 mono_class_initialize_generic (MonoClass *class, gboolean inflate_methods);
 311
 312 MonoClassField*
 313 mono_field_from_memberref  (MonoImage *image, guint32 token, MonoClass **retklass);
 314
 315 MonoClassField*
 316 mono_field_from_token      (MonoImage *image, guint32 token, MonoClass **retklass);
 317
 318 MonoMethod**
 319 mono_class_get_overrides   (MonoImage *image, guint32 type_token, gint32 *num_overrides);
 320
 321 MonoClass *
 322 mono_array_class_get       (MonoClass *element_class, guint32 rank);
 323
 324 MonoClass *
 325 mono_ptr_class_get         (MonoType *type);
 326
 327 MonoClassField *
 328 mono_class_get_field       (MonoClass *klass, guint32 field_token);
 329
 330 MonoClassField *
 331 mono_class_get_field_from_name (MonoClass *klass, const char *name);
 332
 333 MonoProperty*
 334 mono_class_get_property_from_name (MonoClass *klass, const char *name);
 335
 336 gint32
 337 mono_array_element_size    (MonoClass *ac);
 338
 339 gint32
 340 mono_class_instance_size   (MonoClass *klass);
 341
 342 gint32
 343 mono_class_array_element_size (MonoClass *klass);
 344
 345 gint32
 346 mono_class_data_size       (MonoClass *klass);
 347
 348 gint32
 349 mono_class_value_size      (MonoClass *klass, guint32 *align);
 350
 351 gint32
 352 mono_class_min_align       (MonoClass *klass);
 353
 354 MonoClass *
 355 mono_class_from_mono_type  (MonoType *type);
 356
 357 gboolean
 358 mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc,
 359                                                    gboolean check_interfaces);
 360
 361 gboolean
 362 mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass);
 363
 364 gboolean
 365 mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller);
 366
 367 gpointer
 368 mono_ldtoken               (MonoImage *image, guint32 token, MonoClass **retclass);
 369
 370 char*
 371 mono_type_get_name         (MonoType *type);
 372
 373 void
 374 mono_install_trampoline (MonoTrampoline func);
 375
 376 void
 377 mono_install_remoting_trampoline (MonoTrampoline func);
 378
 379 gpointer
 380 mono_lookup_dynamic_token (MonoImage *image, guint32 token);
 381
 382 void
 383 mono_install_lookup_dynamic_token (MonoLookupDynamicToken func);
 384
 385 void
 386 mono_install_get_config_dir(void);
 387
 388 #endif /* _MONO_CLI_CLASS_H_ */