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.
  52          */
  53         MonoConstant    *def_value;
  54 } MonoClassField;
  55
  56 typedef struct {
  57         MonoClassField *field;
  58         guint32 offset;
  59         MonoMarshalSpec *mspec;
  60 } MonoMarshalField;
  61
  62 typedef struct {
  63         guint32 native_size;
  64         guint32 num_fields;
  65         MonoMarshalField fields [MONO_ZERO_LEN_ARRAY];
  66 } MonoMarshalType;
  67
  68 typedef struct {
  69         const char *name;
  70         MonoMethod *get;
  71         MonoMethod *set;
  72         guint32 attrs;
  73 } MonoProperty;
  74
  75 typedef struct {
  76         const char *name;
  77         MonoMethod *add;
  78         MonoMethod *remove;
  79         MonoMethod *raise;
  80         MonoMethod **other;
  81         guint32 attrs;
  82 } MonoEvent;
  83
  84 struct _MonoClass {
  85         MonoImage *image;
  86
  87         /* The underlying type of the enum */
  88         MonoType *enum_basetype;
  89         /* element class for arrays and enum */
  90         MonoClass *element_class;
  91         /* used for subtype checks */
  92         MonoClass *cast_class;
  93         /* array dimension */
  94         guint32    rank;
  95
  96         guint inited          : 1;
  97         /* We use init_pending to detect cyclic calls to mono_class_init */
  98         guint init_pending    : 1;
  99
 100         /* A class contains static and non static data. Static data can be
 101          * of the same type as the class itselfs, but it does not influence
 102          * the instance size of the class. To avoid cyclic calls to
 103          * mono_class_init (from mono_class_instance_size ()) we first
 104          * initialise all non static fields. After that we set size_inited
 105          * to 1, because we know the instance size now. After that we
 106          * initialise all static fields.
 107          */
 108         guint size_inited     : 1;
 109         guint valuetype       : 1; /* derives from System.ValueType */
 110         guint enumtype        : 1; /* derives from System.Enum */
 111         guint blittable       : 1; /* class is blittable */
 112         guint unicode         : 1; /* class uses unicode char when marshalled */
 113         guint wastypebuilder  : 1; /* class was created at runtime from a TypeBuilder */
 114         /* next byte */
 115         guint min_align       : 4;
 116         guint packing_size    : 4;
 117         /* next byte */
 118         guint ghcimpl         : 1; /* class has its own GetHashCode impl */
 119         guint has_finalize    : 1; /* class has its own Finalize impl */
 120         guint marshalbyref    : 1; /* class is a MarshalByRefObject */
 121         guint contextbound    : 1; /* class is a ContextBoundObject */
 122         guint delegate        : 1; /* class is a Delegate */
 123         guint gc_descr_inited : 1; /* gc_descr is initialized */
 124         guint dummy           : 1; /* temporary hack */
 125
 126         MonoClass  *parent;
 127         MonoClass  *nested_in;
 128         GList      *nested_classes;
 129
 130         guint32    type_token;
 131         const char *name;
 132         const char *name_space;
 133
 134         guint       interface_count;
 135         guint       interface_id;        /* unique inderface id (for interfaces) */
 136         guint       max_interface_id;
 137         gint       *interface_offsets;
 138         MonoClass **interfaces;
 139
 140         /* for fast subtype checks */
 141         guint       idepth;
 142         MonoClass **supertypes;
 143
 144         /*
 145          * Computed object instance size, total.
 146          */
 147         int        instance_size;
 148         int        class_size;
 149         int        vtable_size; /* number of slots */
 150
 151         /*
 152          * From the TypeDef table
 153          */
 154         guint32    flags;
 155         struct {
 156                 guint32 first, last;
 157                 int count;
 158         } field, method, property, event;
 159
 160         /* loaded on demand */
 161         MonoMarshalType *marshal_info;
 162
 163         /*
 164          * Field information: Type and location from object base
 165          */
 166         MonoClassField *fields;
 167
 168         MonoProperty *properties;
 169
 170         MonoEvent *events;
 171
 172         MonoMethod **methods;
 173
 174         /* used as the type of the this argument and when passing the arg by value */
 175         MonoType this_arg;
 176         MonoType byval_arg;
 177
 178         MonoType *generic_inst;
 179         MonoGenericParam *gen_params;
 180         guint16 num_gen_params;
 181
 182         void *reflection_info;
 183
 184         void *gc_descr;
 185         guint64 gc_bitmap;
 186
 187         MonoMethod *ptr_to_str;
 188         MonoMethod *str_to_ptr;
 189
 190         MonoVTable *cached_vtable;
 191         MonoMethod **vtable;
 192 };
 193
 194 struct MonoVTable {
 195         MonoClass  *klass;
 196     /*
 197          * According to comments in gc_gcj.h, this should be the second word in
 198          * the vtable.
 199          */
 200         void *gc_descr;
 201         MonoDomain *domain;  /* each object/vtable belongs to exactly one domain */
 202         guint       max_interface_id;
 203         gpointer   *interface_offsets;
 204         gpointer    data; /* to store static class data */
 205         guint remote          : 1; /* class is remotely activated */
 206         guint initialized     : 1; /* cctor has been run */
 207         guint initializing    : 1; /* cctor is running */
 208         /* do not add any fields after vtable, the structure is dynamically extended */
 209         gpointer    vtable [MONO_ZERO_LEN_ARRAY];
 210 };
 211
 212 /*
 213  * Generic instantiation data type encoding.
 214  */
 215 struct _MonoGenericInst {
 216         MonoClass *klass;
 217         MonoType *generic_type;
 218         MonoMethod *generic_method;
 219         int type_argc;
 220         MonoType **type_argv;
 221         guint32 is_open;
 222 };
 223
 224 struct _MonoGenericParam {
 225         MonoClass *pklass;
 226         MonoMethod *method;
 227         const char *name;
 228         guint16 flags;
 229         guint16 num;
 230         MonoClass** constraints; /* NULL means end of list */
 231 };
 232
 233 #define mono_class_has_parent(klass,parent) ((klass)->idepth >= (parent)->idepth) && ((klass)->supertypes [(parent)->idepth - 1] == (parent))
 234
 235 typedef struct {
 236         gulong new_object_count;
 237         gulong initialized_class_count;
 238         gulong used_class_count;
 239         gulong class_vtable_size;
 240         gulong class_static_data_size;
 241 } MonoStats;
 242
 243 extern MonoStats mono_stats;
 244
 245 typedef gpointer (*MonoTrampoline)       (MonoMethod *method);
 246
 247 typedef gpointer (*MonoLookupDynamicToken) (MonoImage *image, guint32 token);
 248
 249 void
 250 mono_classes_init (void);
 251
 252 MonoClass *
 253 mono_class_get             (MonoImage *image, guint32 type_token);
 254
 255 void
 256 mono_class_init            (MonoClass *klass);
 257
 258 void
 259 mono_class_layout_fields   (MonoClass *klass);
 260
 261 void
 262 mono_class_setup_vtable    (MonoClass *klass, MonoMethod **overrides, int onum);
 263
 264 MonoVTable *
 265 mono_class_vtable          (MonoDomain *domain, MonoClass *klass);
 266
 267 MonoVTable *
 268 mono_class_proxy_vtable    (MonoDomain *domain, MonoClass *klass);
 269
 270 void
 271 mono_class_setup_mono_type (MonoClass *klass);
 272
 273 void
 274 mono_class_setup_parent    (MonoClass *klass, MonoClass *parent);
 275
 276 void
 277 mono_class_setup_supertypes (MonoClass *klass);
 278
 279 MonoClass *
 280 mono_class_from_name       (MonoImage *image, const char* name_space, const char *name);
 281
 282 MonoClass *
 283 mono_class_from_name_case  (MonoImage *image, const char* name_space, const char *name);
 284
 285 MonoClass *
 286 mono_class_from_typeref    (MonoImage *image, guint32 type_token);
 287
 288 gboolean
 289 mono_class_is_open_constructed_type (MonoType *t);
 290
 291 MonoClass *
 292 mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar);
 293
 294 MonoClass*
 295 mono_class_from_generic    (MonoType *gtype, gboolean inflate_methods);
 296
 297 MonoType*
 298 mono_class_inflate_generic_type (MonoType *type, MonoGenericInst *ginst);
 299
 300 MonoMethodSignature*
 301 mono_class_inflate_generic_signature (MonoImage *image, MonoMethodSignature *sig, MonoGenericInst *ginst);
 302
 303 MonoMethod*
 304 mono_class_inflate_generic_method (MonoMethod *method, MonoGenericInst *ginst);
 305
 306 MonoClass*
 307 mono_class_create_from_generic (MonoImage *image, MonoType *gtype);
 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_ */