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