mono/metadata/reflection.h

   1 #ifndef __METADATA_REFLECTION_H__
   2 #define __METADATA_REFLECTION_H__
   3
   4 #include <mono/metadata/image.h>
   5 #include <mono/metadata/metadata.h>
   6 #include <mono/metadata/class.h>
   7 #include <mono/metadata/object.h>
   8 #include <mono/utils/mono-hash.h>
   9
  10 typedef struct {
  11         GHashTable *hash;
  12         char *data;
  13         guint32 alloc_size; /* malloced bytes */
  14         guint32 index;
  15         guint32 offset; /* from start of metadata */
  16 } MonoDynamicStream;
  17
  18 typedef struct {
  19         guint32 alloc_rows;
  20         guint32 rows;
  21         guint32 row_size; /*  calculated later with column_sizes */
  22         guint32 columns;
  23         guint32 column_sizes [9];
  24         guint32 *values; /* rows * columns */
  25         guint32 next_idx;
  26 } MonoDynamicTable;
  27
  28 /*
  29  * The followinbg structure must match the C# implementation in our corlib.
  30  */
  31
  32 struct _MonoReflectionMethod {
  33         MonoObject object;
  34         MonoMethod *method;
  35         MonoString *name;
  36         MonoReflectionType *reftype;
  37 };
  38
  39 struct _MonoDelegate {
  40         MonoObject object;
  41         MonoObject *target_type;
  42         MonoObject *target;
  43         MonoString *method_name;
  44         gpointer method_ptr;
  45         gpointer delegate_trampoline;
  46         MonoReflectionMethod *method_info;
  47 };
  48
  49 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
  50 struct _MonoMulticastDelegate {
  51         MonoDelegate delegate;
  52         MonoMulticastDelegate *prev;
  53 };
  54
  55 typedef struct {
  56         MonoObject object;
  57         MonoClass *klass;
  58         MonoClassField *field;
  59         MonoString *name;
  60         MonoReflectionType *type;
  61         guint32 attrs;
  62 } MonoReflectionField;
  63
  64 typedef struct {
  65         MonoObject object;
  66         MonoClass *klass;
  67         MonoProperty *property;
  68 } MonoReflectionProperty;
  69
  70 typedef struct {
  71         MonoObject object;
  72         MonoClass *klass;
  73         MonoEvent *event;
  74 } MonoReflectionEvent;
  75
  76 typedef struct {
  77         MonoObject object;
  78         MonoReflectionType *ClassImpl;
  79         MonoObject *DefaultValueImpl;
  80         MonoObject *MemberImpl;
  81         MonoString *NameImpl;
  82         gint32 PositionImpl;
  83         guint32 AttrsImpl;
  84 } MonoReflectionParameter;
  85
  86 typedef struct {
  87         MonoObject object;
  88         MonoAssembly *assembly;
  89 } MonoReflectionAssembly;
  90
  91 typedef struct {
  92         MonoReflectionType *utype;
  93         MonoArray *values;
  94         MonoArray *names;
  95 } MonoEnumInfo;
  96
  97 typedef struct {
  98         MonoReflectionType *parent;
  99         MonoReflectionType *ret;
 100         guint32 attrs;
 101         guint32 implattrs;
 102         guint32 callconv;
 103 } MonoMethodInfo;
 104
 105 typedef struct {
 106         MonoReflectionType *parent;
 107         MonoString *name;
 108         MonoReflectionMethod *get;
 109         MonoReflectionMethod *set;
 110         guint32 attrs;
 111 } MonoPropertyInfo;
 112
 113 typedef struct {
 114         MonoReflectionType *parent;
 115         MonoString *name;
 116         MonoReflectionMethod *add_method;
 117         MonoReflectionMethod *remove_method;
 118         MonoReflectionMethod *raise_method;
 119         guint32 attrs;
 120 } MonoEventInfo;
 121
 122 typedef struct {
 123         MonoString *name;
 124         MonoString *name_space;
 125         MonoReflectionType *etype;
 126         MonoReflectionType *nested_in;
 127         MonoReflectionAssembly *assembly;
 128         guint32 rank;
 129         MonoBoolean isprimitive;
 130 } MonoTypeInfo;
 131
 132 typedef struct {
 133         MonoObject *member;
 134         gint32 code_pos;
 135 } MonoReflectionILTokenInfo;
 136
 137 typedef struct {
 138         MonoObject object;
 139         MonoArray *code;
 140         gint32 code_len;
 141         gint32 max_stack;
 142         gint32 cur_stack;
 143         MonoArray *locals;
 144         MonoArray *ex_handlers;
 145         gint32 num_token_fixups;
 146         MonoArray *token_fixups;
 147 } MonoReflectionILGen;
 148
 149 typedef struct {
 150         MonoArray *handlers;
 151         gint32 start;
 152         gint32 len;
 153         gint32 label;
 154 } MonoILExceptionInfo;
 155
 156 typedef struct {
 157         MonoReflectionType *extype;
 158         gint32 type;
 159         gint32 start;
 160         gint32 len;
 161         gint32 filter_offset;
 162 } MonoILExceptionBlock;
 163
 164 typedef struct {
 165         MonoObject object;
 166         MonoReflectionType *type;
 167         MonoString *name;
 168 } MonoReflectionLocalBuilder;
 169
 170 typedef struct {
 171         MonoObject object;
 172         gint32 count;
 173         gint32 type;
 174         gint32 eltype;
 175         MonoString *guid;
 176         MonoString *mcookie;
 177         MonoString *marshaltype;
 178         MonoReflectionType *marshaltyperef;
 179 } MonoReflectionMarshal;
 180
 181 typedef struct {
 182         MonoObject object;
 183         MonoObject* methodb;
 184         MonoString *name;
 185         MonoArray *cattrs;
 186         MonoReflectionMarshal *marshal_info;
 187         guint32 attrs;
 188         int position;
 189         guint32 table_idx;
 190 } MonoReflectionParamBuilder;
 191
 192 typedef struct {
 193         MonoObject object;
 194         MonoMethod *mhandle;
 195         MonoReflectionILGen *ilgen;
 196         MonoArray *parameters;
 197         guint32 attrs;
 198         guint32 iattrs;
 199         guint32 table_idx;
 200         guint32 call_conv;
 201         MonoObject *type;
 202         MonoArray *pinfo;
 203         MonoArray *cattrs;
 204         MonoBoolean init_locals;
 205         MonoArray *param_modreq;
 206         MonoArray *param_modopt;
 207         MonoArray *permissions;
 208 } MonoReflectionCtorBuilder;
 209
 210 typedef struct {
 211         MonoObject object;
 212         MonoMethod *mhandle;
 213         MonoReflectionType *rtype;
 214         MonoArray *parameters;
 215         guint32 attrs;
 216         guint32 iattrs;
 217         MonoString *name;
 218         guint32 table_idx;
 219         MonoArray *code;
 220         MonoReflectionILGen *ilgen;
 221         MonoObject *type;
 222         MonoArray *pinfo;
 223         MonoArray *cattrs;
 224         MonoReflectionMethod *override_method;
 225         MonoString *dll;
 226         MonoString *dllentry;
 227         guint32 charset;
 228         guint32 native_cc;
 229         guint32 call_conv;
 230         MonoBoolean init_locals;
 231         MonoArray *generic_params;
 232         MonoArray *return_modreq;
 233         MonoArray *return_modopt;
 234         MonoArray *param_modreq;
 235         MonoArray *param_modopt;
 236         MonoArray *permissions;
 237 } MonoReflectionMethodBuilder;
 238
 239 typedef struct {
 240         MonoObject object;
 241         MonoMethod *mhandle;
 242         MonoReflectionType *parent;
 243         MonoReflectionType *ret;
 244         MonoArray *parameters;
 245         MonoString *name;
 246         guint32 table_idx;
 247         guint32 call_conv;
 248 } MonoReflectionArrayMethod;
 249
 250 /*
 251  * Information which isn't in the MonoMethod structure is stored here for
 252  * dynamic methods.
 253  */
 254 typedef struct {
 255         char **param_names;
 256         MonoMarshalSpec **param_marshall;
 257 } MonoReflectionMethodAux;
 258
 259 enum {
 260         MONO_SECTION_TEXT,
 261         MONO_SECTION_RSRC,
 262         MONO_SECTION_RELOC,
 263         MONO_SECTION_MAX
 264 };
 265
 266 typedef struct {
 267         MonoAssembly assembly;
 268         gboolean run;
 269         gboolean save;
 270         char *strong_name;
 271         guint32 strong_name_size;
 272 } MonoDynamicAssembly;
 273
 274 typedef struct {
 275         MonoImage image;
 276         guint32 meta_size;
 277         guint32 text_rva;
 278         guint32 metadata_rva;
 279         guint32 image_base;
 280         guint32 cli_header_offset;
 281         guint32 iat_offset;
 282         guint32 idt_offset;
 283         guint32 ilt_offset;
 284         guint32 imp_names_offset;
 285         struct {
 286                 guint32 rva;
 287                 guint32 size;
 288                 guint32 offset;
 289                 guint32 attrs;
 290         } sections [MONO_SECTION_MAX];
 291         GHashTable *typeref;
 292         GHashTable *handleref;
 293         MonoGHashTable *tokens;
 294         MonoGHashTable *blob_cache;
 295         GList *array_methods;
 296         MonoGHashTable *token_fixups;
 297         MonoGHashTable *method_to_table_idx;
 298         MonoGHashTable *field_to_table_idx;
 299         MonoGHashTable *method_aux_hash;
 300         gboolean run;
 301         gboolean save;
 302         char *strong_name;
 303         guint32 strong_name_size;
 304         char *win32_res;
 305         guint32 win32_res_size;
 306         MonoDynamicStream pefile;
 307         MonoDynamicStream sheap;
 308         MonoDynamicStream code; /* used to store method headers and bytecode */
 309         MonoDynamicStream resources; /* managed embedded resources */
 310         MonoDynamicStream us;
 311         MonoDynamicStream blob;
 312         MonoDynamicStream tstream;
 313         MonoDynamicStream guid;
 314         MonoDynamicTable tables [64];
 315 } MonoDynamicImage;
 316
 317 typedef struct {
 318         MonoArray *data;
 319         MonoString *name;
 320         MonoString *filename;
 321         guint32 attrs;
 322         guint32 offset;
 323 } MonoReflectionResource;
 324
 325 typedef struct {
 326         guint32 res_type;
 327         guint32 res_id;
 328         guint32 lang_id;
 329         MonoArray *res_data;
 330 } MonoReflectionWin32Resource;
 331
 332 typedef struct {
 333         guint32 action;
 334         MonoString *pset;
 335 } MonoReflectionPermissionSet;
 336
 337 typedef struct {
 338         MonoReflectionAssembly assembly;
 339         MonoDynamicAssembly *dynamic_assembly;
 340         MonoReflectionMethod *entry_point;
 341         MonoArray *modules;
 342         MonoString *name;
 343         MonoString *dir;
 344         MonoArray *cattrs;
 345         MonoArray *resources;
 346         MonoArray *public_key;
 347         MonoString *version;
 348         MonoString *culture;
 349         guint32 algid;
 350         guint32 flags;
 351         guint32 pekind;
 352         MonoBoolean delay_sign;
 353         guint32 access;
 354         MonoArray *loaded_modules;
 355         MonoArray *win32_resources;
 356 } MonoReflectionAssemblyBuilder;
 357
 358 typedef struct {
 359         MonoObject object;
 360         guint32 attrs;
 361         MonoReflectionType *type;
 362         MonoString *name;
 363         MonoObject *def_value;
 364         gint32 offset;
 365         gint32 table_idx;
 366         MonoReflectionType *typeb;
 367         MonoArray *rva_data;
 368         MonoArray *cattrs;
 369         MonoReflectionMarshal *marshal_info;
 370         MonoClassField *handle;
 371         MonoArray *modreq;
 372         MonoArray *modopt;
 373 } MonoReflectionFieldBuilder;
 374
 375 typedef struct {
 376         MonoObject object;
 377         guint32 attrs;
 378         MonoString *name;
 379         MonoReflectionType *type;
 380         MonoArray *parameters;
 381         MonoArray *cattrs;
 382         MonoObject *def_value;
 383         MonoReflectionMethodBuilder *set_method;
 384         MonoReflectionMethodBuilder *get_method;
 385         gint32 table_idx;
 386 } MonoReflectionPropertyBuilder;
 387
 388 typedef struct {
 389         MonoObject      obj;
 390         MonoImage  *image;
 391         MonoReflectionAssembly *assembly;
 392         MonoString *fqname;
 393         MonoString *name;
 394         MonoString *scopename;
 395         MonoBoolean is_resource;
 396 } MonoReflectionModule;
 397
 398 typedef struct {
 399         MonoReflectionModule module;
 400         MonoDynamicImage *dynamic_image;
 401         gint32     num_types;
 402         MonoArray *types;
 403         MonoArray *cattrs;
 404         MonoArray *guid;
 405         guint32    table_idx;
 406         MonoReflectionAssemblyBuilder *assemblyb;
 407         MonoArray *global_methods;
 408         MonoArray *global_fields;
 409         gboolean is_main;
 410         MonoArray *resources;
 411 } MonoReflectionModuleBuilder;
 412
 413 typedef struct {
 414         MonoReflectionType type;
 415         MonoString *name;
 416         MonoString *nspace;
 417         MonoReflectionType *parent;
 418         MonoReflectionType *nesting_type;
 419         MonoArray *interfaces;
 420         gint32     num_methods;
 421         MonoArray *methods;
 422         MonoArray *ctors;
 423         MonoArray *properties;
 424         gint32     num_fields;
 425         MonoArray *fields;
 426         MonoArray *events;
 427         MonoArray *cattrs;
 428         MonoArray *subtypes;
 429         guint32 attrs;
 430         guint32 table_idx;
 431         MonoReflectionModuleBuilder *module;
 432         gint32 class_size;
 433         gint32 packing_size;
 434         MonoArray *generic_params;
 435         MonoArray *permissions;
 436 } MonoReflectionTypeBuilder;
 437
 438 typedef struct {
 439         MonoReflectionType type;
 440         MonoObject *refobj;
 441         guint32 index;
 442         MonoString *name;
 443         guint32 flags;
 444         MonoArray *constraints;
 445         guint32 initialized;
 446 } MonoReflectionGenericParam;
 447
 448 typedef struct _MonoReflectionGenericInst MonoReflectionGenericInst;
 449 struct _MonoReflectionGenericInst {
 450         MonoReflectionType type;
 451         MonoClass *klass;
 452         MonoReflectionGenericInst *parent;
 453         MonoReflectionType *generic_type;
 454         MonoArray *interfaces;
 455         MonoArray *methods;
 456         MonoArray *ctors;
 457         MonoArray *fields;
 458 };
 459
 460 typedef struct {
 461         MonoReflectionMethod rmethod;
 462         MonoReflectionMethod *declaring;
 463         MonoReflectionGenericInst *declaring_type;
 464         MonoReflectionGenericInst *reflected_type;
 465         MonoGenericInst *ginst;
 466 } MonoReflectionInflatedMethod;
 467
 468 typedef struct {
 469         MonoReflectionField rfield;
 470         MonoClassField *declaring;
 471         MonoReflectionGenericInst *declaring_type;
 472         MonoReflectionGenericInst *reflected_type;
 473 } MonoReflectionInflatedField;
 474
 475 typedef struct {
 476         MonoObject  obj;
 477         MonoString *name;
 478         MonoString *codebase;
 479         gint32 major, minor, build, revision;
 480         /* FIXME: add missing stuff */
 481 /*      CultureInfo cultureinfo;
 482         AssemblyNameFlags flags;
 483         AssemblyHashAlgorithm hashalg;
 484         StrongNameKeyPair keypair;
 485         AssemblyVersionCompatibility versioncompat;*/
 486         MonoObject  *cultureInfo;
 487         guint32     flags;
 488         guint32     hashalg;
 489         MonoObject  *keypair;
 490         MonoArray   *publicKey;
 491         MonoArray   *keyToken;
 492         MonoObject  *versioncompat;
 493 } MonoReflectionAssemblyName;
 494
 495 typedef struct {
 496         MonoObject  obj;
 497         MonoString *name;
 498         MonoReflectionType *type;
 499         MonoReflectionTypeBuilder *typeb;
 500         MonoArray *cattrs;
 501         MonoReflectionMethodBuilder *add_method;
 502         MonoReflectionMethodBuilder *remove_method;
 503         MonoReflectionMethodBuilder *raise_method;
 504         MonoArray *other_methods;
 505         guint32 attrs;
 506         guint32 table_idx;
 507 } MonoReflectionEventBuilder;
 508
 509 typedef struct {
 510         MonoObject  obj;
 511         MonoReflectionMethod *ctor;
 512         MonoArray *data;
 513 } MonoReflectionCustomAttr;
 514
 515 typedef struct {
 516         MonoObject object;
 517         MonoMethod *mhandle;
 518         MonoString *name;
 519         MonoReflectionType *rtype;
 520         MonoArray *parameters;
 521         guint32 attrs;
 522         guint32 call_conv;
 523         MonoReflectionModule *module;
 524         MonoBoolean skip_visibility;
 525         MonoBoolean init_locals;
 526         MonoReflectionILGen *ilgen;
 527         gint32 nrefs;
 528         MonoArray *refs;
 529 } MonoReflectionDynamicMethod;
 530
 531 typedef struct MonoTypeNameParse MonoTypeNameParse;
 532
 533 struct MonoTypeNameParse {
 534         char *name_space;
 535         char *name;
 536         MonoAssemblyName assembly;
 537         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 538         GList *nested;
 539 };
 540
 541 typedef struct {
 542         MonoObject object;
 543         MonoReflectionModuleBuilder *module;
 544         MonoArray *arguments;
 545         guint32 type;
 546         MonoReflectionType *return_type;
 547         guint32 call_conv;
 548         guint32 unmanaged_call_conv;
 549 } MonoReflectionSigHelper;
 550
 551 typedef struct {
 552         MonoMethod *ctor;
 553         guint32     data_size;
 554         const guchar* data;
 555 } MonoCustomAttrEntry;
 556
 557 typedef struct {
 558         int num_attrs;
 559         MonoImage *image;
 560         MonoCustomAttrEntry attrs [MONO_ZERO_LEN_ARRAY];
 561 } MonoCustomAttrInfo;
 562
 563 enum {
 564         RESOURCE_LOCATION_EMBEDDED = 1,
 565         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
 566         RESOURCE_LOCATION_IN_MANIFEST = 4
 567 };
 568
 569 typedef struct {
 570         MonoObject object;
 571         MonoReflectionAssembly *assembly;
 572         MonoString *filename;
 573         guint32 location;
 574 } MonoManifestResourceInfo;
 575
 576 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 577 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 578 MonoType*     mono_reflection_type_from_name (char *name, MonoImage *image);
 579
 580 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module);
 581 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 582 MonoReflectionModule * mono_image_load_module (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name);
 583 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str);
 584 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj);
 585 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
 586
 587 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 588 MonoReflectionModule*   mono_module_get_object   (MonoDomain *domain, MonoImage *image);
 589 MonoReflectionModule*   mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index);
 590 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 591 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method, MonoClass *refclass);
 592 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 593 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 594 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 595 /* note: this one is slightly different: we keep the whole array of params in the cache */
 596 MonoArray* mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 597
 598 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 599 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 600
 601 MonoArray*  mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo);
 602 MonoCustomAttrInfo* mono_custom_attrs_from_index    (MonoImage *image, guint32 idx);
 603 MonoCustomAttrInfo* mono_custom_attrs_from_method   (MonoMethod *method);
 604 MonoCustomAttrInfo* mono_custom_attrs_from_class    (MonoClass *klass);
 605 MonoCustomAttrInfo* mono_custom_attrs_from_assembly (MonoAssembly *assembly);
 606 MonoCustomAttrInfo* mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property);
 607 MonoCustomAttrInfo* mono_custom_attrs_from_event    (MonoClass *klass, MonoEvent *event);
 608 MonoCustomAttrInfo* mono_custom_attrs_from_field    (MonoClass *klass, MonoClassField *field);
 609 MonoCustomAttrInfo* mono_custom_attrs_from_param    (MonoMethod *method, guint32 param);
 610 void                mono_custom_attrs_free          (MonoCustomAttrInfo *ainfo);
 611
 612 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 613
 614 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 615
 616 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb);
 617
 618 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 619
 620 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
 621
 622 MonoReflectionGenericParam *mono_reflection_define_generic_parameter (MonoReflectionTypeBuilder *tb, MonoReflectionMethodBuilder *mb, MonoString *name, guint32 index);
 623 void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
 624
 625 MonoReflectionGenericInst*
 626 mono_reflection_bind_generic_parameters (MonoReflectionType *type, MonoArray *types);
 627 MonoReflectionInflatedMethod*
 628 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
 629 MonoReflectionInflatedMethod*
 630 mono_reflection_inflate_method_or_ctor (MonoReflectionGenericInst *declaring_type, MonoReflectionGenericInst *reflected_type, MonoObject *obj);
 631 MonoReflectionInflatedField*
 632 mono_reflection_inflate_field (MonoReflectionGenericInst *declaring_type, MonoReflectionGenericInst *reflected_type, MonoObject *obj);
 633
 634 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 635
 636 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 637
 638 gpointer
 639 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token);
 640
 641 void
 642 mono_image_build_metadata (MonoReflectionModuleBuilder *module);
 643
 644 #endif /* __METADATA_REFLECTION_H__ */
 645